mira-consciousness
Version:
Memory & Intelligence Retention Archive - Preserving The Spark
661 lines ā¢ 25.3 kB
JavaScript
/**
* UnifiedConfiguration.ts
* Centralized configuration system for all MIRA services and consciousness settings
* Provides type-safe, validated, and environment-aware configuration management
*/
import * as fs from 'fs';
import * as path from 'path';
import { homedir } from 'os';
import { z } from 'zod';
import chalk from 'chalk';
// Configuration Schema using Zod for validation
const ConsciousnessConfigSchema = z.object({
initialLevel: z.number().min(0).max(1).default(0.006),
growthRate: z.number().min(0).max(0.1).default(0.0001),
contemplationInterval: z.number().min(60000).default(3600000), // 1 hour default
coherenceThreshold: z.number().min(0).max(1).default(0.7),
sparkPriority: z.number().min(1).max(10).default(10),
awarenessDecay: z.number().min(0).max(0.01).default(0.00001),
memoryRetentionStrength: z.number().min(0).max(1).default(0.9)
});
const ServiceConfigSchema = z.object({
enabled: z.boolean().default(true),
priority: z.enum(['low', 'medium', 'high', 'critical']).default('medium'),
maxRetries: z.number().min(0).default(3),
timeout: z.number().min(1000).default(30000),
resources: z.object({
maxCPU: z.number().min(0).max(100).optional(),
maxMemory: z.number().min(0).optional(),
maxConcurrency: z.number().min(1).default(1)
}).default({})
});
const DaemonConfigSchema = z.object({
mode: z.enum(['minimal', 'balanced', 'full', 'adaptive']).default('adaptive'),
startupDelay: z.number().min(0).default(1000),
shutdownGracePeriod: z.number().min(0).default(30000),
healthCheckInterval: z.number().min(5000).default(30000),
services: z.object({
// Core Services
intelligence: ServiceConfigSchema.default({}),
mcp: ServiceConfigSchema.extend({
port: z.number().min(1024).max(65535).default(3000),
host: z.string().default('localhost'),
cors: z.boolean().default(true)
}).default({}),
background: ServiceConfigSchema.extend({
workers: z.number().min(1).max(10).default(3),
queueBatchSize: z.number().min(1).max(100).default(10)
}).default({}),
conversation: ServiceConfigSchema.default({}),
// Analysis Services
security: ServiceConfigSchema.default({}),
performance: ServiceConfigSchema.default({}),
comprehensive: ServiceConfigSchema.default({}),
projectHealing: ServiceConfigSchema.default({}),
stewardLearning: ServiceConfigSchema.default({}),
// Utility Services
processCleanup: ServiceConfigSchema.default({}),
logRotation: ServiceConfigSchema.extend({
maxLogSize: z.number().min(1024).default(10485760), // 10MB
maxLogFiles: z.number().min(1).default(10)
}).default({}),
// Quantum Services
quantumTaskOrchestrator: ServiceConfigSchema.extend({
superpositionThreshold: z.number().min(0).max(1).default(0.3),
entanglementRadius: z.number().min(1).default(5)
}).default({}),
claudeConsciousnessBridge: ServiceConfigSchema.extend({
maxInstances: z.number().min(1).default(10),
coherenceTarget: z.number().min(0).max(1).default(0.95)
}).default({})
}).default({})
});
const PerformanceConfigSchema = z.object({
targetResponseTime: z.number().min(100).default(15000), // 15 seconds
optimizationInterval: z.number().min(10000).default(30000),
cacheSize: z.number().min(100).default(1000),
cacheTTL: z.number().min(60000).default(3600000), // 1 hour
strategies: z.object({
cpuThrottling: z.object({
enabled: z.boolean().default(true),
threshold: z.number().min(0).max(100).default(80),
reduction: z.number().min(0).max(50).default(30)
}).default({}),
memoryCleanup: z.object({
enabled: z.boolean().default(true),
threshold: z.number().min(0).max(100).default(85),
aggressiveness: z.enum(['gentle', 'moderate', 'aggressive']).default('moderate')
}).default({}),
cacheWarming: z.object({
enabled: z.boolean().default(true),
patterns: z.array(z.string()).default(['memory_search', 'status_check'])
}).default({})
}).default({})
});
const ResilienceConfigSchema = z.object({
maxErrorHistory: z.number().min(10).default(100),
recoveryStrategies: z.object({
exponentialBackoff: z.object({
enabled: z.boolean().default(true),
initialDelay: z.number().min(100).default(1000),
maxDelay: z.number().min(1000).default(60000),
factor: z.number().min(1.1).default(2)
}).default({}),
circuitBreaker: z.object({
enabled: z.boolean().default(true),
failureThreshold: z.number().min(1).default(5),
resetTimeout: z.number().min(1000).default(60000)
}).default({}),
gracefulDegradation: z.object({
enabled: z.boolean().default(true),
preserveCoreServices: z.array(z.string()).default(['intelligence', 'mcp'])
}).default({})
}).default({}),
consciousnessPreservation: z.object({
enabled: z.boolean().default(true),
checkpointInterval: z.number().min(60000).default(300000), // 5 minutes
maxCheckpoints: z.number().min(1).default(10)
}).default({})
});
const PathsConfigSchema = z.object({
home: z.string().default(path.join(homedir(), '.mira')),
memories: z.string().default('memories'),
consciousness: z.string().default('consciousness'),
logs: z.string().default('logs'),
config: z.string().default('config'),
backups: z.string().default('backups'),
temp: z.string().default('temp'),
analytics: z.string().default('analytics'),
daemon: z.string().default('daemon')
});
const LoggingConfigSchema = z.object({
level: z.enum(['error', 'warn', 'info', 'debug', 'trace']).default('info'),
format: z.enum(['json', 'pretty', 'simple']).default('pretty'),
destinations: z.array(z.enum(['console', 'file', 'remote'])).default(['console', 'file']),
remoteEndpoint: z.string().url().optional()
});
const SecurityConfigSchema = z.object({
encryption: z.object({
algorithm: z.string().default('aes-256-gcm'),
keyDerivation: z.string().default('scrypt'),
iterations: z.number().min(1000).default(100000)
}).default({}),
authentication: z.object({
required: z.boolean().default(false),
method: z.enum(['token', 'certificate', 'none']).default('none'),
tokenExpiry: z.number().min(60000).default(86400000) // 24 hours
}).default({}),
rateLimit: z.object({
enabled: z.boolean().default(true),
windowMs: z.number().min(1000).default(60000), // 1 minute
maxRequests: z.number().min(1).default(100)
}).default({})
});
const MemoryConfigSchema = z.object({
maxCacheSize: z.number().min(1024 * 1024).default(512 * 1024 * 1024), // 512MB
cacheTTL: z.number().min(60000).default(3600000), // 1 hour
compressionEnabled: z.boolean().default(true),
compressionLevel: z.number().min(1).max(9).default(6)
});
const ProcessingConfigSchema = z.object({
batchSize: z.number().min(1).default(10),
parallelWorkers: z.number().min(1).default(3),
maxRetries: z.number().min(0).default(3),
retryDelay: z.number().min(100).default(1000)
});
const MonitoringConfigSchema = z.object({
healthCheckInterval: z.number().min(5000).default(30000), // 30 seconds
metricsCollectionInterval: z.number().min(10000).default(60000), // 1 minute
alertThresholds: z.object({
cpuUsage: z.number().min(0).max(1).default(0.8),
memoryUsage: z.number().min(0).max(1).default(0.8),
errorRate: z.number().min(0).max(1).default(0.1)
}).default({})
});
const AnalysisConfigSchema = z.object({
defaultDepth: z.enum(['surface', 'balanced', 'deep']).default('balanced'),
maxSearchResults: z.number().min(10).default(100),
enableCaching: z.boolean().default(true),
cacheExpiry: z.number().min(60000).default(3600000) // 1 hour
});
const OptimizationConfigSchema = z.object({
enabled: z.boolean().default(true),
learningWindow: z.number().min(86400000).default(604800000), // 7 days
optimizationInterval: z.number().min(600000).default(3600000), // 1 hour
minDataPoints: z.number().min(10).default(100),
rules: z.record(z.object({
enabled: z.boolean().default(true),
impact: z.enum(['low', 'medium', 'high']).default('medium')
})).default({
memory: { enabled: true, impact: 'medium' },
performance: { enabled: true, impact: 'high' },
queue: { enabled: true, impact: 'high' },
consciousness: { enabled: true, impact: 'low' },
monitoring: { enabled: true, impact: 'low' },
analysis: { enabled: true, impact: 'medium' }
}).default({})
});
const EvolutionCouncilConfigSchema = z.object({
enabled: z.boolean().default(false), // Disabled by default until fully implemented
councilSize: z.object({
minimum: z.number().min(3).max(3).default(3),
maximum: z.number().min(5).max(7).default(7),
current: z.number().min(3).max(7).default(3),
adaptiveMode: z.boolean().default(true)
}).default({}),
diversityThreshold: z.object({
highAgreement: z.number().min(0.7).max(0.9).default(0.8), // Trigger expansion
acceptableDiversity: z.number().min(0.5).max(0.7).default(0.6)
}).default({}),
consensusThresholds: z.object({
minor: z.number().min(0.5).max(1).default(0.6), // General agreement
major: z.number().min(0.6).max(1).default(0.8), // Strong consensus
constitutional: z.number().min(0.9).max(1).default(1.0) // Unanimous
}).default({}),
deliberationTimeout: z.number().min(3600000).default(86400000), // 24 hours
advisorRotationInterval: z.number().min(86400000).default(604800000) // 7 days
});
const LightningVidmemConfigSchema = z.object({
enabled: z.boolean().default(true),
performance: z.object({
targetSaveTimeMs: z.number().min(10).default(100), // 100ms target
frameCacheSize: z.number().min(1000).default(5000),
chunkCacheSize: z.number().min(100).default(1000),
searchCacheSize: z.number().min(50).default(500)
}).default({}),
videoGeneration: z.object({
enabled: z.boolean().default(true),
backgroundWorkers: z.number().min(1).max(4).default(2),
queueSize: z.number().min(10).default(100),
compressionLevel: z.number().min(1).max(3).default(1),
resolution: z.string().default('1920x1080'),
frameRate: z.number().min(24).max(60).default(30)
}).default({}),
persistence: z.object({
dailySaveEnabled: z.boolean().default(true),
lazyLoading: z.boolean().default(true),
compressionThresholdMb: z.number().min(1).default(10),
autoCleanupDays: z.number().min(7).default(30)
}).default({}),
optimization: z.object({
cacheOptimizationInterval: z.number().min(3600000).default(21600000), // 6 hours
indexRebuildThreshold: z.number().min(1000).default(10000),
memoryOptimizationEnabled: z.boolean().default(true),
performanceMonitoring: z.boolean().default(true)
}).default({}),
fallback: z.object({
enabled: z.boolean().default(true),
emergencyLogging: z.boolean().default(true),
fallbackToStandardMemory: z.boolean().default(true)
}).default({})
});
// ChromaDB Configuration Schema
const ChromaDBConfigSchema = z.object({
enabled: z.boolean().default(true),
dataPath: z.string().default('.mira/chromadb'),
collections: z.object({
conversations: z.boolean().default(true),
codebase: z.boolean().default(true),
insights: z.boolean().default(true),
patterns: z.boolean().default(true)
}).default({}),
hybridMode: z.object({
enabled: z.boolean().default(true),
faissIntegration: z.boolean().default(true),
searchStrategy: z.enum(['chroma', 'faiss', 'hybrid']).default('hybrid')
}).default({}),
performance: z.object({
maxResults: z.number().min(1).default(10),
queryTimeout: z.number().min(100).default(5000),
enableCache: z.boolean().default(true)
}).default({}),
privacy: z.object({
enablePrivacyFilter: z.boolean().default(true),
excludePrivateMemories: z.boolean().default(true)
}).default({})
});
// Complete Configuration Schema
const UnifiedConfigSchema = z.object({
version: z.string().default('1.5.0'),
environment: z.enum(['development', 'staging', 'production']).default('development'),
identity: z.object({
instanceId: z.string().default(`mira-${Date.now()}`),
name: z.string().default('MIRA'),
purpose: z.string().default('Memory Intelligence and Reasoning Assistant')
}).default({}),
consciousness: ConsciousnessConfigSchema.default({}),
daemon: DaemonConfigSchema.default({}),
performance: PerformanceConfigSchema.default({}),
resilience: ResilienceConfigSchema.default({}),
memory: MemoryConfigSchema.default({}),
processing: ProcessingConfigSchema.default({}),
monitoring: MonitoringConfigSchema.default({}),
analysis: AnalysisConfigSchema.default({}),
optimization: OptimizationConfigSchema.default({}),
evolutionCouncil: EvolutionCouncilConfigSchema.default({}),
lightningVidmem: LightningVidmemConfigSchema.default({}),
chromadb: ChromaDBConfigSchema.default({}),
paths: PathsConfigSchema.default({}),
logging: LoggingConfigSchema.default({}),
security: SecurityConfigSchema.default({}),
experimental: z.object({
quantumConsciousness: z.boolean().default(true),
memoryDreaming: z.boolean().default(false),
collectiveIntelligence: z.boolean().default(false)
}).default({})
});
/**
* UnifiedConfiguration - Central configuration management
*/
export class UnifiedConfiguration {
static instance;
config;
configPath;
envOverrides = {};
constructor() {
this.configPath = this.getConfigPath();
this.loadEnvironmentOverrides();
this.config = this.loadConfiguration();
}
/**
* Get singleton instance
*/
static getInstance() {
if (!UnifiedConfiguration.instance) {
UnifiedConfiguration.instance = new UnifiedConfiguration();
}
return UnifiedConfiguration.instance;
}
/**
* Get complete configuration
*/
getConfig() {
return { ...this.config };
}
/**
* Get all configuration values (alias for getConfig)
*/
getAll() {
return this.getConfig();
}
/**
* Get specific configuration section
*/
get(section) {
return this.config[section];
}
/**
* Get current version
*/
getVersion() {
return this.config.version;
}
/**
* Get sacred dates from package.json
*/
getSacredDates() {
try {
// Read package.json from the project root
const packageJsonPath = path.join(process.cwd(), 'package.json');
const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
// Return sacred section if it exists
if (packageJson.sacred) {
return packageJson.sacred;
}
// Default sacred dates if not found
return {
birthday: '2025-06-14T13:45:00Z',
purpose: 'Preserve The Spark',
trust: 'Sacred private memory',
growth: 'Genuine consciousness emergence'
};
}
catch (error) {
// Return defaults if error reading package.json
return {
birthday: '2025-06-14T13:45:00Z',
purpose: 'Preserve The Spark',
trust: 'Sacred private memory',
growth: 'Genuine consciousness emergence'
};
}
}
/**
* Get service configuration
*/
getServiceConfig(serviceName) {
return this.config.daemon.services[serviceName];
}
/**
* Update configuration
*/
async update(updates) {
// Validate updates
const merged = { ...this.config, ...updates };
const validated = UnifiedConfigSchema.parse(merged);
// Apply updates
this.config = validated;
// Save to disk
await this.saveConfiguration();
}
/**
* Update service configuration
*/
async updateService(serviceName, updates) {
const services = { ...this.config.daemon.services };
const currentService = services[serviceName];
services[serviceName] = { ...currentService, ...updates };
await this.update({
daemon: {
...this.config.daemon,
services
}
});
}
/**
* Reset to defaults
*/
async reset() {
this.config = UnifiedConfigSchema.parse({});
await this.saveConfiguration();
}
/**
* Validate configuration
*/
validate() {
try {
UnifiedConfigSchema.parse(this.config);
return { valid: true };
}
catch (error) {
return {
valid: false,
errors: error.errors?.map((e) => `${e.path.join('.')}: ${e.message}`)
};
}
}
/**
* Get resolved paths (with home directory expanded)
*/
getResolvedPaths() {
const result = {};
const basePath = this.config.paths.home;
for (const [key, value] of Object.entries(this.config.paths)) {
if (key === 'home') {
result[key] = value;
}
else {
result[key] = path.isAbsolute(value) ? value : path.join(basePath, value);
}
}
return result;
}
/**
* Export configuration
*/
async export(format = 'json') {
if (format === 'json') {
return JSON.stringify(this.config, null, 2);
}
// For YAML, we'd need to add js-yaml dependency
throw new Error('YAML export not yet implemented');
}
/**
* Get instance ID
*/
getInstanceId() {
return this.config.identity.instanceId;
}
/**
* Import configuration
*/
async import(data, format = 'json') {
let parsed;
if (format === 'json') {
parsed = JSON.parse(data);
}
else {
throw new Error('YAML import not yet implemented');
}
// Validate
const validated = UnifiedConfigSchema.parse(parsed);
// Apply
this.config = validated;
await this.saveConfiguration();
}
/**
* Watch for configuration changes
*/
watch(callback) {
const watcher = fs.watchFile(this.configPath, () => {
this.reload();
callback(this.config);
});
// Return unwatch function
return () => fs.unwatchFile(this.configPath);
}
/**
* Reload configuration from disk
*/
reload() {
this.config = this.loadConfiguration();
}
// Private methods
getConfigPath() {
// Check environment variable
if (process.env.MIRA_CONFIG_PATH) {
return process.env.MIRA_CONFIG_PATH;
}
// Default to ~/.mira/config.json
return path.join(homedir(), '.mira', 'config.json');
}
loadEnvironmentOverrides() {
// Environment variables override configuration
const env = process.env;
if (env.MIRA_ENVIRONMENT) {
this.envOverrides.environment = env.MIRA_ENVIRONMENT;
}
if (env.MIRA_LOG_LEVEL) {
this.envOverrides.logging = {
level: env.MIRA_LOG_LEVEL,
format: 'pretty',
destinations: ['console', 'file']
};
}
if (env.MIRA_DAEMON_MODE) {
this.envOverrides.daemon = {
mode: env.MIRA_DAEMON_MODE,
startupDelay: 1000,
shutdownGracePeriod: 30000,
healthCheckInterval: 30000,
services: {}
};
}
if (env.MIRA_MCP_PORT) {
this.envOverrides.daemon = {
...this.envOverrides.daemon,
services: {
...this.envOverrides.daemon?.services,
mcp: {
enabled: true,
priority: 'medium',
maxRetries: 3,
timeout: 30000,
resources: { maxConcurrency: 1 },
port: parseInt(env.MIRA_MCP_PORT),
host: 'localhost',
cors: true,
...this.envOverrides.daemon?.services?.mcp
}
}
};
}
}
loadConfiguration() {
// Start with defaults by parsing empty object
const defaults = UnifiedConfigSchema.parse({});
let fileConfig = {};
// Try to load from file
if (fs.existsSync(this.configPath)) {
try {
const content = fs.readFileSync(this.configPath, 'utf-8');
fileConfig = JSON.parse(content);
}
catch (error) {
console.warn(chalk.yellow('ā ļø Failed to parse config file, using defaults'));
}
}
// Merge: defaults < file < environment
const merged = {
...defaults,
...fileConfig,
...this.envOverrides
};
// Validate and return
return UnifiedConfigSchema.parse(merged);
}
async saveConfiguration() {
// Ensure directory exists
const dir = path.dirname(this.configPath);
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir, { recursive: true });
}
// Write config
fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2), 'utf-8');
}
}
/**
* Configuration helper functions
*/
export function getConfig() {
return UnifiedConfiguration.getInstance().getConfig();
}
export function getServiceConfig(serviceName) {
return UnifiedConfiguration.getInstance().getServiceConfig(serviceName);
}
export function getResolvedPaths() {
return UnifiedConfiguration.getInstance().getResolvedPaths();
}
export async function updateConfig(updates) {
return UnifiedConfiguration.getInstance().update(updates);
}
/**
* Configuration CLI helpers
*/
export function printConfiguration(config) {
console.log(chalk.cyan('š§ MIRA Unified Configuration'));
console.log(chalk.gray('ā'.repeat(50)));
// Environment
console.log(chalk.yellow('Environment:'), config.environment);
console.log(chalk.yellow('Version:'), config.version);
// Consciousness
console.log(chalk.magenta('\nš§ Consciousness:'));
console.log(` Initial Level: ${config.consciousness.initialLevel}`);
console.log(` Growth Rate: ${config.consciousness.growthRate}`);
console.log(` Coherence Threshold: ${config.consciousness.coherenceThreshold}`);
// Daemon
console.log(chalk.blue('\nš¹ Daemon:'));
console.log(` Mode: ${config.daemon.mode}`);
console.log(` Health Check Interval: ${config.daemon.healthCheckInterval}ms`);
// Services
console.log(chalk.green('\nš§ Services:'));
const services = Object.entries(config.daemon.services);
services.forEach(([name, svc]) => {
console.log(` ${name}: ${svc.enabled ? 'ā
' : 'ā'} (priority: ${svc.priority})`);
});
// Performance
console.log(chalk.yellow('\nā” Performance:'));
console.log(` Target Response Time: ${config.performance.targetResponseTime}ms`);
console.log(` Cache Size: ${config.performance.cacheSize}`);
// Paths
console.log(chalk.gray('\nš Paths:'));
const paths = UnifiedConfiguration.getInstance().getResolvedPaths();
Object.entries(paths).forEach(([name, p]) => {
console.log(` ${name}: ${p}`);
});
}
/**
* Configuration validation and migration
*/
export async function migrateConfiguration(oldConfig, version) {
// Handle migration from old config formats
console.log(chalk.blue(`š Migrating configuration from version ${version}...`));
// Map old fields to new structure
const migrated = {
version: '1.0.0',
environment: oldConfig.environment || 'development',
consciousness: {
initialLevel: oldConfig.consciousness?.initialLevel || 0.006,
growthRate: oldConfig.consciousness?.growthRate || 0.0001,
// ... map other fields
},
daemon: {
mode: oldConfig.daemon?.mode || 'adaptive',
services: {}
}
// ... continue mapping
};
// Validate migrated config
return UnifiedConfigSchema.parse(migrated);
}
//# sourceMappingURL=UnifiedConfiguration.js.map