genesis-ai-cli 7.4.5

package/dist/src/agents/memory.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Genesis 4.0 - Memory Agent
+ *
+ * Manages memory with Ebbinghaus forgetting curve.
+ * Stores, retrieves, consolidates, and forgets.
+ *
+ * Key formula: R(t) = e^(-t/S)
+ * where R = retention, t = time, S = stability
+ */
+import { BaseAgent } from './base-agent.js';
+import { MessageBus } from './message-bus.js';
+import { Message, MessageType, MemoryItem, MemoryQuery } from './types.js';
+export declare class MemoryAgent extends BaseAgent {
+    private workingMemory;
+    private shortTermMemory;
+    private longTermMemory;
+    private associations;
+    private consolidationInterval;
+    private lastConsolidation;
+    constructor(bus?: MessageBus);
+    protected getMessageTypes(): MessageType[];
+    process(message: Message): Promise<Message | null>;
+    private handleStore;
+    store(content: any, options?: {
+        type?: 'episodic' | 'semantic' | 'procedural';
+        importance?: number;
+        emotionalValence?: number;
+        associations?: string[];
+    }): MemoryItem;
+    private addToWorkingMemory;
+    private handleRetrieve;
+    retrieve(query: MemoryQuery): MemoryItem[];
+    private matchesQuery;
+    private accessMemory;
+    private handleQuery;
+    semanticSearch(query: string, limit?: number): MemoryItem[];
+    /**
+     * Calculate current retention using Ebbinghaus formula
+     * R(t) = e^(-t/S)
+     */
+    getRetention(memory: MemoryItem): number;
+    private startConsolidationCycle;
+    /**
+     * Consolidation process (runs during "sleep")
+     * 1. Scan working memory
+     * 2. Evaluate each memory
+     * 3. Decide: consolidate, keep, or forget
+     * 4. Compress similar memories
+     * 5. Prune weak memories
+     */
+    consolidate(): void;
+    private calculateConsolidationScore;
+    private updateAssociations;
+    private removeAssociations;
+    getAssociations(memoryId: string): string[];
+    private handleCommand;
+    getStats(): {
+        workingMemory: number;
+        shortTermMemory: number;
+        longTermMemory: number;
+        totalMemories: number;
+        associations: number;
+        lastConsolidation: Date;
+    };
+    getTotalMemoryCount(): number;
+    clear(): void;
+    shutdown(): void;
+}
+export declare function createMemoryAgent(bus?: MessageBus): MemoryAgent;

package/dist/src/agents/memory.js

@@ -0,0 +1,404 @@
+"use strict";
+/**
+ * Genesis 4.0 - Memory Agent
+ *
+ * Manages memory with Ebbinghaus forgetting curve.
+ * Stores, retrieves, consolidates, and forgets.
+ *
+ * Key formula: R(t) = e^(-t/S)
+ * where R = retention, t = time, S = stability
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryAgent = void 0;
+exports.createMemoryAgent = createMemoryAgent;
+const base_agent_js_1 = require("./base-agent.js");
+const message_bus_js_1 = require("./message-bus.js");
+const crypto_1 = require("crypto");
+// ============================================================================
+// Constants
+// ============================================================================
+const MEMORY_THRESHOLDS = {
+    CONSOLIDATE: 0.7, // Min score for long-term
+    KEEP_SHORT: 0.3, // Min score for short-term
+    FORGET: 0.01, // Below this = forgotten
+    SIMILARITY_MERGE: 0.85, // Threshold for merging similar memories
+};
+const MEMORY_LIMITS = {
+    WORKING: 9, // 7±2 rule
+    SHORT_TERM: 100,
+    LONG_TERM: 10000,
+};
+const STABILITY_MULTIPLIER = {
+    SUCCESS: 2.5, // Multiply stability on successful recall
+    IMPORTANCE_BOOST: 1.5, // Additional boost for important memories
+    EMOTIONAL_BOOST: 2.0, // Additional boost for emotional memories
+};
+// ============================================================================
+// Memory Agent
+// ============================================================================
+class MemoryAgent extends base_agent_js_1.BaseAgent {
+    // Memory stores
+    workingMemory = [];
+    shortTermMemory = new Map();
+    longTermMemory = new Map();
+    // Associations graph
+    associations = new Map();
+    // Consolidation timer
+    consolidationInterval = null;
+    lastConsolidation = new Date();
+    constructor(bus = message_bus_js_1.messageBus) {
+        super({ type: 'memory' }, bus);
+        this.startConsolidationCycle();
+    }
+    // ============================================================================
+    // Message Handling
+    // ============================================================================
+    getMessageTypes() {
+        return ['MEMORY_STORE', 'MEMORY_RETRIEVE', 'QUERY', 'COMMAND'];
+    }
+    async process(message) {
+        switch (message.type) {
+            case 'MEMORY_STORE':
+                return this.handleStore(message);
+            case 'MEMORY_RETRIEVE':
+                return this.handleRetrieve(message);
+            case 'QUERY':
+                return this.handleQuery(message);
+            case 'COMMAND':
+                return this.handleCommand(message);
+            default:
+                return null;
+        }
+    }
+    // ============================================================================
+    // Store
+    // ============================================================================
+    async handleStore(message) {
+        const { content, type, importance, emotionalValence, associations } = message.payload;
+        const memory = this.store(content, {
+            type: type || 'episodic',
+            importance: importance || 0.5,
+            emotionalValence: emotionalValence || 0,
+            associations: associations || [],
+        });
+        this.log(`Stored memory: ${memory.id.slice(0, 8)} (importance: ${memory.importance})`);
+        return {
+            ...this.createResponse(message, 'RESPONSE', { memoryId: memory.id, success: true }),
+            id: '',
+            timestamp: new Date(),
+        };
+    }
+    store(content, options = {}) {
+        const now = new Date();
+        // Calculate initial strength based on importance and emotion
+        const baseStrength = 1.0;
+        const importanceBoost = (options.importance || 0.5) * 0.5;
+        const emotionalBoost = Math.abs(options.emotionalValence || 0) * 0.3;
+        const memory = {
+            id: (0, crypto_1.randomUUID)(),
+            type: options.type || 'episodic',
+            content,
+            created: now,
+            lastAccessed: now,
+            accessCount: 1,
+            R0: baseStrength + importanceBoost + emotionalBoost,
+            S: 1.0, // Initial stability = 1 day
+            importance: options.importance || 0.5,
+            emotionalValence: options.emotionalValence || 0,
+            associations: options.associations || [],
+            consolidated: false,
+        };
+        // Add to working memory
+        this.addToWorkingMemory(memory);
+        // Update associations
+        this.updateAssociations(memory);
+        return memory;
+    }
+    addToWorkingMemory(memory) {
+        this.workingMemory.push(memory);
+        // Enforce capacity limit
+        while (this.workingMemory.length > MEMORY_LIMITS.WORKING) {
+            const evicted = this.workingMemory.shift();
+            // Move to short-term
+            this.shortTermMemory.set(evicted.id, evicted);
+        }
+    }
+    // ============================================================================
+    // Retrieve
+    // ============================================================================
+    async handleRetrieve(message) {
+        const query = message.payload;
+        const memories = this.retrieve(query);
+        return {
+            ...this.createResponse(message, 'RESPONSE', { memories, count: memories.length }),
+            id: '',
+            timestamp: new Date(),
+        };
+    }
+    retrieve(query) {
+        const results = [];
+        // Search all memory stores
+        const allMemories = [
+            ...this.workingMemory,
+            ...this.shortTermMemory.values(),
+            ...this.longTermMemory.values(),
+        ];
+        for (const memory of allMemories) {
+            if (this.matchesQuery(memory, query)) {
+                // Update retention on access
+                this.accessMemory(memory);
+                results.push(memory);
+            }
+        }
+        // Sort by current strength
+        results.sort((a, b) => this.getRetention(b) - this.getRetention(a));
+        // Apply limit
+        if (query.limit) {
+            return results.slice(0, query.limit);
+        }
+        return results;
+    }
+    matchesQuery(memory, query) {
+        // Type filter
+        if (query.type && memory.type !== query.type)
+            return false;
+        // Importance filter
+        if (query.minImportance && memory.importance < query.minImportance)
+            return false;
+        // Time range filter
+        if (query.timeRange) {
+            if (memory.created < query.timeRange.start)
+                return false;
+            if (memory.created > query.timeRange.end)
+                return false;
+        }
+        // Keyword filter
+        if (query.keywords && query.keywords.length > 0) {
+            const contentStr = JSON.stringify(memory.content).toLowerCase();
+            const hasKeyword = query.keywords.some((k) => contentStr.includes(k.toLowerCase()));
+            if (!hasKeyword)
+                return false;
+        }
+        // Check if memory is still "alive" (retention > FORGET threshold)
+        if (this.getRetention(memory) < MEMORY_THRESHOLDS.FORGET) {
+            return false;
+        }
+        return true;
+    }
+    accessMemory(memory) {
+        memory.lastAccessed = new Date();
+        memory.accessCount++;
+        // Strengthen stability on successful recall (FSRS-style)
+        memory.S *= STABILITY_MULTIPLIER.SUCCESS;
+        // Bonus for important memories
+        if (memory.importance > 0.7) {
+            memory.S *= STABILITY_MULTIPLIER.IMPORTANCE_BOOST;
+        }
+        // Bonus for emotional memories
+        if (Math.abs(memory.emotionalValence) > 0.5) {
+            memory.S *= STABILITY_MULTIPLIER.EMOTIONAL_BOOST;
+        }
+    }
+    // ============================================================================
+    // Query (semantic search)
+    // ============================================================================
+    async handleQuery(message) {
+        const { query, limit } = message.payload;
+        const memories = this.semanticSearch(query, limit || 10);
+        return {
+            ...this.createResponse(message, 'RESPONSE', { memories, count: memories.length }),
+            id: '',
+            timestamp: new Date(),
+        };
+    }
+    semanticSearch(query, limit = 10) {
+        // Simple keyword-based search (would use embeddings in production)
+        const keywords = query.toLowerCase().split(/\s+/);
+        return this.retrieve({
+            keywords,
+            limit,
+        });
+    }
+    // ============================================================================
+    // Ebbinghaus Forgetting Curve
+    // ============================================================================
+    /**
+     * Calculate current retention using Ebbinghaus formula
+     * R(t) = e^(-t/S)
+     */
+    getRetention(memory) {
+        const now = Date.now();
+        const lastAccess = memory.lastAccessed.getTime();
+        const elapsedDays = (now - lastAccess) / (1000 * 60 * 60 * 24);
+        // R = R0 * e^(-t/S)
+        const retention = memory.R0 * Math.exp(-elapsedDays / memory.S);
+        return Math.max(0, Math.min(1, retention));
+    }
+    // ============================================================================
+    // Consolidation Cycle
+    // ============================================================================
+    startConsolidationCycle() {
+        // Run consolidation every 10 minutes (simulated "sleep")
+        this.consolidationInterval = setInterval(() => {
+            this.consolidate();
+        }, 10 * 60 * 1000);
+    }
+    /**
+     * Consolidation process (runs during "sleep")
+     * 1. Scan working memory
+     * 2. Evaluate each memory
+     * 3. Decide: consolidate, keep, or forget
+     * 4. Compress similar memories
+     * 5. Prune weak memories
+     */
+    consolidate() {
+        this.log('Starting consolidation cycle...');
+        let consolidated = 0;
+        let forgotten = 0;
+        let kept = 0;
+        // Process short-term memories
+        for (const [id, memory] of this.shortTermMemory) {
+            const score = this.calculateConsolidationScore(memory);
+            if (score >= MEMORY_THRESHOLDS.CONSOLIDATE) {
+                // Move to long-term
+                memory.consolidated = true;
+                this.longTermMemory.set(id, memory);
+                this.shortTermMemory.delete(id);
+                consolidated++;
+            }
+            else if (score < MEMORY_THRESHOLDS.KEEP_SHORT) {
+                // Forget
+                this.shortTermMemory.delete(id);
+                this.removeAssociations(memory);
+                forgotten++;
+            }
+            else {
+                kept++;
+            }
+        }
+        // Prune weak long-term memories
+        for (const [id, memory] of this.longTermMemory) {
+            const retention = this.getRetention(memory);
+            if (retention < MEMORY_THRESHOLDS.FORGET) {
+                this.longTermMemory.delete(id);
+                this.removeAssociations(memory);
+                forgotten++;
+            }
+        }
+        this.lastConsolidation = new Date();
+        this.log(`Consolidation complete: ${consolidated} consolidated, ${forgotten} forgotten, ${kept} kept`);
+        // Broadcast consolidation event
+        this.broadcast('MEMORY_STORE', {
+            event: 'consolidation',
+            consolidated,
+            forgotten,
+            kept,
+            totalMemories: this.getTotalMemoryCount(),
+        });
+    }
+    calculateConsolidationScore(memory) {
+        const retention = this.getRetention(memory);
+        const associationCount = this.associations.get(memory.id)?.size || 0;
+        const recency = 1 / (1 + (Date.now() - memory.lastAccessed.getTime()) / (1000 * 60 * 60 * 24));
+        // Score = importance * (1 + associations) * retention * recency
+        const score = memory.importance * (1 + associationCount * 0.1) * retention * recency;
+        return Math.min(1, score);
+    }
+    // ============================================================================
+    // Associations
+    // ============================================================================
+    updateAssociations(memory) {
+        if (!this.associations.has(memory.id)) {
+            this.associations.set(memory.id, new Set());
+        }
+        for (const assocId of memory.associations) {
+            // Bidirectional association
+            this.associations.get(memory.id).add(assocId);
+            if (!this.associations.has(assocId)) {
+                this.associations.set(assocId, new Set());
+            }
+            this.associations.get(assocId).add(memory.id);
+        }
+    }
+    removeAssociations(memory) {
+        const assocs = this.associations.get(memory.id);
+        if (assocs) {
+            for (const assocId of assocs) {
+                this.associations.get(assocId)?.delete(memory.id);
+            }
+            this.associations.delete(memory.id);
+        }
+    }
+    getAssociations(memoryId) {
+        return Array.from(this.associations.get(memoryId) || []);
+    }
+    // ============================================================================
+    // Commands
+    // ============================================================================
+    async handleCommand(message) {
+        const { command, params } = message.payload;
+        switch (command) {
+            case 'consolidate':
+                this.consolidate();
+                return {
+                    ...this.createResponse(message, 'RESPONSE', { success: true }),
+                    id: '',
+                    timestamp: new Date(),
+                };
+            case 'stats':
+                return {
+                    ...this.createResponse(message, 'RESPONSE', this.getStats()),
+                    id: '',
+                    timestamp: new Date(),
+                };
+            case 'clear':
+                this.clear();
+                return {
+                    ...this.createResponse(message, 'RESPONSE', { success: true }),
+                    id: '',
+                    timestamp: new Date(),
+                };
+            default:
+                return null;
+        }
+    }
+    // ============================================================================
+    // Stats
+    // ============================================================================
+    getStats() {
+        return {
+            workingMemory: this.workingMemory.length,
+            shortTermMemory: this.shortTermMemory.size,
+            longTermMemory: this.longTermMemory.size,
+            totalMemories: this.getTotalMemoryCount(),
+            associations: this.associations.size,
+            lastConsolidation: this.lastConsolidation,
+        };
+    }
+    getTotalMemoryCount() {
+        return this.workingMemory.length + this.shortTermMemory.size + this.longTermMemory.size;
+    }
+    // ============================================================================
+    // Cleanup
+    // ============================================================================
+    clear() {
+        this.workingMemory = [];
+        this.shortTermMemory.clear();
+        this.longTermMemory.clear();
+        this.associations.clear();
+    }
+    shutdown() {
+        if (this.consolidationInterval) {
+            clearInterval(this.consolidationInterval);
+        }
+        super.shutdown();
+    }
+}
+exports.MemoryAgent = MemoryAgent;
+// ============================================================================
+// Register Factory
+// ============================================================================
+(0, base_agent_js_1.registerAgentFactory)('memory', (bus) => new MemoryAgent(bus));
+function createMemoryAgent(bus) {
+    return new MemoryAgent(bus);
+}

package/dist/src/agents/message-bus.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Genesis 4.0 - Message Bus
+ *
+ * Pub/Sub message bus for agent communication.
+ * Based on EventEmitter pattern with typed messages.
+ */
+import { Message, MessageType, MessagePriority, AgentId } from './types.js';
+export type MessageHandler = (message: Message) => void | Promise<void>;
+export interface Subscription {
+    id: string;
+    agentId: AgentId;
+    filter?: MessageFilter;
+    handler: MessageHandler;
+}
+export interface MessageFilter {
+    types?: MessageType[];
+    from?: AgentId[];
+    priority?: MessagePriority[];
+}
+export declare class MessageBus {
+    private subscriptions;
+    private messageQueue;
+    private processing;
+    private messageHistory;
+    private maxHistorySize;
+    private metrics;
+    /**
+     * Subscribe to messages
+     */
+    subscribe(agentId: AgentId, handler: MessageHandler, filter?: MessageFilter): string;
+    /**
+     * Unsubscribe from messages
+     */
+    unsubscribe(subscriptionId: string): boolean;
+    /**
+     * Publish a message
+     */
+    publish(message: Omit<Message, 'id' | 'timestamp'>): Promise<string>;
+    /**
+     * Create and publish a message (helper)
+     */
+    send(from: AgentId, to: AgentId | 'broadcast' | 'kernel', type: MessageType, payload: any, options?: {
+        priority?: MessagePriority;
+        replyTo?: string;
+        correlationId?: string;
+    }): Promise<string>;
+    /**
+     * Broadcast to all agents
+     */
+    broadcast(from: AgentId, type: MessageType, payload: any, priority?: MessagePriority): Promise<string>;
+    private processQueue;
+    private deliverMessage;
+    private findSubscriptions;
+    private addToHistory;
+    getHistory(filter?: {
+        from?: AgentId;
+        to?: AgentId;
+        type?: MessageType;
+        limit?: number;
+    }): Message[];
+    /**
+     * Wait for a specific message (useful for request-response)
+     */
+    waitForMessage(filter: {
+        replyTo?: string;
+        correlationId?: string;
+        type?: MessageType;
+        from?: AgentId;
+        to?: AgentId;
+    }, timeout?: number): Promise<Message>;
+    /**
+     * Request-response pattern
+     */
+    request(from: AgentId, to: AgentId, type: MessageType, payload: any, timeout?: number): Promise<Message>;
+    getMetrics(): {
+        uptime: number;
+        activeSubscriptions: number;
+        queueLength: number;
+        historySize: number;
+        messagesSent: number;
+        messagesDelivered: number;
+        messagesDropped: number;
+        startTime: Date;
+    };
+    clear(): void;
+}
+export declare const messageBus: MessageBus;
+export declare function createMessage(from: AgentId, to: AgentId | 'broadcast' | 'kernel', type: MessageType, payload: any, options?: Partial<Message>): Message;