genesis-ai-cli 7.4.5

package/dist/src/daemon/scheduler.js

@@ -0,0 +1,494 @@
+"use strict";
+/**
+ * Genesis 6.0 - Task Scheduler
+ *
+ * Background task scheduling with priorities, retries, and monitoring.
+ *
+ * Features:
+ * - Priority-based execution queue
+ * - Interval and cron scheduling
+ * - Automatic retries with backoff
+ * - Task timeout handling
+ * - Concurrent execution limits
+ *
+ * Usage:
+ * ```typescript
+ * import { createScheduler } from './daemon/scheduler.js';
+ *
+ * const scheduler = createScheduler({ maxConcurrentTasks: 5 });
+ *
+ * // Schedule a recurring task
+ * scheduler.schedule({
+ *   name: 'health-check',
+ *   schedule: { type: 'interval', intervalMs: 60000 },
+ *   handler: async (ctx) => {
+ *     ctx.logger.info('Running health check');
+ *     return { success: true, duration: 50 };
+ *   },
+ * });
+ *
+ * // Start the scheduler
+ * scheduler.start();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = exports.DEFAULT_SCHEDULER_CONFIG = void 0;
+exports.createScheduler = createScheduler;
+const crypto_1 = require("crypto");
+exports.DEFAULT_SCHEDULER_CONFIG = {
+    maxConcurrentTasks: 5,
+    defaultTimeout: 60000, // 1 minute
+    defaultRetries: 3,
+    defaultRetryDelay: 1000, // 1 second
+    tickIntervalMs: 1000, // Check every second
+};
+// ============================================================================
+// Priority Queue
+// ============================================================================
+const PRIORITY_ORDER = {
+    critical: 0,
+    high: 1,
+    normal: 2,
+    low: 3,
+    idle: 4,
+};
+function compareTasks(a, b) {
+    // First by priority
+    const priorityDiff = PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority];
+    if (priorityDiff !== 0)
+        return priorityDiff;
+    // Then by next run time
+    if (a.nextRun && b.nextRun) {
+        return a.nextRun.getTime() - b.nextRun.getTime();
+    }
+    if (a.nextRun)
+        return -1;
+    if (b.nextRun)
+        return 1;
+    // Finally by creation time
+    return a.createdAt.getTime() - b.createdAt.getTime();
+}
+// ============================================================================
+// Task Logger Implementation
+// ============================================================================
+function createTaskLogger(taskId, taskName) {
+    const prefix = `[Task:${taskName}]`;
+    return {
+        debug(message, data) {
+            if (process.env.LOG_LEVEL === 'debug') {
+                console.log(`${prefix} DEBUG: ${message}`, data || '');
+            }
+        },
+        info(message, data) {
+            console.log(`${prefix} INFO: ${message}`, data || '');
+        },
+        warn(message, data) {
+            console.warn(`${prefix} WARN: ${message}`, data || '');
+        },
+        error(message, error) {
+            console.error(`${prefix} ERROR: ${message}`, error?.message || '');
+        },
+    };
+}
+// ============================================================================
+// Cron Parser (Simplified)
+// ============================================================================
+/**
+ * Parse a simplified cron expression
+ * Format: minute hour day-of-month month day-of-week
+ * Supports: *, numbers, ranges (1-5), steps (* /5)
+ */
+function parseCron(expression) {
+    const parts = expression.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`Invalid cron expression: ${expression}`);
+    }
+    const parse = (part, min, max) => {
+        if (part === '*') {
+            return Array.from({ length: max - min + 1 }, (_, i) => min + i);
+        }
+        // Handle step (*/5)
+        if (part.startsWith('*/')) {
+            const step = parseInt(part.slice(2), 10);
+            const result = [];
+            for (let i = min; i <= max; i += step) {
+                result.push(i);
+            }
+            return result;
+        }
+        // Handle range (1-5)
+        if (part.includes('-')) {
+            const [start, end] = part.split('-').map((n) => parseInt(n, 10));
+            const result = [];
+            for (let i = start; i <= end; i++) {
+                result.push(i);
+            }
+            return result;
+        }
+        // Handle list (1,3,5)
+        if (part.includes(',')) {
+            return part.split(',').map((n) => parseInt(n, 10));
+        }
+        // Single value
+        return [parseInt(part, 10)];
+    };
+    return {
+        minutes: parse(parts[0], 0, 59),
+        hours: parse(parts[1], 0, 23),
+        days: parse(parts[2], 1, 31),
+        months: parse(parts[3], 1, 12),
+        weekdays: parse(parts[4], 0, 6),
+    };
+}
+function getNextCronTime(expression, after = new Date()) {
+    const cron = parseCron(expression);
+    const next = new Date(after);
+    next.setSeconds(0, 0);
+    next.setMinutes(next.getMinutes() + 1);
+    // Search up to 1 year ahead
+    const maxIterations = 366 * 24 * 60;
+    for (let i = 0; i < maxIterations; i++) {
+        const month = next.getMonth() + 1;
+        const day = next.getDate();
+        const weekday = next.getDay();
+        const hour = next.getHours();
+        const minute = next.getMinutes();
+        if (cron.months.includes(month) &&
+            cron.days.includes(day) &&
+            cron.weekdays.includes(weekday) &&
+            cron.hours.includes(hour) &&
+            cron.minutes.includes(minute)) {
+            return next;
+        }
+        next.setMinutes(next.getMinutes() + 1);
+    }
+    throw new Error(`Could not find next cron time for: ${expression}`);
+}
+class Scheduler {
+    tasks = new Map();
+    running = new Set();
+    tickTimer = null;
+    config;
+    started = false;
+    eventHandlers = new Set();
+    constructor(config = {}) {
+        this.config = { ...exports.DEFAULT_SCHEDULER_CONFIG, ...config };
+    }
+    // ============================================================================
+    // Lifecycle
+    // ============================================================================
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.tickTimer = setInterval(() => this.tick(), this.config.tickIntervalMs);
+        this.emit({ type: 'started' });
+        // Run immediate tasks
+        this.tick();
+    }
+    stop() {
+        if (!this.started)
+            return;
+        this.started = false;
+        if (this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = null;
+        }
+        this.emit({ type: 'stopped' });
+    }
+    isRunning() {
+        return this.started;
+    }
+    // ============================================================================
+    // Task Management
+    // ============================================================================
+    schedule(options) {
+        const id = (0, crypto_1.randomUUID)();
+        const now = new Date();
+        const task = {
+            id,
+            name: options.name,
+            description: options.description,
+            state: 'pending',
+            priority: options.priority || 'normal',
+            schedule: options.schedule,
+            nextRun: this.calculateNextRun(options.schedule, now),
+            lastRun: null,
+            handler: options.handler,
+            timeout: options.timeout || this.config.defaultTimeout,
+            retries: options.retries ?? this.config.defaultRetries,
+            retryDelay: options.retryDelay || this.config.defaultRetryDelay,
+            runCount: 0,
+            successCount: 0,
+            failureCount: 0,
+            avgDuration: 0,
+            createdAt: now,
+            tags: options.tags || [],
+        };
+        if (task.nextRun) {
+            task.state = 'scheduled';
+        }
+        this.tasks.set(id, task);
+        this.emit({ type: 'task_scheduled', task });
+        return task;
+    }
+    cancel(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return false;
+        if (task.state === 'running') {
+            // Can't cancel running tasks directly (they have abort signals)
+            return false;
+        }
+        task.state = 'cancelled';
+        this.emit({ type: 'task_cancelled', task });
+        return true;
+    }
+    remove(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return false;
+        if (task.state === 'running') {
+            return false; // Can't remove running tasks
+        }
+        return this.tasks.delete(taskId);
+    }
+    pause(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return false;
+        if (task.state === 'scheduled' || task.state === 'pending') {
+            task.state = 'paused';
+            return true;
+        }
+        return false;
+    }
+    resume(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return false;
+        if (task.state === 'paused') {
+            task.state = task.nextRun ? 'scheduled' : 'pending';
+            return true;
+        }
+        return false;
+    }
+    trigger(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return false;
+        if (task.state !== 'running') {
+            task.nextRun = new Date();
+            task.state = 'scheduled';
+            return true;
+        }
+        return false;
+    }
+    // ============================================================================
+    // Query
+    // ============================================================================
+    get(taskId) {
+        return this.tasks.get(taskId);
+    }
+    getByName(name) {
+        for (const task of this.tasks.values()) {
+            if (task.name === name)
+                return task;
+        }
+        return undefined;
+    }
+    getAll() {
+        return Array.from(this.tasks.values());
+    }
+    getPending() {
+        return this.getAll().filter((t) => ['pending', 'scheduled'].includes(t.state));
+    }
+    getRunning() {
+        return this.getAll().filter((t) => t.state === 'running');
+    }
+    getByTag(tag) {
+        return this.getAll().filter((t) => t.tags.includes(tag));
+    }
+    // ============================================================================
+    // Stats
+    // ============================================================================
+    stats() {
+        const tasks = this.getAll();
+        return {
+            total: tasks.length,
+            pending: tasks.filter((t) => t.state === 'pending').length,
+            scheduled: tasks.filter((t) => t.state === 'scheduled').length,
+            running: tasks.filter((t) => t.state === 'running').length,
+            completed: tasks.filter((t) => t.state === 'completed').length,
+            failed: tasks.filter((t) => t.state === 'failed').length,
+            cancelled: tasks.filter((t) => t.state === 'cancelled').length,
+            paused: tasks.filter((t) => t.state === 'paused').length,
+        };
+    }
+    // ============================================================================
+    // 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('Scheduler event handler error:', err);
+            }
+        }
+    }
+    // ============================================================================
+    // Internal
+    // ============================================================================
+    async tick() {
+        if (!this.started)
+            return;
+        const now = new Date();
+        const dueTasks = this.getDueTasks(now);
+        // Sort by priority
+        dueTasks.sort(compareTasks);
+        // Execute up to max concurrent
+        const available = this.config.maxConcurrentTasks - this.running.size;
+        const toRun = dueTasks.slice(0, available);
+        for (const task of toRun) {
+            this.executeTask(task);
+        }
+    }
+    getDueTasks(now) {
+        const due = [];
+        for (const task of this.tasks.values()) {
+            if (task.state === 'scheduled' && task.nextRun && task.nextRun <= now) {
+                due.push(task);
+            }
+            if (task.state === 'pending' && task.schedule.type === 'immediate') {
+                due.push(task);
+            }
+        }
+        return due;
+    }
+    async executeTask(task) {
+        task.state = 'running';
+        this.running.add(task.id);
+        this.emit({ type: 'task_started', task });
+        const startTime = Date.now();
+        let attempt = 0;
+        let lastError;
+        while (attempt <= task.retries) {
+            attempt++;
+            try {
+                const result = await this.runWithTimeout(task, attempt);
+                if (result.success) {
+                    // Success
+                    task.successCount++;
+                    task.runCount++;
+                    task.lastRun = new Date();
+                    // Update average duration
+                    const newAvg = (task.avgDuration * (task.runCount - 1) + result.duration) / task.runCount;
+                    task.avgDuration = newAvg;
+                    // Reschedule if recurring
+                    const nextRun = this.calculateNextRun(task.schedule, task.lastRun);
+                    if (nextRun) {
+                        task.nextRun = nextRun;
+                        task.state = 'scheduled';
+                    }
+                    else {
+                        task.state = 'completed';
+                    }
+                    this.emit({ type: 'task_completed', task });
+                    break;
+                }
+                else {
+                    lastError = result.error;
+                    if (attempt <= task.retries) {
+                        await this.sleep(task.retryDelay * attempt); // Exponential backoff
+                    }
+                }
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                if (attempt <= task.retries) {
+                    await this.sleep(task.retryDelay * attempt);
+                }
+            }
+        }
+        // If we exhausted all retries
+        if (task.state === 'running') {
+            task.failureCount++;
+            task.runCount++;
+            task.lastRun = new Date();
+            // Still reschedule if recurring
+            const nextRun = this.calculateNextRun(task.schedule, task.lastRun);
+            if (nextRun) {
+                task.nextRun = nextRun;
+                task.state = 'scheduled';
+            }
+            else {
+                task.state = 'failed';
+            }
+            this.emit({ type: 'task_failed', task, error: lastError });
+        }
+        this.running.delete(task.id);
+    }
+    async runWithTimeout(task, attempt) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), task.timeout);
+        const context = {
+            taskId: task.id,
+            attempt,
+            maxAttempts: task.retries + 1,
+            startedAt: new Date(),
+            timeout: task.timeout,
+            signal: controller.signal,
+            logger: createTaskLogger(task.id, task.name),
+        };
+        try {
+            const startTime = Date.now();
+            const result = await task.handler(context);
+            clearTimeout(timeout);
+            return {
+                ...result,
+                duration: result.duration || (Date.now() - startTime),
+            };
+        }
+        catch (err) {
+            clearTimeout(timeout);
+            return {
+                success: false,
+                duration: Date.now() - context.startedAt.getTime(),
+                error: err instanceof Error ? err : new Error(String(err)),
+            };
+        }
+    }
+    calculateNextRun(schedule, after) {
+        switch (schedule.type) {
+            case 'once':
+                // Already passed
+                return schedule.at > after ? schedule.at : null;
+            case 'immediate':
+                return null; // Only run once
+            case 'manual':
+                return null; // Triggered manually
+            case 'interval':
+                return new Date(after.getTime() + schedule.intervalMs);
+            case 'cron':
+                return getNextCronTime(schedule.expression, after);
+            default:
+                return null;
+        }
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.Scheduler = Scheduler;
+// ============================================================================
+// Factory
+// ============================================================================
+function createScheduler(config) {
+    return new Scheduler(config);
+}

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

@@ -0,0 +1,213 @@
+/**
+ * Genesis 6.0 - Daemon Module Types
+ *
+ * Types for background task scheduling, maintenance, and dream mode.
+ *
+ * Based on:
+ * - Node.js daemon patterns
+ * - Self-healing systems (Kubernetes liveness/readiness)
+ * - Sleep consolidation research (Walker, 2017)
+ */
+export type DaemonState = 'stopped' | 'starting' | 'running' | 'dreaming' | 'maintaining' | 'stopping' | 'error';
+export interface DaemonStatus {
+    state: DaemonState;
+    uptime: number;
+    startedAt: Date | null;
+    lastHeartbeat: Date;
+    activeTasks: number;
+    completedTasks: number;
+    failedTasks: number;
+    dreamCycles: number;
+    maintenanceCycles: number;
+    errors: DaemonError[];
+}
+export interface DaemonError {
+    timestamp: Date;
+    code: string;
+    message: string;
+    source: 'scheduler' | 'maintenance' | 'dream' | 'task';
+    recovered: boolean;
+}
+export type TaskPriority = 'critical' | 'high' | 'normal' | 'low' | 'idle';
+export type TaskState = 'pending' | 'scheduled' | 'running' | 'completed' | 'failed' | 'cancelled' | 'paused';
+export interface ScheduledTask {
+    id: string;
+    name: string;
+    description?: string;
+    state: TaskState;
+    priority: TaskPriority;
+    schedule: TaskSchedule;
+    nextRun: Date | null;
+    lastRun: Date | null;
+    handler: TaskHandler;
+    timeout: number;
+    retries: number;
+    retryDelay: number;
+    runCount: number;
+    successCount: number;
+    failureCount: number;
+    avgDuration: number;
+    createdAt: Date;
+    tags: string[];
+}
+export type TaskSchedule = {
+    type: 'once';
+    at: Date;
+} | {
+    type: 'interval';
+    intervalMs: number;
+} | {
+    type: 'cron';
+    expression: string;
+} | {
+    type: 'immediate';
+} | {
+    type: 'manual';
+};
+export type TaskHandler = (context: TaskContext) => Promise<TaskResult>;
+export interface TaskContext {
+    taskId: string;
+    attempt: number;
+    maxAttempts: number;
+    startedAt: Date;
+    timeout: number;
+    signal: AbortSignal;
+    logger: TaskLogger;
+}
+export interface TaskLogger {
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, error?: Error): void;
+}
+export interface TaskResult {
+    success: boolean;
+    duration: number;
+    output?: unknown;
+    error?: Error;
+    metrics?: Record<string, number>;
+}
+export interface CreateTaskOptions {
+    name: string;
+    description?: string;
+    handler: TaskHandler;
+    schedule: TaskSchedule;
+    priority?: TaskPriority;
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+    tags?: string[];
+}
+export type MaintenanceAction = 'agent_restart' | 'memory_cleanup' | 'cache_clear' | 'health_check' | 'invariant_repair' | 'state_reset' | 'log_rotation' | 'resource_reclaim';
+export interface MaintenanceTask {
+    id: string;
+    action: MaintenanceAction;
+    target?: string;
+    priority: TaskPriority;
+    state: TaskState;
+    reason: string;
+    startedAt?: Date;
+    completedAt?: Date;
+    success?: boolean;
+    details?: string;
+}
+export interface MaintenanceConfig {
+    enabled: boolean;
+    intervalMs: number;
+    healthCheckIntervalMs: number;
+    memoryCleanupIntervalMs: number;
+    autoRepair: boolean;
+    maxConcurrentTasks: number;
+    unhealthyAgentThreshold: number;
+    memoryRetentionThreshold: number;
+    resourceUsageThreshold: number;
+}
+export interface MaintenanceReport {
+    timestamp: Date;
+    duration: number;
+    tasksRun: number;
+    tasksSucceeded: number;
+    tasksFailed: number;
+    issues: MaintenanceIssue[];
+    actions: MaintenanceTask[];
+}
+export interface MaintenanceIssue {
+    type: string;
+    severity: 'critical' | 'warning' | 'info';
+    description: string;
+    detected: Date;
+    resolved: boolean;
+    resolution?: string;
+}
+export type DreamPhase = 'light' | 'deep' | 'rem' | 'wake';
+export interface DreamConfig {
+    enabled: boolean;
+    autoTrigger: boolean;
+    inactivityThresholdMs: number;
+    minDreamDurationMs: number;
+    maxDreamDurationMs: number;
+    lightSleepRatio: number;
+    deepSleepRatio: number;
+    remSleepRatio: number;
+    episodicConsolidationThreshold: number;
+    patternExtractionThreshold: number;
+    creativityTemperature: number;
+}
+export interface DreamSession {
+    id: string;
+    startedAt: Date;
+    endedAt?: Date;
+    phase: DreamPhase;
+    phaseHistory: Array<{
+        phase: DreamPhase;
+        enteredAt: Date;
+        exitedAt?: Date;
+    }>;
+    results?: DreamResults;
+    interrupted: boolean;
+    interruptReason?: string;
+}
+export interface DreamResults {
+    episodesProcessed: number;
+    memoriesConsolidated: number;
+    patternsExtracted: number;
+    skillsReinforced: number;
+    memoriesForgotten: number;
+    newAssociations: number;
+    novelIdeas: string[];
+    stateRepairs: number;
+    invariantsChecked: number;
+}
+export interface DreamMetrics {
+    totalDreamTime: number;
+    dreamCycles: number;
+    avgCycleDuration: number;
+    consolidationRate: number;
+    patternExtractionRate: number;
+    lastDreamAt: Date | null;
+    nextScheduledDream: Date | null;
+}
+export interface DaemonConfig {
+    enabled: boolean;
+    heartbeatIntervalMs: number;
+    maxErrors: number;
+    scheduler: {
+        enabled: boolean;
+        maxConcurrentTasks: number;
+        defaultTimeout: number;
+        defaultRetries: number;
+    };
+    maintenance: MaintenanceConfig;
+    dream: DreamConfig;
+    logLevel: 'debug' | 'info' | 'warn' | 'error';
+    logToFile: boolean;
+    logFilePath?: string;
+}
+export declare const DEFAULT_DAEMON_CONFIG: DaemonConfig;
+export type DaemonEventType = 'daemon_started' | 'daemon_stopped' | 'daemon_error' | 'task_scheduled' | 'task_started' | 'task_completed' | 'task_failed' | 'task_cancelled' | 'maintenance_started' | 'maintenance_completed' | 'maintenance_issue' | 'dream_started' | 'dream_phase_changed' | 'dream_completed' | 'dream_interrupted';
+export interface DaemonEvent {
+    type: DaemonEventType;
+    timestamp: Date;
+    data: unknown;
+}
+export type DaemonEventHandler = (event: DaemonEvent) => void;