genesis-ai-cli 7.4.5

package/dist/src/memory/consolidation.js

@@ -0,0 +1,443 @@
+"use strict";
+/**
+ * Genesis 6.0 - Memory Consolidation Service
+ *
+ * Implements sleep-based memory consolidation:
+ * - Episodic → Semantic (pattern extraction)
+ * - Episodic → Procedural (skill learning)
+ * - Forgetting weak memories
+ * - Merging similar memories
+ *
+ * Inspired by:
+ * - Memory consolidation during sleep (Walker & Stickgold, 2006)
+ * - Systems consolidation theory (McClelland et al., 1995)
+ * - Schema theory (Bartlett, 1932)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsolidationService = void 0;
+exports.createConsolidationService = createConsolidationService;
+const forgetting_js_1 = require("./forgetting.js");
+// ============================================================================
+// Default Configuration
+// ============================================================================
+const DEFAULT_CONFIG = {
+    retentionThreshold: forgetting_js_1.FORGETTING_THRESHOLDS.FORGET,
+    consolidationThreshold: 0.7,
+    mergeThreshold: 0.85,
+    backgroundIntervalMs: 10 * 60 * 1000, // 10 minutes
+    sleepDurationMs: 5 * 60 * 1000, // 5 minutes (simulated)
+    maxEpisodicAge: 30, // 30 days
+    maxSemanticSize: 50000,
+};
+// ============================================================================
+// Consolidation Service
+// ============================================================================
+class ConsolidationService {
+    episodicStore;
+    semanticStore;
+    proceduralStore;
+    config;
+    backgroundTimer = null;
+    isConsolidating = false;
+    lastConsolidation = null;
+    consolidationHistory = [];
+    eventLog = [];
+    constructor(episodicStore, semanticStore, proceduralStore, config = {}) {
+        this.episodicStore = episodicStore;
+        this.semanticStore = semanticStore;
+        this.proceduralStore = proceduralStore;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    // ============================================================================
+    // Main Consolidation Methods
+    // ============================================================================
+    /**
+     * Run full consolidation cycle (sleep mode)
+     */
+    async sleep() {
+        return this.consolidate('sleep');
+    }
+    /**
+     * Run quick consolidation (background)
+     */
+    async backgroundConsolidate() {
+        return this.consolidate('background');
+    }
+    /**
+     * Run immediate consolidation for specific memories
+     */
+    async immediateConsolidate(episodeIds) {
+        const episodes = episodeIds
+            .map((id) => this.episodicStore.peek(id))
+            .filter((e) => e !== undefined);
+        return this.processEpisodes(episodes, 'immediate');
+    }
+    /**
+     * Core consolidation logic
+     */
+    async consolidate(mode) {
+        if (this.isConsolidating) {
+            throw new Error('Consolidation already in progress');
+        }
+        this.isConsolidating = true;
+        const startTime = Date.now();
+        try {
+            // Get episodes ready for consolidation
+            const episodes = mode === 'background'
+                ? this.episodicStore.getReadyForConsolidation(this.config.consolidationThreshold)
+                : this.episodicStore.getAll().filter((e) => !e.consolidated);
+            // Process episodes
+            const result = await this.processEpisodes(episodes, mode);
+            // Run forgetting
+            const forgottenEpisodic = this.episodicStore.runForgetting();
+            const forgottenSemantic = this.semanticStore.runForgetting();
+            const forgottenProcedural = this.proceduralStore.runForgetting();
+            result.forgotten = forgottenEpisodic.forgotten +
+                forgottenSemantic.forgotten +
+                forgottenProcedural.forgotten;
+            result.duration = Date.now() - startTime;
+            result.timestamp = new Date();
+            // Record history
+            this.consolidationHistory.push(result);
+            if (this.consolidationHistory.length > 100) {
+                this.consolidationHistory.shift();
+            }
+            this.lastConsolidation = new Date();
+            return result;
+        }
+        finally {
+            this.isConsolidating = false;
+        }
+    }
+    /**
+     * Process a batch of episodes
+     */
+    async processEpisodes(episodes, mode) {
+        const result = {
+            mode,
+            timestamp: new Date(),
+            duration: 0,
+            episodicProcessed: 0,
+            semanticCreated: 0,
+            proceduralUpdated: 0,
+            forgotten: 0,
+            merged: 0,
+            newFacts: [],
+            updatedSkills: [],
+        };
+        // Group episodes by similarity for pattern extraction
+        const groups = this.groupSimilarEpisodes(episodes);
+        for (const group of groups) {
+            result.episodicProcessed += group.length;
+            // Extract patterns from group
+            if (group.length >= 2) {
+                // Multiple similar episodes -> extract semantic fact
+                const fact = this.extractFact(group);
+                if (fact) {
+                    const created = this.semanticStore.createFact(fact);
+                    result.semanticCreated++;
+                    result.newFacts.push(created.id);
+                    this.logEvent('CONSOLIDATE', created.id, 'semantic');
+                }
+                // Check for procedural patterns
+                const procedure = this.extractProcedure(group);
+                if (procedure) {
+                    const skill = this.proceduralStore.createSkill(procedure);
+                    result.proceduralUpdated++;
+                    result.updatedSkills.push(skill.id);
+                    this.logEvent('CONSOLIDATE', skill.id, 'procedural');
+                }
+                // Merge similar episodes
+                if (group.length > 3) {
+                    const merged = this.mergeEpisodes(group);
+                    result.merged += group.length - 1;
+                    for (const e of group.slice(1)) {
+                        this.episodicStore.delete(e.id);
+                        this.logEvent('MERGE', e.id, 'episodic');
+                    }
+                }
+            }
+            // Mark as consolidated
+            for (const episode of group) {
+                this.episodicStore.update(episode.id, { consolidated: true });
+            }
+        }
+        return result;
+    }
+    // ============================================================================
+    // Pattern Extraction
+    // ============================================================================
+    /**
+     * Group similar episodes together
+     */
+    groupSimilarEpisodes(episodes) {
+        const groups = [];
+        const used = new Set();
+        for (const episode of episodes) {
+            if (used.has(episode.id))
+                continue;
+            const group = [episode];
+            used.add(episode.id);
+            // Find similar episodes
+            for (const other of episodes) {
+                if (used.has(other.id))
+                    continue;
+                if (this.episodeSimilarity(episode, other) >= this.config.mergeThreshold) {
+                    group.push(other);
+                    used.add(other.id);
+                }
+            }
+            groups.push(group);
+        }
+        return groups;
+    }
+    /**
+     * Calculate similarity between two episodes
+     */
+    episodeSimilarity(a, b) {
+        let score = 0;
+        let factors = 0;
+        // Content similarity (simplified - would use embeddings in production)
+        const contentA = JSON.stringify(a.content).toLowerCase();
+        const contentB = JSON.stringify(b.content).toLowerCase();
+        const wordsA = new Set(contentA.split(/\s+/));
+        const wordsB = new Set(contentB.split(/\s+/));
+        const intersection = new Set([...wordsA].filter((w) => wordsB.has(w)));
+        const union = new Set([...wordsA, ...wordsB]);
+        if (union.size > 0) {
+            score += intersection.size / union.size;
+            factors++;
+        }
+        // Tag similarity
+        if (a.tags.length > 0 || b.tags.length > 0) {
+            const tagsA = new Set(a.tags);
+            const tagsB = new Set(b.tags);
+            const tagIntersection = new Set([...tagsA].filter((t) => tagsB.has(t)));
+            const tagUnion = new Set([...tagsA, ...tagsB]);
+            if (tagUnion.size > 0) {
+                score += tagIntersection.size / tagUnion.size;
+                factors++;
+            }
+        }
+        // Location similarity
+        if (a.where && b.where) {
+            if (a.where.location === b.where.location) {
+                score += 1;
+            }
+            factors++;
+        }
+        // Agent similarity
+        if (a.who && b.who) {
+            const agentsA = new Set(a.who.agents);
+            const agentsB = new Set(b.who.agents);
+            const agentIntersection = new Set([...agentsA].filter((ag) => agentsB.has(ag)));
+            const agentUnion = new Set([...agentsA, ...agentsB]);
+            if (agentUnion.size > 0) {
+                score += agentIntersection.size / agentUnion.size;
+                factors++;
+            }
+        }
+        return factors > 0 ? score / factors : 0;
+    }
+    /**
+     * Extract a semantic fact from a group of similar episodes
+     */
+    extractFact(episodes) {
+        if (episodes.length < 2)
+            return null;
+        // Find common elements
+        const allTags = new Map();
+        const allContent = [];
+        let totalImportance = 0;
+        for (const e of episodes) {
+            for (const tag of e.tags) {
+                allTags.set(tag, (allTags.get(tag) || 0) + 1);
+            }
+            allContent.push(e.content.what);
+            totalImportance += e.importance;
+        }
+        // Most common tags become the concept
+        const sortedTags = [...allTags.entries()]
+            .sort((a, b) => b[1] - a[1]);
+        if (sortedTags.length === 0) {
+            // Use content analysis
+            const words = allContent.join(' ').toLowerCase().split(/\s+/);
+            const wordFreq = new Map();
+            for (const word of words) {
+                if (word.length > 3) { // Skip short words
+                    wordFreq.set(word, (wordFreq.get(word) || 0) + 1);
+                }
+            }
+            const topWord = [...wordFreq.entries()]
+                .sort((a, b) => b[1] - a[1])[0];
+            if (!topWord)
+                return null;
+            sortedTags.push([topWord[0], topWord[1]]);
+        }
+        const mainConcept = sortedTags[0][0];
+        return {
+            concept: mainConcept,
+            definition: `Observed pattern from ${episodes.length} episodes`,
+            properties: {
+                occurrences: episodes.length,
+                timeSpan: {
+                    first: episodes[0].when.timestamp,
+                    last: episodes[episodes.length - 1].when.timestamp,
+                },
+                sources: episodes.map((e) => e.id),
+            },
+            category: 'extracted',
+            sources: episodes.map((e) => e.id),
+            importance: totalImportance / episodes.length,
+            tags: sortedTags.slice(0, 5).map(([tag]) => tag),
+        };
+    }
+    /**
+     * Extract a procedural skill from a group of similar episodes
+     */
+    extractProcedure(episodes) {
+        if (episodes.length < 3)
+            return null;
+        // Look for sequential patterns
+        const sortedEpisodes = [...episodes].sort((a, b) => a.when.timestamp.getTime() - b.when.timestamp.getTime());
+        // Check if episodes form a sequence (within a session)
+        const timeDiffs = [];
+        for (let i = 1; i < sortedEpisodes.length; i++) {
+            const diff = sortedEpisodes[i].when.timestamp.getTime() -
+                sortedEpisodes[i - 1].when.timestamp.getTime();
+            timeDiffs.push(diff);
+        }
+        // If episodes are too spread out, not a procedure
+        const avgTimeDiff = timeDiffs.reduce((a, b) => a + b, 0) / timeDiffs.length;
+        if (avgTimeDiff > 60 * 60 * 1000) { // More than 1 hour apart on average
+            return null;
+        }
+        // Extract steps from episode sequence
+        const steps = sortedEpisodes.map((e) => ({
+            action: e.content.what,
+        }));
+        // Common tags become the skill name
+        const allTags = new Set();
+        for (const e of sortedEpisodes) {
+            for (const t of e.tags)
+                allTags.add(t);
+        }
+        const name = [...allTags][0] || 'extracted-procedure';
+        return {
+            name: `${name}-workflow`,
+            description: `Workflow extracted from ${episodes.length} sequential episodes`,
+            steps,
+            importance: sortedEpisodes.reduce((sum, e) => sum + e.importance, 0) / sortedEpisodes.length,
+            tags: [...allTags],
+        };
+    }
+    /**
+     * Merge multiple similar episodes into one
+     */
+    mergeEpisodes(episodes) {
+        const first = episodes[0];
+        // Combine content
+        const mergedContent = {
+            what: `Merged: ${first.content.what} (${episodes.length} occurrences)`,
+            details: {
+                originalCount: episodes.length,
+                mergedFrom: episodes.map((e) => e.id),
+                timeRange: {
+                    first: episodes[0].when.timestamp,
+                    last: episodes[episodes.length - 1].when.timestamp,
+                },
+            },
+        };
+        // Update first episode with merged content
+        this.episodicStore.update(first.id, {
+            content: mergedContent,
+            importance: Math.max(...episodes.map((e) => e.importance)),
+            S: Math.max(...episodes.map((e) => e.S)), // Keep strongest stability
+        });
+        return first;
+    }
+    // ============================================================================
+    // Background Consolidation
+    // ============================================================================
+    /**
+     * Start background consolidation timer
+     */
+    startBackground() {
+        if (this.backgroundTimer)
+            return;
+        this.backgroundTimer = setInterval(async () => {
+            try {
+                await this.backgroundConsolidate();
+            }
+            catch (error) {
+                console.error('[Consolidation] Background error:', error);
+            }
+        }, this.config.backgroundIntervalMs);
+    }
+    /**
+     * Stop background consolidation
+     */
+    stopBackground() {
+        if (this.backgroundTimer) {
+            clearInterval(this.backgroundTimer);
+            this.backgroundTimer = null;
+        }
+    }
+    /**
+     * Check if background consolidation is running
+     */
+    isBackgroundRunning() {
+        return this.backgroundTimer !== null;
+    }
+    // ============================================================================
+    // Event Logging
+    // ============================================================================
+    logEvent(type, memoryId, memoryType) {
+        this.eventLog.push({
+            type,
+            memoryId,
+            memoryType,
+            timestamp: new Date(),
+        });
+        // Keep log bounded
+        if (this.eventLog.length > 1000) {
+            this.eventLog.shift();
+        }
+    }
+    // ============================================================================
+    // Stats and History
+    // ============================================================================
+    getStats() {
+        return {
+            lastConsolidation: this.lastConsolidation,
+            isConsolidating: this.isConsolidating,
+            backgroundRunning: this.isBackgroundRunning(),
+            totalConsolidations: this.consolidationHistory.length,
+            recentResults: this.consolidationHistory.slice(-10),
+            memoryStats: {
+                episodic: (0, forgetting_js_1.calculateForgettingStats)(this.episodicStore.getAll()),
+                semantic: (0, forgetting_js_1.calculateForgettingStats)(this.semanticStore.getAll()),
+                procedural: (0, forgetting_js_1.calculateForgettingStats)(this.proceduralStore.getAll()),
+            },
+        };
+    }
+    getHistory(limit) {
+        if (limit) {
+            return this.consolidationHistory.slice(-limit);
+        }
+        return [...this.consolidationHistory];
+    }
+    getEventLog(limit) {
+        if (limit) {
+            return this.eventLog.slice(-limit);
+        }
+        return [...this.eventLog];
+    }
+}
+exports.ConsolidationService = ConsolidationService;
+// ============================================================================
+// Factory
+// ============================================================================
+function createConsolidationService(episodicStore, semanticStore, proceduralStore, config) {
+    return new ConsolidationService(episodicStore, semanticStore, proceduralStore, config);
+}

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

@@ -0,0 +1,114 @@
+/**
+ * Genesis 6.0 - Episodic Memory Store
+ *
+ * Stores autobiographical memories - events with context.
+ * "What happened, when, where, who was involved"
+ *
+ * Key features:
+ * - Temporal ordering and sequencing
+ * - Context binding (where, who)
+ * - Emotional coloring
+ * - Forgetting curve integration
+ *
+ * Reference: Tulving, E. (1972). Episodic and semantic memory.
+ */
+import { EpisodicMemory, IMemoryStore, MemoryFilter, StoreStats } from './types.js';
+export interface EpisodicStoreConfig {
+    maxSize: number;
+    autoForget: boolean;
+    forgetThreshold: number;
+    defaultStability: number;
+}
+export interface CreateEpisodicOptions {
+    what: string;
+    details?: any;
+    when?: Date;
+    duration?: number;
+    where?: {
+        location: string;
+        context: string;
+    };
+    who?: {
+        agents: string[];
+        roles?: Record<string, string>;
+    };
+    feeling?: {
+        valence: number;
+        arousal: number;
+        label?: string;
+    };
+    importance?: number;
+    tags?: string[];
+    associations?: string[];
+    source?: string;
+}
+export declare class EpisodicStore implements IMemoryStore<EpisodicMemory> {
+    private memories;
+    private config;
+    private byTime;
+    private byLocation;
+    private byAgent;
+    private byTag;
+    constructor(config?: Partial<EpisodicStoreConfig>);
+    store(input: Omit<EpisodicMemory, 'id' | 'created' | 'lastAccessed' | 'accessCount'>): EpisodicMemory;
+    /**
+     * Convenience method to create an episodic memory from options
+     */
+    createEpisode(options: CreateEpisodicOptions): EpisodicMemory;
+    get(id: string): EpisodicMemory | undefined;
+    /**
+     * Get without updating access (for internal use)
+     */
+    peek(id: string): EpisodicMemory | undefined;
+    update(id: string, updates: Partial<EpisodicMemory>): EpisodicMemory | undefined;
+    delete(id: string): boolean;
+    query(filter: MemoryFilter<EpisodicMemory>): EpisodicMemory[];
+    /**
+     * Search by keyword in content
+     */
+    search(queryStr: string, limit?: number): EpisodicMemory[];
+    /**
+     * Get episodes in a time range
+     */
+    getByTimeRange(start: Date, end: Date): EpisodicMemory[];
+    /**
+     * Get recent episodes
+     */
+    getRecent(limit?: number): EpisodicMemory[];
+    /**
+     * Get episodes from today
+     */
+    getToday(): EpisodicMemory[];
+    /**
+     * Get episodes involving a specific agent
+     */
+    getByAgent(agentId: string): EpisodicMemory[];
+    /**
+     * Get episodes at a location
+     */
+    getByLocation(location: string): EpisodicMemory[];
+    getAll(): EpisodicMemory[];
+    clear(): void;
+    count(): number;
+    stats(): StoreStats;
+    /**
+     * Get episodes that should be forgotten
+     */
+    getForgotten(): EpisodicMemory[];
+    /**
+     * Get episodes ready for consolidation (strong retention, not yet consolidated)
+     */
+    getReadyForConsolidation(threshold?: number): EpisodicMemory[];
+    /**
+     * Run forgetting cycle - remove memories below threshold
+     */
+    runForgetting(): {
+        forgotten: number;
+        ids: string[];
+    };
+    private accessMemory;
+    private updateIndexes;
+    private removeFromIndexes;
+    private maintainSize;
+}
+export declare function createEpisodicStore(config?: Partial<EpisodicStoreConfig>): EpisodicStore;