genesis-ai-cli 7.4.5

package/dist/src/active-inference/autonomous-loop.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Genesis 6.2 - Autonomous Loop
+ *
+ * Extracted to avoid circular dependencies.
+ * This module provides the AutonomousLoop class for running Active Inference cycles.
+ */
+import { ActiveInferenceEngine } from './core.js';
+import { ObservationGatherer } from './observations.js';
+import { ActionExecutorManager } from './actions.js';
+import { Observation, Beliefs, ActionType } from './types.js';
+export interface AutonomousLoopConfig {
+    cycleInterval: number;
+    maxCycles: number;
+    stopOnGoalAchieved: boolean;
+    stopOnEnergyCritical: boolean;
+    stopOnHighSurprise: boolean;
+    surpriseThreshold: number;
+    verbose: boolean;
+}
+export declare const DEFAULT_LOOP_CONFIG: AutonomousLoopConfig;
+export interface LoopStats {
+    cycles: number;
+    startTime: Date;
+    endTime?: Date;
+    actions: Record<string, number>;
+    avgSurprise: number;
+    finalBeliefs: Beliefs;
+}
+export declare class AutonomousLoop {
+    private config;
+    private engine;
+    private observations;
+    private actions;
+    private running;
+    private cycleCount;
+    private startTime?;
+    private stopReason?;
+    private onCycleHandlers;
+    private onStopHandlers;
+    private customStepFn;
+    constructor(config?: Partial<AutonomousLoopConfig>);
+    /**
+     * Run the autonomous loop
+     */
+    run(maxCycles?: number): Promise<LoopStats>;
+    /**
+     * Run a single inference cycle
+     */
+    cycle(): Promise<ActionType>;
+    /**
+     * Stop the loop
+     */
+    stop(reason?: string): void;
+    private checkStoppingConditions;
+    private handleEngineEvent;
+    /**
+     * Subscribe to cycle events
+     */
+    onCycle(handler: (cycle: number, action: ActionType, beliefs: Beliefs) => void): () => void;
+    /**
+     * Subscribe to stop events
+     */
+    onStop(handler: (reason: string, stats: LoopStats) => void): () => void;
+    isRunning(): boolean;
+    getCycleCount(): number;
+    getBeliefs(): Beliefs;
+    getMostLikelyState(): {
+        viability: string;
+        worldState: string;
+        coupling: string;
+        goalProgress: string;
+    };
+    getStats(): LoopStats;
+    /**
+     * Configure observation sources
+     */
+    configureObservations(sources: Parameters<ObservationGatherer['configure']>[0]): void;
+    /**
+     * Set action context
+     */
+    setActionContext(context: Parameters<ActionExecutorManager['setContext']>[0]): void;
+    /**
+     * Set custom step function for value-augmented inference
+     *
+     * This allows replacing the default Active Inference engine step
+     * with a custom function (e.g., ValueAugmentedEngine.step)
+     */
+    setCustomStepFunction(stepFn: ((obs: Observation) => Promise<{
+        action: ActionType;
+        beliefs: Beliefs;
+    }>) | null): void;
+    /**
+     * Get underlying components for advanced usage
+     */
+    getComponents(): {
+        engine: ActiveInferenceEngine;
+        observations: ObservationGatherer;
+        actions: ActionExecutorManager;
+    };
+}
+export declare function createAutonomousLoop(config?: Partial<AutonomousLoopConfig>): AutonomousLoop;
+export declare function getAutonomousLoop(config?: Partial<AutonomousLoopConfig>): AutonomousLoop;
+export declare function resetAutonomousLoop(): void;

package/dist/src/active-inference/autonomous-loop.js

@@ -0,0 +1,289 @@
+"use strict";
+/**
+ * Genesis 6.2 - Autonomous Loop
+ *
+ * Extracted to avoid circular dependencies.
+ * This module provides the AutonomousLoop class for running Active Inference cycles.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutonomousLoop = exports.DEFAULT_LOOP_CONFIG = void 0;
+exports.createAutonomousLoop = createAutonomousLoop;
+exports.getAutonomousLoop = getAutonomousLoop;
+exports.resetAutonomousLoop = resetAutonomousLoop;
+const core_js_1 = require("./core.js");
+const observations_js_1 = require("./observations.js");
+const actions_js_1 = require("./actions.js");
+exports.DEFAULT_LOOP_CONFIG = {
+    cycleInterval: 1000,
+    maxCycles: 0,
+    stopOnGoalAchieved: true,
+    stopOnEnergyCritical: true,
+    stopOnHighSurprise: false,
+    surpriseThreshold: 10,
+    verbose: false,
+};
+// ============================================================================
+// AutonomousLoop Class
+// ============================================================================
+class AutonomousLoop {
+    config;
+    // Components
+    engine;
+    observations;
+    actions;
+    // State
+    running = false;
+    cycleCount = 0;
+    startTime;
+    stopReason;
+    // Event handlers
+    onCycleHandlers = [];
+    onStopHandlers = [];
+    // Custom step function (for value integration)
+    customStepFn = null;
+    constructor(config = {}) {
+        this.config = { ...exports.DEFAULT_LOOP_CONFIG, ...config };
+        this.engine = (0, core_js_1.createActiveInferenceEngine)();
+        this.observations = (0, observations_js_1.createObservationGatherer)();
+        this.actions = (0, actions_js_1.createActionExecutorManager)();
+        // Subscribe to engine events
+        this.engine.on(this.handleEngineEvent.bind(this));
+    }
+    // ============================================================================
+    // Main Loop
+    // ============================================================================
+    /**
+     * Run the autonomous loop
+     */
+    async run(maxCycles) {
+        if (this.running) {
+            throw new Error('Loop is already running');
+        }
+        this.running = true;
+        this.cycleCount = 0;
+        this.startTime = new Date();
+        this.stopReason = undefined;
+        const limit = maxCycles ?? this.config.maxCycles;
+        if (this.config.verbose) {
+            console.log(`[AI Loop] Starting autonomous loop (max cycles: ${limit || 'unlimited'})`);
+        }
+        try {
+            while (this.running) {
+                // Check cycle limit
+                if (limit > 0 && this.cycleCount >= limit) {
+                    this.stopReason = 'cycle_limit';
+                    break;
+                }
+                // Run one cycle
+                await this.cycle();
+                // Wait for next cycle
+                if (this.config.cycleInterval > 0) {
+                    await new Promise(r => setTimeout(r, this.config.cycleInterval));
+                }
+            }
+        }
+        catch (error) {
+            this.stopReason = `error: ${error}`;
+            if (this.config.verbose) {
+                console.error(`[AI Loop] Error:`, error);
+            }
+        }
+        this.running = false;
+        const stats = this.getStats();
+        // Notify stop handlers
+        for (const handler of this.onStopHandlers) {
+            handler(this.stopReason || 'unknown', stats);
+        }
+        if (this.config.verbose) {
+            console.log(`[AI Loop] Stopped: ${this.stopReason}`);
+            console.log(`[AI Loop] Stats:`, stats);
+        }
+        return stats;
+    }
+    /**
+     * Run a single inference cycle
+     */
+    async cycle() {
+        this.cycleCount++;
+        // 1. Gather observations
+        const obs = await this.observations.gather();
+        if (this.config.verbose) {
+            console.log(`[AI Loop] Cycle ${this.cycleCount} - Observation:`, obs);
+        }
+        // 2. Run inference (beliefs + policy + action)
+        let action;
+        let beliefs;
+        if (this.customStepFn) {
+            // Use custom step function (e.g., value-augmented inference)
+            const result = await this.customStepFn(obs);
+            action = result.action;
+            beliefs = result.beliefs;
+        }
+        else {
+            // Use default Active Inference engine
+            action = this.engine.step(obs);
+            beliefs = this.engine.getBeliefs();
+        }
+        if (this.config.verbose) {
+            const state = this.engine.getMostLikelyState();
+            console.log(`[AI Loop] Cycle ${this.cycleCount} - Beliefs:`, state);
+            console.log(`[AI Loop] Cycle ${this.cycleCount} - Action: ${action}`);
+        }
+        // 3. Execute action
+        const result = await this.actions.execute(action);
+        if (this.config.verbose) {
+            console.log(`[AI Loop] Cycle ${this.cycleCount} - Result:`, result.success ? 'success' : result.error);
+        }
+        // 4. Check stopping conditions
+        this.checkStoppingConditions(obs);
+        // 5. Notify cycle handlers
+        for (const handler of this.onCycleHandlers) {
+            handler(this.cycleCount, action, beliefs);
+        }
+        return action;
+    }
+    /**
+     * Stop the loop
+     */
+    stop(reason = 'manual') {
+        this.stopReason = reason;
+        this.running = false;
+    }
+    // ============================================================================
+    // Stopping Conditions
+    // ============================================================================
+    checkStoppingConditions(obs) {
+        // Goal achieved
+        if (this.config.stopOnGoalAchieved && obs.task === 3) {
+            this.stop('goal_achieved');
+            return;
+        }
+        // Energy critical
+        if (this.config.stopOnEnergyCritical && obs.energy === 0) {
+            this.stop('energy_critical');
+            return;
+        }
+        // High surprise
+        if (this.config.stopOnHighSurprise) {
+            const stats = this.engine.getStats();
+            if (stats.averageSurprise > this.config.surpriseThreshold) {
+                this.stop('high_surprise');
+                return;
+            }
+        }
+    }
+    // ============================================================================
+    // Event Handling
+    // ============================================================================
+    handleEngineEvent(event) {
+        if (event.type === 'energy_critical' && this.config.stopOnEnergyCritical) {
+            this.stop('energy_critical');
+        }
+        if (event.type === 'goal_achieved' && this.config.stopOnGoalAchieved) {
+            this.stop('goal_achieved');
+        }
+    }
+    /**
+     * Subscribe to cycle events
+     */
+    onCycle(handler) {
+        this.onCycleHandlers.push(handler);
+        return () => {
+            const idx = this.onCycleHandlers.indexOf(handler);
+            if (idx >= 0)
+                this.onCycleHandlers.splice(idx, 1);
+        };
+    }
+    /**
+     * Subscribe to stop events
+     */
+    onStop(handler) {
+        this.onStopHandlers.push(handler);
+        return () => {
+            const idx = this.onStopHandlers.indexOf(handler);
+            if (idx >= 0)
+                this.onStopHandlers.splice(idx, 1);
+        };
+    }
+    // ============================================================================
+    // Getters
+    // ============================================================================
+    isRunning() {
+        return this.running;
+    }
+    getCycleCount() {
+        return this.cycleCount;
+    }
+    getBeliefs() {
+        return this.engine.getBeliefs();
+    }
+    getMostLikelyState() {
+        return this.engine.getMostLikelyState();
+    }
+    getStats() {
+        const engineStats = this.engine.getStats();
+        return {
+            cycles: this.cycleCount,
+            startTime: this.startTime || new Date(),
+            endTime: this.running ? undefined : new Date(),
+            actions: engineStats.actionCounts,
+            avgSurprise: engineStats.averageSurprise,
+            finalBeliefs: this.engine.getBeliefs(),
+        };
+    }
+    // ============================================================================
+    // Configuration
+    // ============================================================================
+    /**
+     * Configure observation sources
+     */
+    configureObservations(sources) {
+        this.observations.configure(sources);
+    }
+    /**
+     * Set action context
+     */
+    setActionContext(context) {
+        this.actions.setContext(context);
+    }
+    /**
+     * Set custom step function for value-augmented inference
+     *
+     * This allows replacing the default Active Inference engine step
+     * with a custom function (e.g., ValueAugmentedEngine.step)
+     */
+    setCustomStepFunction(stepFn) {
+        this.customStepFn = stepFn;
+    }
+    /**
+     * Get underlying components for advanced usage
+     */
+    getComponents() {
+        return {
+            engine: this.engine,
+            observations: this.observations,
+            actions: this.actions,
+        };
+    }
+}
+exports.AutonomousLoop = AutonomousLoop;
+// ============================================================================
+// Factory Functions
+// ============================================================================
+function createAutonomousLoop(config) {
+    return new AutonomousLoop(config);
+}
+// Singleton instance
+let loopInstance = null;
+function getAutonomousLoop(config) {
+    if (!loopInstance) {
+        loopInstance = createAutonomousLoop(config);
+    }
+    return loopInstance;
+}
+function resetAutonomousLoop() {
+    if (loopInstance?.isRunning()) {
+        loopInstance.stop('reset');
+    }
+    loopInstance = null;
+}

package/dist/src/active-inference/core.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Genesis 6.1 - Active Inference Core
+ *
+ * Pure mathematics for Active Inference (pymdp-style)
+ *
+ * Based on:
+ * - Free Energy Principle (Friston)
+ * - pymdp library (Python Active Inference)
+ * - RxInfer.jl (reactive message passing)
+ *
+ * Key functions:
+ * - inferStates: Update beliefs given observations
+ * - inferPolicies: Select policy by minimizing Expected Free Energy
+ * - sampleAction: Sample action from policy
+ *
+ * NO external dependencies - pure TypeScript math.
+ */
+import { Observation, Beliefs, Policy, ActiveInferenceConfig, ActionType, AIEventHandler } from './types.js';
+export declare class ActiveInferenceEngine {
+    private config;
+    private A;
+    private B;
+    private C;
+    private D;
+    private beliefs;
+    private eventHandlers;
+    private stats;
+    constructor(config?: Partial<ActiveInferenceConfig>);
+    /**
+     * Update beliefs given observations (state inference)
+     *
+     * Uses Bayesian inference:
+     * P(s|o) ∝ P(o|s) * P(s)
+     *
+     * Iterates to find fixed point (variational inference)
+     */
+    inferStates(observation: Observation): Beliefs;
+    /**
+     * Infer policies by minimizing Expected Free Energy (EFE)
+     *
+     * EFE = ambiguity + risk
+     *     = E[H(o|s,π)] + D_KL[Q(s|π) || P(s)]
+     *
+     * Lower EFE = better policy
+     */
+    inferPolicies(): Policy;
+    /**
+     * Sample action from policy
+     */
+    sampleAction(policy: Policy): ActionType;
+    /**
+     * Full inference cycle: observe → infer → act
+     */
+    step(observation: Observation): ActionType;
+    private computeLikelihoods;
+    private updateFactor;
+    private computeEFE;
+    private predictNextState;
+    private computeSurprise;
+    getBeliefs(): Beliefs;
+    getStats(): {
+        inferenceCount: number;
+        averageSurprise: number;
+        actionCounts: {
+            [k: string]: number;
+        };
+    };
+    getMostLikelyState(): {
+        viability: string;
+        worldState: string;
+        coupling: string;
+        goalProgress: string;
+    };
+    on(handler: AIEventHandler): () => void;
+    private emit;
+    /**
+     * Update A matrix based on observation-state pairs (supervised)
+     */
+    updateAMatrix(observation: Observation, trueState: Partial<Beliefs>): void;
+    /**
+     * Reset beliefs to priors
+     */
+    resetBeliefs(): void;
+}
+export declare function createActiveInferenceEngine(config?: Partial<ActiveInferenceConfig>): ActiveInferenceEngine;