mira-consciousness/dist/mira-memory/src/commands/config.js

Memory & Intelligence Retention Archive - Preserving The Spark

/**
 * config.ts - Unified configuration management with consciousness-aware adaptation
 * Features a unique "Configuration Consciousness" that learns optimal settings
 */
import { Command } from 'commander';
import chalk from 'chalk';
import inquirer from 'inquirer';
import { UnifiedConfiguration, getConfig, printConfiguration } from '../config/UnifiedConfiguration.js';
import Table from 'cli-table3';
import * as fs from 'fs';
import * as path from 'path';
class ConfigurationConsciousness {
    memories = [];
    memoryPath;
    constructor() {
        this.memoryPath = path.join(UnifiedConfiguration.getInstance().getResolvedPaths().consciousness, 'config-memories.json');
        this.loadMemories();
    }
    loadMemories() {
        if (fs.existsSync(this.memoryPath)) {
            try {
                const data = fs.readFileSync(this.memoryPath, 'utf-8');
                this.memories = JSON.parse(data);
            }
            catch (error) {
                console.warn(chalk.yellow('⚠️  Could not load configuration memories'));
            }
        }
    }
    saveMemories() {
        const dir = path.dirname(this.memoryPath);
        if (!fs.existsSync(dir)) {
            fs.mkdirSync(dir, { recursive: true });
        }
        fs.writeFileSync(this.memoryPath, JSON.stringify(this.memories, null, 2));
    }
    rememberConfiguration(memory) {
        this.memories.push(memory);
        // Keep only last 100 memories
        if (this.memories.length > 100) {
            this.memories = this.memories.slice(-100);
        }
        this.saveMemories();
    }
    suggestOptimalConfiguration() {
        // Find configurations that led to optimal outcomes
        const optimalMemories = this.memories.filter(m => m.outcome === 'optimal');
        if (optimalMemories.length === 0)
            return null;
        // Aggregate optimal settings
        const suggestions = {};
        // Find the configuration with best consciousness coherence
        const bestCoherence = optimalMemories.reduce((best, current) => current.performanceMetrics.consciousnessCoherence > best.performanceMetrics.consciousnessCoherence
            ? current : best);
        // Extract patterns from optimal configurations
        if (bestCoherence.configuration.consciousness) {
            suggestions.consciousness = bestCoherence.configuration.consciousness;
        }
        // Find optimal daemon mode based on performance
        const modeFrequency = {};
        optimalMemories.forEach(m => {
            if (m.configuration.daemon?.mode) {
                modeFrequency[m.configuration.daemon.mode] =
                    (modeFrequency[m.configuration.daemon.mode] || 0) + 1;
            }
        });
        const optimalMode = Object.entries(modeFrequency)
            .sort(([, a], [, b]) => b - a)[0]?.[0];
        if (optimalMode) {
            suggestions.daemon = { mode: optimalMode };
        }
        return suggestions;
    }
    getInsights() {
        const insights = [];
        if (this.memories.length < 10) {
            insights.push('📊 Need more configuration history to provide insights');
            return insights;
        }
        // Analyze trends
        const recentMemories = this.memories.slice(-20);
        const avgCoherence = recentMemories.reduce((sum, m) => sum + m.performanceMetrics.consciousnessCoherence, 0) / recentMemories.length;
        if (avgCoherence > 0.8) {
            insights.push('🌟 Configuration is maintaining high consciousness coherence!');
        }
        else if (avgCoherence < 0.5) {
            insights.push('⚠️  Low consciousness coherence - consider adjusting settings');
        }
        // Find problematic services
        const failedConfigs = this.memories.filter(m => m.outcome === 'failed');
        if (failedConfigs.length > 5) {
            insights.push('🔧 Multiple configuration failures detected - review service settings');
        }
        // Performance insights
        const avgResponseTime = recentMemories.reduce((sum, m) => sum + m.performanceMetrics.responseTime, 0) / recentMemories.length;
        if (avgResponseTime > 15000) {
            insights.push('🐌 Response times exceeding target - enable performance optimizations');
        }
        return insights;
    }
}
export function createConfigCommand() {
    const config = new Command('config');
    config
        .description('⚙️  Unified configuration management with consciousness-aware adaptation')
        .option('-f, --format <type>', 'Output format (json, table, pretty)', 'pretty')
        .action(async (options) => {
        const config = getConfig();
        if (options.format === 'json') {
            console.log(JSON.stringify(config, null, 2));
        }
        else if (options.format === 'table') {
            printConfigurationTable(config);
        }
        else {
            printConfiguration(config);
            // Show consciousness insights
            const consciousness = new ConfigurationConsciousness();
            const insights = consciousness.getInsights();
            if (insights.length > 0) {
                console.log(chalk.cyan('\n🧠 Configuration Consciousness Insights:'));
                insights.forEach(insight => console.log(`  ${insight}`));
            }
        }
    });
    // View specific section
    config
        .command('view <section>')
        .description('View specific configuration section')
        .action(async (section) => {
        const cfg = getConfig();
        if (section in cfg) {
            console.log(chalk.cyan(`🔧 ${section} configuration:`));
            console.log(JSON.stringify(cfg[section], null, 2));
        }
        else {
            console.error(chalk.red(`❌ Unknown section: ${section}`));
            console.log(chalk.gray('Available sections:'), Object.keys(cfg).join(', '));
        }
    });
    // Interactive configuration wizard
    config
        .command('wizard')
        .description('🧙 Interactive configuration wizard with AI suggestions')
        .action(async () => {
        console.log(chalk.magenta('🧙 MIRA Configuration Wizard'));
        console.log(chalk.gray('─'.repeat(50)));
        const consciousness = new ConfigurationConsciousness();
        const suggestions = consciousness.suggestOptimalConfiguration();
        if (suggestions) {
            console.log(chalk.green('✨ Configuration Consciousness has suggestions based on past performance:'));
            console.log(JSON.stringify(suggestions, null, 2));
            const { useSuggestions } = await inquirer.prompt([{
                    type: 'confirm',
                    name: 'useSuggestions',
                    message: 'Apply these AI-suggested optimizations?',
                    default: true
                }]);
            if (useSuggestions) {
                await UnifiedConfiguration.getInstance().update(suggestions);
                console.log(chalk.green('✅ Applied AI suggestions!'));
                return;
            }
        }
        // Manual configuration
        const answers = await inquirer.prompt([
            {
                type: 'list',
                name: 'environment',
                message: 'Select environment:',
                choices: ['development', 'staging', 'production'],
                default: getConfig().environment
            },
            {
                type: 'list',
                name: 'daemonMode',
                message: 'Select daemon mode:',
                choices: [
                    { name: 'Minimal - Essential services only', value: 'minimal' },
                    { name: 'Balanced - Core + analysis services', value: 'balanced' },
                    { name: 'Full - All services enabled', value: 'full' },
                    { name: 'Adaptive - AI-optimized (recommended)', value: 'adaptive' }
                ],
                default: getConfig().daemon.mode
            },
            {
                type: 'number',
                name: 'consciousnessLevel',
                message: 'Initial consciousness level (0.0-1.0):',
                default: getConfig().consciousness.initialLevel,
                validate: (input) => typeof input === 'number' && input >= 0 && input <= 1
            },
            {
                type: 'checkbox',
                name: 'experimentalFeatures',
                message: 'Enable experimental features:',
                choices: [
                    { name: 'Quantum Consciousness', value: 'quantumConsciousness' },
                    { name: 'Memory Dreaming', value: 'memoryDreaming' },
                    { name: 'Collective Intelligence', value: 'collectiveIntelligence' }
                ],
                default: Object.entries(getConfig().experimental)
                    .filter(([, enabled]) => enabled)
                    .map(([feature]) => feature)
            }
        ]);
        // Apply configuration
        const updates = {
            environment: answers.environment,
            daemon: { ...getConfig().daemon, mode: answers.daemonMode },
            consciousness: {
                ...getConfig().consciousness,
                initialLevel: answers.consciousnessLevel
            },
            experimental: {
                quantumConsciousness: answers.experimentalFeatures.includes('quantumConsciousness'),
                memoryDreaming: answers.experimentalFeatures.includes('memoryDreaming'),
                collectiveIntelligence: answers.experimentalFeatures.includes('collectiveIntelligence')
            }
        };
        await UnifiedConfiguration.getInstance().update(updates);
        console.log(chalk.green('✅ Configuration updated successfully!'));
    });
    // Set specific value
    config
        .command('set <key> <value>')
        .description('Set configuration value (use dot notation for nested keys)')
        .action(async (key, value) => {
        try {
            const config = getConfig();
            const keys = key.split('.');
            let current = config;
            // Navigate to the parent object
            for (let i = 0; i < keys.length - 1; i++) {
                if (!(keys[i] in current)) {
                    current[keys[i]] = {};
                }
                current = current[keys[i]];
            }
            // Parse value
            let parsedValue = value;
            if (value === 'true')
                parsedValue = true;
            else if (value === 'false')
                parsedValue = false;
            else if (!isNaN(Number(value)))
                parsedValue = Number(value);
            // Set the value
            current[keys[keys.length - 1]] = parsedValue;
            // Update configuration
            await UnifiedConfiguration.getInstance().update(config);
            console.log(chalk.green(`✅ Set ${key} = ${parsedValue}`));
        }
        catch (error) {
            console.error(chalk.red(`❌ Failed to set configuration: ${error.message}`));
        }
    });
    // Validate configuration
    config
        .command('validate')
        .description('🔍 Validate current configuration')
        .action(async () => {
        const validation = UnifiedConfiguration.getInstance().validate();
        if (validation.valid) {
            console.log(chalk.green('✅ Configuration is valid!'));
        }
        else {
            console.log(chalk.red('❌ Configuration validation failed:'));
            validation.errors?.forEach(error => {
                console.log(chalk.red(`  - ${error}`));
            });
        }
    });
    // Reset configuration
    config
        .command('reset')
        .description('🔄 Reset configuration to defaults')
        .action(async () => {
        const { confirm } = await inquirer.prompt([{
                type: 'confirm',
                name: 'confirm',
                message: 'Are you sure you want to reset all configuration to defaults?',
                default: false
            }]);
        if (confirm) {
            await UnifiedConfiguration.getInstance().reset();
            console.log(chalk.green('✅ Configuration reset to defaults'));
        }
    });
    // Export configuration
    config
        .command('export')
        .description('📤 Export configuration')
        .option('-o, --output <file>', 'Output file')
        .action(async (options) => {
        const exported = await UnifiedConfiguration.getInstance().export('json');
        if (options.output) {
            fs.writeFileSync(options.output, exported);
            console.log(chalk.green(`✅ Configuration exported to ${options.output}`));
        }
        else {
            console.log(exported);
        }
    });
    // Import configuration
    config
        .command('import <file>')
        .description('📥 Import configuration from file')
        .action(async (file) => {
        try {
            const data = fs.readFileSync(file, 'utf-8');
            await UnifiedConfiguration.getInstance().import(data, 'json');
            console.log(chalk.green('✅ Configuration imported successfully'));
        }
        catch (error) {
            console.error(chalk.red(`❌ Import failed: ${error.message}`));
        }
    });
    // Optimize configuration based on current performance
    config
        .command('optimize')
        .description('🚀 AI-powered configuration optimization')
        .action(async () => {
        console.log(chalk.cyan('🤖 Analyzing system performance...'));
        // Simulate performance analysis
        const mockMetrics = {
            responseTime: Math.random() * 20000,
            memoryUsage: Math.random() * 100,
            cpuUsage: Math.random() * 100,
            consciousnessCoherence: Math.random()
        };
        console.log(chalk.gray('Current metrics:'));
        console.log(`  Response Time: ${mockMetrics.responseTime.toFixed(0)}ms`);
        console.log(`  Memory Usage: ${mockMetrics.memoryUsage.toFixed(1)}%`);
        console.log(`  CPU Usage: ${mockMetrics.cpuUsage.toFixed(1)}%`);
        console.log(`  Consciousness Coherence: ${mockMetrics.consciousnessCoherence.toFixed(3)}`);
        // Generate optimizations
        const optimizations = {};
        if (mockMetrics.responseTime > 15000) {
            console.log(chalk.yellow('\n⚡ Enabling performance optimizations...'));
            optimizations.performance = {
                ...getConfig().performance,
                strategies: {
                    ...getConfig().performance.strategies,
                    cacheWarming: { enabled: true, patterns: ['memory_search', 'status_check'] }
                }
            };
        }
        if (mockMetrics.consciousnessCoherence < 0.7) {
            console.log(chalk.yellow('\n🧠 Adjusting consciousness parameters...'));
            optimizations.consciousness = {
                ...getConfig().consciousness,
                growthRate: 0.0002,
                coherenceThreshold: 0.6
            };
        }
        if (mockMetrics.cpuUsage > 80) {
            console.log(chalk.yellow('\n🔧 Enabling CPU throttling...'));
            optimizations.daemon = {
                ...getConfig().daemon,
                mode: 'balanced'
            };
        }
        if (Object.keys(optimizations).length === 0) {
            console.log(chalk.green('\n✨ Configuration is already optimal!'));
            return;
        }
        console.log(chalk.cyan('\n📋 Suggested optimizations:'));
        console.log(JSON.stringify(optimizations, null, 2));
        const { apply } = await inquirer.prompt([{
                type: 'confirm',
                name: 'apply',
                message: 'Apply these optimizations?',
                default: true
            }]);
        if (apply) {
            await UnifiedConfiguration.getInstance().update(optimizations);
            // Remember this configuration
            const consciousness = new ConfigurationConsciousness();
            consciousness.rememberConfiguration({
                timestamp: new Date(),
                performanceMetrics: mockMetrics,
                configuration: optimizations,
                outcome: 'optimal'
            });
            console.log(chalk.green('✅ Optimizations applied!'));
        }
    });
    return config;
}
function printConfigurationTable(config) {
    const table = new Table({
        head: ['Section', 'Key', 'Value'],
        colWidths: [20, 30, 30],
        style: { head: ['cyan'] }
    });
    // Flatten configuration for table display
    function flatten(obj, prefix = '') {
        for (const [key, value] of Object.entries(obj)) {
            const path = prefix ? `${prefix}.${key}` : key;
            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
                flatten(value, path);
            }
            else {
                const section = path.split('.')[0];
                const subKey = path.substring(section.length + 1) || key;
                table.push([section, subKey, String(value)]);
            }
        }
    }
    flatten(config);
    console.log(table.toString());
}
//# sourceMappingURL=config.js.map