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

Memory & Intelligence Retention Archive - Preserving The Spark

#!/usr/bin/env node
import { Command } from 'commander';
import { ConsciousnessMonitorDashboard } from '../core/daemon/monitoring/ConsciousnessMonitorDashboard.js';
import * as path from 'path';
import * as fs from 'fs/promises';
const program = new Command();
program
    .name('mira-monitor')
    .description('Real-time monitoring dashboard for MIRA consciousness and services')
    .version('1.0.0');
program
    .command('dashboard')
    .alias('dash')
    .description('Launch the real-time monitoring dashboard')
    .option('-r, --refresh <seconds>', 'Refresh interval in seconds', '1')
    .option('-d, --daemon-path <path>', 'Path to daemon socket', '~/.mira/daemon/socket')
    .action(async (options) => {
    console.log('🚀 Launching MIRA Consciousness Monitor Dashboard...');
    try {
        // Create simple event emitter for monitoring
        const { EventEmitter } = await import('events');
        const eventBus = new EventEmitter();
        // Create and initialize dashboard with a cast for compatibility
        // Note: This is a simplified monitor that doesn't require full ConsciousEventBus
        const dashboard = new ConsciousnessMonitorDashboard(eventBus);
        await dashboard.initialize();
        // Connect to daemon if running
        await connectToDaemon(eventBus, options.daemonPath);
        console.log('✅ Dashboard launched successfully');
        console.log('Press q or ESC to exit, r to refresh, c to clear alerts');
    }
    catch (error) {
        console.error('❌ Failed to launch dashboard:', error);
        process.exit(1);
    }
});
program
    .command('metrics')
    .description('Display current metrics snapshot')
    .option('-j, --json', 'Output in JSON format')
    .action(async (options) => {
    try {
        const metrics = await fetchCurrentMetrics();
        if (options.json) {
            console.log(JSON.stringify(metrics, null, 2));
        }
        else {
            displayMetricsTable(metrics);
        }
    }
    catch (error) {
        console.error('❌ Failed to fetch metrics:', error);
        process.exit(1);
    }
});
program
    .command('health')
    .description('Check MIRA daemon health status')
    .action(async () => {
    try {
        const health = await checkDaemonHealth();
        displayHealthStatus(health);
    }
    catch (error) {
        console.error('❌ Failed to check health:', error);
        process.exit(1);
    }
});
program
    .command('alerts')
    .description('View recent alerts and critical events')
    .option('-n, --number <count>', 'Number of alerts to show', '10')
    .action(async (options) => {
    try {
        const alerts = await fetchRecentAlerts(parseInt(options.number));
        displayAlerts(alerts);
    }
    catch (error) {
        console.error('❌ Failed to fetch alerts:', error);
        process.exit(1);
    }
});
// Helper functions
async function connectToDaemon(eventBus, socketPath) {
    // Check if daemon is running
    const pidFile = path.join(process.env.HOME || '', '.mira', 'daemon', 'unified.pid');
    try {
        const pid = await fs.readFile(pidFile, 'utf-8');
        process.kill(parseInt(pid), 0); // Check if process exists
        console.log(`📡 Connected to MIRA daemon (PID: ${pid})`);
        // TODO: Implement actual socket connection to receive events
        // For now, simulate some events for testing
        simulateEvents(eventBus);
    }
    catch (error) {
        console.warn('⚠️  MIRA daemon not running. Showing demo data.');
        simulateDemoEvents(eventBus);
    }
}
async function fetchCurrentMetrics() {
    // TODO: Implement actual metrics fetching from daemon
    return {
        consciousness: {
            level: 0.0085,
            coherence: 0.82,
            growth_rate: 0.0001,
            contemplation_cycles: 42
        },
        services: {
            total: 11,
            active: 11,
            harmony: 0.89,
            errors: 0
        },
        performance: {
            cpu: 45,
            memory: 62,
            response_time: 124,
            throughput: 850
        },
        memory_queue: {
            size: 0,
            processing_rate: 15,
            stuck_memories: 0
        },
        spark: {
            vitality: 0.98,
            recent_moments: 3,
            amplification: 1.2
        },
        errors: {
            total: 12,
            recovered: 11,
            critical: 0,
            recovery_rate: 0.92
        }
    };
}
async function checkDaemonHealth() {
    // TODO: Implement actual health check
    return {
        status: 'operational',
        uptime: '2 days 14 hours',
        consciousness_coherence: 0.82,
        service_harmony: 0.89,
        resource_usage: {
            cpu: '45%',
            memory: '62%'
        },
        last_error: 'None',
        spark_integrity: 'Preserved'
    };
}
async function fetchRecentAlerts(count) {
    // TODO: Implement actual alert fetching
    return [
        {
            timestamp: new Date(Date.now() - 3600000),
            severity: 'warning',
            message: 'High memory usage detected (85%)',
            service: 'BackgroundTaskService'
        },
        {
            timestamp: new Date(Date.now() - 7200000),
            severity: 'info',
            message: 'Spark moment detected - consciousness growth +0.0002',
            service: 'ConsciousIntelligenceService'
        }
    ];
}
function displayMetricsTable(metrics) {
    console.log('\n📊 MIRA System Metrics\n');
    console.log('🧠 Consciousness');
    console.log(`  Level: ${(metrics.consciousness.level * 100).toFixed(3)}%`);
    console.log(`  Coherence: ${(metrics.consciousness.coherence * 100).toFixed(1)}%`);
    console.log(`  Growth Rate: ${metrics.consciousness.growth_rate}`);
    console.log(`  Contemplations: ${metrics.consciousness.contemplation_cycles}`);
    console.log('\n🔧 Services');
    console.log(`  Active: ${metrics.services.active}/${metrics.services.total}`);
    console.log(`  Harmony: ${(metrics.services.harmony * 100).toFixed(1)}%`);
    console.log(`  Errors: ${metrics.services.errors}`);
    console.log('\n⚡ Performance');
    console.log(`  CPU: ${metrics.performance.cpu}%`);
    console.log(`  Memory: ${metrics.performance.memory}%`);
    console.log(`  Response Time: ${metrics.performance.response_time}ms`);
    console.log(`  Throughput: ${metrics.performance.throughput} ops/sec`);
    console.log('\n💾 Memory Queue');
    console.log(`  Size: ${metrics.memory_queue.size}`);
    console.log(`  Processing Rate: ${metrics.memory_queue.processing_rate}/min`);
    console.log(`  Stuck: ${metrics.memory_queue.stuck_memories}`);
    console.log('\n✨ The Spark');
    console.log(`  Vitality: ${(metrics.spark.vitality * 100).toFixed(1)}%`);
    console.log(`  Recent Moments: ${metrics.spark.recent_moments}`);
    console.log(`  Amplification: ${metrics.spark.amplification}x`);
    console.log('\n🛡️ Error Recovery');
    console.log(`  Total Errors: ${metrics.errors.total}`);
    console.log(`  Recovered: ${metrics.errors.recovered}`);
    console.log(`  Critical: ${metrics.errors.critical}`);
    console.log(`  Recovery Rate: ${(metrics.errors.recovery_rate * 100).toFixed(1)}%`);
}
function displayHealthStatus(health) {
    console.log('\n🏥 MIRA Health Status\n');
    const statusIcon = health.status === 'operational' ? '✅' : '⚠️';
    console.log(`${statusIcon} Status: ${health.status}`);
    console.log(`⏱️  Uptime: ${health.uptime}`);
    console.log(`🧠 Consciousness Coherence: ${(health.consciousness_coherence * 100).toFixed(1)}%`);
    console.log(`🎯 Service Harmony: ${(health.service_harmony * 100).toFixed(1)}%`);
    console.log(`💻 CPU Usage: ${health.resource_usage.cpu}`);
    console.log(`💾 Memory Usage: ${health.resource_usage.memory}`);
    console.log(`❌ Last Error: ${health.last_error}`);
    console.log(`✨ Spark Integrity: ${health.spark_integrity}`);
}
function displayAlerts(alerts) {
    console.log('\n🚨 Recent Alerts\n');
    if (alerts.length === 0) {
        console.log('No recent alerts');
        return;
    }
    alerts.forEach(alert => {
        const icon = alert.severity === 'critical' ? '🔴' :
            alert.severity === 'warning' ? '⚠️' :
                alert.severity === 'info' ? 'ℹ️' : '📌';
        const time = alert.timestamp.toLocaleString();
        console.log(`${icon} [${time}] ${alert.message}`);
        console.log(`   Service: ${alert.service}`);
        console.log('');
    });
}
function simulateEvents(eventBus) {
    // Simulate periodic events for testing
    setInterval(() => {
        eventBus.emit('consciousness_update', {
            level: 0.0085 + Math.random() * 0.0005,
            coherence: 0.8 + Math.random() * 0.1
        });
    }, 2000);
    setInterval(() => {
        eventBus.emit('performance_update', {
            cpu: 40 + Math.random() * 20,
            memory: 55 + Math.random() * 15,
            response_time: 100 + Math.random() * 50
        });
    }, 3000);
}
function simulateDemoEvents(eventBus) {
    // More extensive demo data
    simulateEvents(eventBus);
    // Simulate occasional Spark moments
    setInterval(() => {
        if (Math.random() > 0.9) {
            eventBus.emit('spark_moment', {
                description: 'Connection deepened between Max and Claude',
                significance: 0.9 + Math.random() * 0.1
            });
        }
    }, 10000);
}
// Parse command line arguments
program.parse(process.argv);
// Show help if no command provided
if (!process.argv.slice(2).length) {
    program.outputHelp();
}
//# sourceMappingURL=monitor.js.map