genesis-ai-cli 7.4.5

package/dist/src/daemon/index.js

@@ -0,0 +1,542 @@
+"use strict";
+/**
+ * Genesis 6.0 - Daemon Module
+ *
+ * Unified daemon for background task scheduling, self-maintenance, and dream mode.
+ *
+ * This module provides:
+ * - Scheduler: Background task execution with priorities and retries
+ * - Maintenance: Self-repair and health monitoring
+ * - Dream Mode: Offline memory consolidation and creative synthesis
+ *
+ * Usage:
+ * ```typescript
+ * import { createDaemon } from './daemon/index.js';
+ * import { createMemorySystem } from './memory/index.js';
+ *
+ * const memory = createMemorySystem();
+ * const daemon = createDaemon({ memory });
+ *
+ * // Start the daemon
+ * daemon.start();
+ *
+ * // Schedule a custom task
+ * daemon.schedule({
+ *   name: 'my-task',
+ *   schedule: { type: 'interval', intervalMs: 60000 },
+ *   handler: async (ctx) => {
+ *     ctx.logger.info('Running my task');
+ *     return { success: true, duration: 100 };
+ *   },
+ * });
+ *
+ * // Trigger a dream session
+ * await daemon.dream();
+ *
+ * // Check status
+ * console.log(daemon.status());
+ *
+ * // Stop the daemon
+ * daemon.stop();
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Daemon = exports.createDreamService = exports.DreamService = exports.createMaintenanceService = exports.MaintenanceService = exports.createScheduler = exports.Scheduler = void 0;
+exports.createDaemon = createDaemon;
+exports.getDaemon = getDaemon;
+exports.resetDaemon = resetDaemon;
+// Re-export types
+__exportStar(require("./types.js"), exports);
+// Re-export components
+var scheduler_js_1 = require("./scheduler.js");
+Object.defineProperty(exports, "Scheduler", { enumerable: true, get: function () { return scheduler_js_1.Scheduler; } });
+Object.defineProperty(exports, "createScheduler", { enumerable: true, get: function () { return scheduler_js_1.createScheduler; } });
+var maintenance_js_1 = require("./maintenance.js");
+Object.defineProperty(exports, "MaintenanceService", { enumerable: true, get: function () { return maintenance_js_1.MaintenanceService; } });
+Object.defineProperty(exports, "createMaintenanceService", { enumerable: true, get: function () { return maintenance_js_1.createMaintenanceService; } });
+var dream_mode_js_1 = require("./dream-mode.js");
+Object.defineProperty(exports, "DreamService", { enumerable: true, get: function () { return dream_mode_js_1.DreamService; } });
+Object.defineProperty(exports, "createDreamService", { enumerable: true, get: function () { return dream_mode_js_1.createDreamService; } });
+const types_js_1 = require("./types.js");
+const scheduler_js_2 = require("./scheduler.js");
+const maintenance_js_2 = require("./maintenance.js");
+const dream_mode_js_2 = require("./dream-mode.js");
+// ============================================================================
+// Daemon Class
+// ============================================================================
+class Daemon {
+    config;
+    state = 'stopped';
+    startedAt = null;
+    errors = [];
+    eventHandlers = new Set();
+    heartbeatTimer = null;
+    // Components
+    scheduler;
+    maintenance;
+    dreamService;
+    // Dependencies
+    deps;
+    constructor(deps = {}, config = {}) {
+        this.config = { ...types_js_1.DEFAULT_DAEMON_CONFIG, ...config };
+        this.deps = deps;
+        // Create components
+        this.scheduler = (0, scheduler_js_2.createScheduler)(this.config.scheduler);
+        this.maintenance = (0, maintenance_js_2.createMaintenanceService)(this.config.maintenance, this.buildMaintenanceContext());
+        this.dreamService = (0, dream_mode_js_2.createDreamService)(this.config.dream, this.buildDreamContext());
+        // Wire up events
+        this.setupEventForwarding();
+        // Setup default tasks
+        this.setupDefaultTasks();
+    }
+    // ============================================================================
+    // Lifecycle
+    // ============================================================================
+    start() {
+        if (this.state !== 'stopped') {
+            throw new Error(`Cannot start daemon in state: ${this.state}`);
+        }
+        this.state = 'starting';
+        this.startedAt = new Date();
+        this.log('Daemon starting...');
+        // Start heartbeat
+        this.heartbeatTimer = setInterval(() => this.heartbeat(), this.config.heartbeatIntervalMs);
+        // Start components
+        if (this.config.scheduler.enabled) {
+            this.scheduler.start();
+        }
+        if (this.config.maintenance.enabled) {
+            this.maintenance.start();
+        }
+        if (this.config.dream.autoTrigger) {
+            this.dreamService.startAutoTrigger();
+        }
+        this.state = 'running';
+        this.emit({ type: 'daemon_started', timestamp: new Date(), data: null });
+        this.log('Daemon started');
+    }
+    stop() {
+        if (this.state === 'stopped' || this.state === 'stopping') {
+            return;
+        }
+        this.state = 'stopping';
+        this.log('Daemon stopping...');
+        // Stop heartbeat
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        // Stop components
+        this.scheduler.stop();
+        this.maintenance.stop();
+        this.dreamService.stopAutoTrigger();
+        // Interrupt dream if running
+        if (this.dreamService.isDreaming()) {
+            this.dreamService.interruptDream('Daemon stopping');
+        }
+        this.state = 'stopped';
+        this.emit({ type: 'daemon_stopped', timestamp: new Date(), data: null });
+        this.log('Daemon stopped');
+    }
+    restart() {
+        this.stop();
+        this.start();
+    }
+    getState() {
+        return this.state;
+    }
+    isRunning() {
+        return this.state === 'running' || this.state === 'dreaming' || this.state === 'maintaining';
+    }
+    // ============================================================================
+    // Task Scheduling
+    // ============================================================================
+    schedule(options) {
+        return this.scheduler.schedule(options);
+    }
+    cancelTask(taskId) {
+        return this.scheduler.cancel(taskId);
+    }
+    triggerTask(taskId) {
+        return this.scheduler.trigger(taskId);
+    }
+    getTasks() {
+        return this.scheduler.getAll();
+    }
+    // ============================================================================
+    // Maintenance
+    // ============================================================================
+    async runMaintenance() {
+        const previousState = this.state;
+        this.state = 'maintaining';
+        try {
+            const report = await this.maintenance.runCycle();
+            return report;
+        }
+        finally {
+            this.state = previousState;
+        }
+    }
+    getMaintenanceIssues() {
+        return this.maintenance.getOpenIssues();
+    }
+    // ============================================================================
+    // Dream Mode
+    // ============================================================================
+    async dream(options = {}) {
+        if (this.dreamService.isDreaming()) {
+            throw new Error('Already dreaming');
+        }
+        const previousState = this.state;
+        this.state = 'dreaming';
+        try {
+            await this.dreamService.startDream(options);
+            const results = await this.dreamService.waitForWake();
+            return results;
+        }
+        finally {
+            this.state = previousState;
+        }
+    }
+    interruptDream(reason) {
+        return this.dreamService.interruptDream(reason);
+    }
+    isDreaming() {
+        return this.dreamService.isDreaming();
+    }
+    getDreamMetrics() {
+        return this.dreamService.getMetrics();
+    }
+    // ============================================================================
+    // Activity Tracking
+    // ============================================================================
+    recordActivity() {
+        this.dreamService.recordActivity();
+    }
+    // ============================================================================
+    // Status
+    // ============================================================================
+    status() {
+        const now = new Date();
+        const uptime = this.startedAt
+            ? now.getTime() - this.startedAt.getTime()
+            : 0;
+        const schedulerStats = this.scheduler.stats();
+        return {
+            state: this.state,
+            uptime,
+            startedAt: this.startedAt,
+            lastHeartbeat: now,
+            activeTasks: schedulerStats.running,
+            completedTasks: schedulerStats.completed,
+            failedTasks: schedulerStats.failed,
+            dreamCycles: this.dreamService.getMetrics().dreamCycles,
+            maintenanceCycles: this.maintenance.stats().cyclesRun,
+            errors: this.errors.slice(-10), // Last 10 errors
+        };
+    }
+    // ============================================================================
+    // Events
+    // ============================================================================
+    on(handler) {
+        this.eventHandlers.add(handler);
+        return () => this.eventHandlers.delete(handler);
+    }
+    emit(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch (err) {
+                console.error('Daemon event handler error:', err);
+            }
+        }
+    }
+    // ============================================================================
+    // Internal
+    // ============================================================================
+    heartbeat() {
+        // Check for too many errors
+        if (this.errors.length >= this.config.maxErrors) {
+            const recentErrors = this.errors.filter((e) => Date.now() - e.timestamp.getTime() < 60000);
+            if (recentErrors.length >= this.config.maxErrors) {
+                this.log('Too many errors, entering error state', 'error');
+                this.state = 'error';
+                this.emit({
+                    type: 'daemon_error',
+                    timestamp: new Date(),
+                    data: { message: 'Too many errors' },
+                });
+            }
+        }
+    }
+    setupEventForwarding() {
+        // Forward scheduler events
+        this.scheduler.on((event) => {
+            const eventType = `task_${event.type.replace('task_', '')}`;
+            if (['task_scheduled', 'task_started', 'task_completed', 'task_failed', 'task_cancelled'].includes(eventType)) {
+                this.emit({
+                    type: eventType,
+                    timestamp: new Date(),
+                    data: event.task,
+                });
+            }
+        });
+        // Forward maintenance events
+        this.maintenance.on((event) => {
+            if (event.type === 'cycle_started') {
+                this.emit({
+                    type: 'maintenance_started',
+                    timestamp: new Date(),
+                    data: null,
+                });
+            }
+            else if (event.type === 'cycle_completed') {
+                this.emit({
+                    type: 'maintenance_completed',
+                    timestamp: new Date(),
+                    data: event.data,
+                });
+            }
+            else if (event.type === 'issue_detected') {
+                this.emit({
+                    type: 'maintenance_issue',
+                    timestamp: new Date(),
+                    data: event.data,
+                });
+            }
+        });
+        // Forward dream events
+        this.dreamService.on((event) => {
+            if (event.type === 'dream_started') {
+                this.emit({
+                    type: 'dream_started',
+                    timestamp: new Date(),
+                    data: event.session,
+                });
+            }
+            else if (event.type === 'phase_changed') {
+                this.emit({
+                    type: 'dream_phase_changed',
+                    timestamp: new Date(),
+                    data: event.data,
+                });
+            }
+            else if (event.type === 'dream_completed') {
+                this.emit({
+                    type: 'dream_completed',
+                    timestamp: new Date(),
+                    data: event.session?.results,
+                });
+            }
+            else if (event.type === 'dream_interrupted') {
+                this.emit({
+                    type: 'dream_interrupted',
+                    timestamp: new Date(),
+                    data: { reason: event.session?.interruptReason },
+                });
+            }
+        });
+    }
+    setupDefaultTasks() {
+        // Health check task
+        this.scheduler.schedule({
+            name: 'health-check',
+            description: 'Periodic agent health check',
+            schedule: { type: 'interval', intervalMs: this.config.maintenance.healthCheckIntervalMs },
+            priority: 'normal',
+            handler: async (ctx) => {
+                ctx.logger.debug('Running health check');
+                const issues = await this.maintenance.checkHealth();
+                return {
+                    success: true,
+                    duration: 0,
+                    output: { issues: issues.length },
+                };
+            },
+            tags: ['system', 'health'],
+        });
+        // Memory cleanup task
+        if (this.deps.memory) {
+            this.scheduler.schedule({
+                name: 'memory-cleanup',
+                description: 'Periodic memory forgetting and cleanup',
+                schedule: { type: 'interval', intervalMs: this.config.maintenance.memoryCleanupIntervalMs },
+                priority: 'low',
+                handler: async (ctx) => {
+                    ctx.logger.debug('Running memory cleanup');
+                    const result = await this.maintenance.cleanupMemory();
+                    return {
+                        success: true,
+                        duration: 0,
+                        output: result,
+                    };
+                },
+                tags: ['system', 'memory'],
+            });
+        }
+    }
+    buildMaintenanceContext() {
+        return {
+            checkAgentHealth: this.deps.kernel?.checkAgentHealth,
+            getMemoryStats: this.deps.memory
+                ? () => {
+                    const stats = this.deps.memory.getStats();
+                    return {
+                        total: stats.total,
+                        byType: {
+                            episodic: stats.episodic.total,
+                            semantic: stats.semantic.total,
+                            procedural: stats.procedural.total,
+                        },
+                        avgRetention: 0.5, // Would need to calculate from memories
+                    };
+                }
+                : undefined,
+            runMemoryForgetting: this.deps.memory
+                ? () => this.deps.memory.episodic.runForgetting()
+                : undefined,
+            runMemoryConsolidation: this.deps.memory
+                ? async () => {
+                    const result = await this.deps.memory.consolidation.sleep();
+                    return { consolidated: result.consolidated };
+                }
+                : undefined,
+            checkInvariants: this.deps.kernel?.checkInvariants,
+            repairInvariant: this.deps.kernel?.repairInvariant,
+            getState: this.deps.kernel?.getState,
+            resetState: this.deps.kernel?.resetState,
+            log: (message, level) => this.log(message, level),
+        };
+    }
+    buildDreamContext() {
+        return {
+            getEpisodicMemories: this.deps.memory
+                ? () => this.deps.memory.episodic.getAll()
+                : undefined,
+            getSemanticMemories: this.deps.memory
+                ? () => this.deps.memory.semantic.getAll()
+                : undefined,
+            getProceduralMemories: this.deps.memory
+                ? () => this.deps.memory.procedural.getAll()
+                : undefined,
+            consolidateMemory: this.deps.memory
+                ? async (episodeId) => {
+                    // This would need proper implementation
+                    return null;
+                }
+                : undefined,
+            extractPattern: this.deps.memory
+                ? async (episodeIds) => {
+                    // This would need proper implementation
+                    return null;
+                }
+                : undefined,
+            forgetMemory: this.deps.memory
+                ? (memoryId) => {
+                    // This would need proper implementation
+                    return false;
+                }
+                : undefined,
+            getState: this.deps.kernel?.getState,
+            rechargeEnergy: this.deps.kernel?.rechargeEnergy,
+            checkInvariants: this.deps.kernel
+                ? async () => {
+                    const results = await this.deps.kernel.checkInvariants();
+                    return results.every((r) => r.satisfied);
+                }
+                : undefined,
+            repairState: this.deps.kernel
+                ? async () => {
+                    // Count repairs
+                    return 0;
+                }
+                : undefined,
+            log: (message, level) => this.log(message, level),
+        };
+    }
+    log(message, level = 'info') {
+        if (this.deps.log) {
+            this.deps.log(message, level);
+        }
+        else {
+            const prefix = '[Daemon]';
+            const shouldLog = level === 'error' ||
+                level === 'warn' ||
+                (level === 'info' && this.config.logLevel !== 'error' && this.config.logLevel !== 'warn') ||
+                (level === 'debug' && this.config.logLevel === 'debug');
+            if (shouldLog) {
+                switch (level) {
+                    case 'debug':
+                        console.log(`${prefix} DEBUG: ${message}`);
+                        break;
+                    case 'info':
+                        console.log(`${prefix} ${message}`);
+                        break;
+                    case 'warn':
+                        console.warn(`${prefix} ${message}`);
+                        break;
+                    case 'error':
+                        console.error(`${prefix} ${message}`);
+                        break;
+                }
+            }
+        }
+    }
+    recordError(code, message, source) {
+        const error = {
+            timestamp: new Date(),
+            code,
+            message,
+            source,
+            recovered: false,
+        };
+        this.errors.push(error);
+        // Keep only last 100 errors
+        if (this.errors.length > 100) {
+            this.errors = this.errors.slice(-100);
+        }
+        this.emit({
+            type: 'daemon_error',
+            timestamp: new Date(),
+            data: error,
+        });
+    }
+}
+exports.Daemon = Daemon;
+// ============================================================================
+// Factory
+// ============================================================================
+function createDaemon(deps, config) {
+    return new Daemon(deps, config);
+}
+// ============================================================================
+// Singleton Instance (optional)
+// ============================================================================
+let daemonInstance = null;
+function getDaemon(deps, config) {
+    if (!daemonInstance) {
+        daemonInstance = createDaemon(deps, config);
+    }
+    return daemonInstance;
+}
+function resetDaemon() {
+    if (daemonInstance) {
+        daemonInstance.stop();
+        daemonInstance = null;
+    }
+}

package/dist/src/daemon/maintenance.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Genesis 6.0 - Maintenance Service
+ *
+ * Self-repair and health maintenance for the Genesis system.
+ *
+ * Features:
+ * - Health monitoring (agent responsiveness)
+ * - Memory cleanup (weak memories, cache)
+ * - State repair (invariant violations)
+ * - Resource management
+ * - Automatic recovery
+ *
+ * Based on:
+ * - Kubernetes liveness/readiness probes
+ * - Self-healing systems patterns
+ * - Autonomic computing (IBM, 2001)
+ *
+ * Usage:
+ * ```typescript
+ * import { createMaintenanceService } from './daemon/maintenance.js';
+ *
+ * const maintenance = createMaintenanceService({
+ *   autoRepair: true,
+ *   intervalMs: 300000, // 5 minutes
+ * });
+ *
+ * // Run maintenance cycle
+ * const report = await maintenance.runCycle();
+ *
+ * // Check specific component
+ * const issues = await maintenance.checkHealth();
+ * ```
+ */
+import { MaintenanceConfig, MaintenanceTask, MaintenanceAction, MaintenanceReport, MaintenanceIssue } from './types.js';
+export interface HealthCheckResult {
+    component: string;
+    healthy: boolean;
+    latency?: number;
+    details?: string;
+    lastCheck: Date;
+}
+export interface SystemHealth {
+    overall: 'healthy' | 'degraded' | 'unhealthy';
+    components: HealthCheckResult[];
+    timestamp: Date;
+}
+export interface MaintenanceContext {
+    checkAgentHealth?: () => Promise<Array<{
+        id: string;
+        healthy: boolean;
+        latency?: number;
+    }>>;
+    getMemoryStats?: () => {
+        total: number;
+        byType: {
+            episodic: number;
+            semantic: number;
+            procedural: number;
+        };
+        avgRetention: number;
+    };
+    runMemoryForgetting?: () => {
+        forgotten: number;
+    };
+    runMemoryConsolidation?: () => Promise<{
+        consolidated: number;
+    }>;
+    checkInvariants?: () => Promise<Array<{
+        id: string;
+        satisfied: boolean;
+        message?: string;
+    }>>;
+    repairInvariant?: (id: string) => Promise<boolean>;
+    getState?: () => {
+        state: string;
+        energy: number;
+    };
+    resetState?: () => void;
+    log?: (message: string, level?: 'debug' | 'info' | 'warn' | 'error') => void;
+}
+export type MaintenanceEventType = 'cycle_started' | 'cycle_completed' | 'issue_detected' | 'issue_resolved' | 'action_started' | 'action_completed' | 'action_failed';
+export type MaintenanceEventHandler = (event: {
+    type: MaintenanceEventType;
+    data?: unknown;
+}) => void;
+export declare class MaintenanceService {
+    private config;
+    private context;
+    private tasks;
+    private issues;
+    private cycleTimer;
+    private running;
+    private eventHandlers;
+    private cyclesRun;
+    private issuesDetected;
+    private issuesResolved;
+    private lastCycleAt;
+    constructor(config?: Partial<MaintenanceConfig>, context?: MaintenanceContext);
+    start(): void;
+    stop(): void;
+    isRunning(): boolean;
+    setContext(context: Partial<MaintenanceContext>): void;
+    runCycle(): Promise<MaintenanceReport>;
+    checkHealth(): Promise<MaintenanceIssue[]>;
+    checkMemory(): Promise<MaintenanceIssue[]>;
+    checkInvariants(): Promise<MaintenanceIssue[]>;
+    checkResources(): Promise<MaintenanceIssue[]>;
+    autoRepair(issues: MaintenanceIssue[]): Promise<MaintenanceTask[]>;
+    private getRepairAction;
+    private createTask;
+    private getActionPriority;
+    private executeRepair;
+    runAction(action: MaintenanceAction, target?: string): Promise<MaintenanceTask>;
+    cleanupMemory(): Promise<{
+        forgotten: number;
+        consolidated: number;
+    }>;
+    getIssues(options?: {
+        severity?: 'critical' | 'warning' | 'info';
+        resolved?: boolean;
+        limit?: number;
+    }): MaintenanceIssue[];
+    getOpenIssues(): MaintenanceIssue[];
+    getTasks(): MaintenanceTask[];
+    stats(): {
+        cyclesRun: number;
+        issuesDetected: number;
+        issuesResolved: number;
+        openIssues: number;
+        lastCycleAt: Date | null;
+        tasksTotal: number;
+        tasksSucceeded: number;
+        tasksFailed: number;
+    };
+    on(handler: MaintenanceEventHandler): () => void;
+    private emit;
+    private log;
+}
+export declare function createMaintenanceService(config?: Partial<MaintenanceConfig>, context?: MaintenanceContext): MaintenanceService;