genesis-ai-cli 7.4.5

package/dist/src/memory/index.js

@@ -0,0 +1,367 @@
+"use strict";
+/**
+ * Genesis 6.0 - Memory Module
+ *
+ * Unified memory system based on cognitive science:
+ * - Episodic: Events with context (what/when/where/who)
+ * - Semantic: Facts and concepts (knowledge)
+ * - Procedural: Skills and workflows (know-how)
+ *
+ * Features:
+ * - Ebbinghaus forgetting curve
+ * - Sleep-based consolidation (episodic → semantic)
+ * - Pattern extraction
+ * - Skill learning
+ *
+ * Usage:
+ * ```typescript
+ * import { createMemorySystem } from './memory/index.js';
+ *
+ * const memory = createMemorySystem();
+ *
+ * // Store an episode
+ * memory.remember({
+ *   what: 'User asked about AI',
+ *   when: new Date(),
+ *   tags: ['conversation', 'AI'],
+ * });
+ *
+ * // Create a fact
+ * memory.learn({
+ *   concept: 'TypeScript',
+ *   definition: 'A typed superset of JavaScript',
+ *   category: 'programming',
+ * });
+ *
+ * // Create a skill
+ * memory.learnSkill({
+ *   name: 'git-commit',
+ *   description: 'Create a git commit',
+ *   steps: [
+ *     { action: 'git add .' },
+ *     { action: 'git commit -m "message"' },
+ *   ],
+ * });
+ *
+ * // Run consolidation (sleep)
+ * await memory.sleep();
+ * ```
+ */
+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.MemorySystem = exports.DEFAULT_WORKSPACE_CONFIG = exports.resetCognitiveWorkspace = exports.getCognitiveWorkspace = exports.createCognitiveWorkspace = exports.CognitiveWorkspace = exports.createConsolidationService = exports.ConsolidationService = exports.createProceduralStore = exports.ProceduralStore = exports.createSemanticStore = exports.SemanticStore = exports.createEpisodicStore = exports.EpisodicStore = void 0;
+exports.createMemorySystem = createMemorySystem;
+exports.getMemorySystem = getMemorySystem;
+exports.resetMemorySystem = resetMemorySystem;
+// Re-export types
+__exportStar(require("./types.js"), exports);
+// Re-export modules
+__exportStar(require("./forgetting.js"), exports);
+// Re-export Phase 8: Local-First modules
+__exportStar(require("./cache.js"), exports);
+__exportStar(require("./indexer.js"), exports);
+var episodic_js_1 = require("./episodic.js");
+Object.defineProperty(exports, "EpisodicStore", { enumerable: true, get: function () { return episodic_js_1.EpisodicStore; } });
+Object.defineProperty(exports, "createEpisodicStore", { enumerable: true, get: function () { return episodic_js_1.createEpisodicStore; } });
+var semantic_js_1 = require("./semantic.js");
+Object.defineProperty(exports, "SemanticStore", { enumerable: true, get: function () { return semantic_js_1.SemanticStore; } });
+Object.defineProperty(exports, "createSemanticStore", { enumerable: true, get: function () { return semantic_js_1.createSemanticStore; } });
+var procedural_js_1 = require("./procedural.js");
+Object.defineProperty(exports, "ProceduralStore", { enumerable: true, get: function () { return procedural_js_1.ProceduralStore; } });
+Object.defineProperty(exports, "createProceduralStore", { enumerable: true, get: function () { return procedural_js_1.createProceduralStore; } });
+var consolidation_js_1 = require("./consolidation.js");
+Object.defineProperty(exports, "ConsolidationService", { enumerable: true, get: function () { return consolidation_js_1.ConsolidationService; } });
+Object.defineProperty(exports, "createConsolidationService", { enumerable: true, get: function () { return consolidation_js_1.createConsolidationService; } });
+// Re-export Memory 2.0 - Cognitive Workspace
+var cognitive_workspace_js_1 = require("./cognitive-workspace.js");
+Object.defineProperty(exports, "CognitiveWorkspace", { enumerable: true, get: function () { return cognitive_workspace_js_1.CognitiveWorkspace; } });
+Object.defineProperty(exports, "createCognitiveWorkspace", { enumerable: true, get: function () { return cognitive_workspace_js_1.createCognitiveWorkspace; } });
+Object.defineProperty(exports, "getCognitiveWorkspace", { enumerable: true, get: function () { return cognitive_workspace_js_1.getCognitiveWorkspace; } });
+Object.defineProperty(exports, "resetCognitiveWorkspace", { enumerable: true, get: function () { return cognitive_workspace_js_1.resetCognitiveWorkspace; } });
+Object.defineProperty(exports, "DEFAULT_WORKSPACE_CONFIG", { enumerable: true, get: function () { return cognitive_workspace_js_1.DEFAULT_WORKSPACE_CONFIG; } });
+const episodic_js_2 = require("./episodic.js");
+const semantic_js_2 = require("./semantic.js");
+const procedural_js_2 = require("./procedural.js");
+const consolidation_js_2 = require("./consolidation.js");
+const cognitive_workspace_js_2 = require("./cognitive-workspace.js");
+const forgetting_js_1 = require("./forgetting.js");
+// ============================================================================
+// Unified Memory System
+// ============================================================================
+/**
+ * Unified memory system with episodic, semantic, and procedural stores
+ */
+class MemorySystem {
+    episodic;
+    semantic;
+    procedural;
+    consolidation;
+    workspace; // Memory 2.0
+    constructor(config = {}) {
+        this.episodic = (0, episodic_js_2.createEpisodicStore)(config.episodic);
+        this.semantic = (0, semantic_js_2.createSemanticStore)(config.semantic);
+        this.procedural = (0, procedural_js_2.createProceduralStore)(config.procedural);
+        this.consolidation = (0, consolidation_js_2.createConsolidationService)(this.episodic, this.semantic, this.procedural, config.consolidation);
+        // Memory 2.0: Create cognitive workspace
+        this.workspace = (0, cognitive_workspace_js_2.createCognitiveWorkspace)(config.workspace);
+        // Connect workspace to stores
+        this.workspace.connectStores({
+            episodic: {
+                search: (q, l) => this.episodic.search(q, l),
+                get: (id) => this.episodic.get(id),
+            },
+            semantic: {
+                search: (q, l) => this.semantic.search(q, l),
+                getByConcept: (c) => this.semantic.getByConcept(c),
+            },
+            procedural: {
+                search: (q, l) => this.procedural.search(q, l),
+                getByName: (n) => this.procedural.getByName(n),
+            },
+        });
+        // Auto-start background consolidation if configured
+        if (config.consolidation?.autoStart) {
+            this.consolidation.startBackground();
+        }
+    }
+    // ============================================================================
+    // High-Level API
+    // ============================================================================
+    /**
+     * Store an episodic memory (event)
+     */
+    remember(options) {
+        return this.episodic.createEpisode(options);
+    }
+    /**
+     * Store a semantic memory (fact)
+     */
+    learn(options) {
+        return this.semantic.createFact(options);
+    }
+    /**
+     * Store a procedural memory (skill)
+     */
+    learnSkill(options) {
+        return this.procedural.createSkill(options);
+    }
+    /**
+     * Anticipate needed memories based on context (Memory 2.0)
+     *
+     * Uses context cues to predict which memories will be needed,
+     * pre-loading them into working memory for fast access.
+     */
+    async anticipate(context) {
+        return this.workspace.anticipate(context);
+    }
+    /**
+     * Get currently active memories in working memory (Memory 2.0)
+     */
+    getActive() {
+        return this.workspace.getActive();
+    }
+    /**
+     * Get memory reuse metrics (Memory 2.0)
+     */
+    getReuseMetrics() {
+        return this.workspace.getMetrics();
+    }
+    /**
+     * Recall memories by query
+     */
+    recall(query, options = {}) {
+        const types = options.types || ['episodic', 'semantic', 'procedural'];
+        const limit = options.limit || 10;
+        const results = [];
+        if (types.includes('episodic')) {
+            results.push(...this.episodic.search(query, limit));
+        }
+        if (types.includes('semantic')) {
+            results.push(...this.semantic.search(query, limit));
+        }
+        if (types.includes('procedural')) {
+            results.push(...this.procedural.search(query, limit));
+        }
+        // Sort by retention and return top results
+        return results
+            .sort((a, b) => {
+            const retA = this.getRetention(a);
+            const retB = this.getRetention(b);
+            return retB - retA;
+        })
+            .slice(0, limit);
+    }
+    /**
+     * Get a specific fact by concept name
+     */
+    getFact(concept) {
+        return this.semantic.getByConcept(concept);
+    }
+    /**
+     * Get a specific skill by name
+     */
+    getSkill(name) {
+        return this.procedural.getByName(name);
+    }
+    /**
+     * Get recent episodes
+     */
+    getRecentEpisodes(limit = 10) {
+        return this.episodic.getRecent(limit);
+    }
+    /**
+     * Run consolidation (sleep mode)
+     */
+    async sleep() {
+        return this.consolidation.sleep();
+    }
+    /**
+     * Run quick background consolidation
+     */
+    async consolidate() {
+        return this.consolidation.backgroundConsolidate();
+    }
+    // ============================================================================
+    // Utility Methods
+    // ============================================================================
+    /**
+     * Calculate retention for any memory type
+     */
+    getRetention(memory) {
+        const elapsed = Date.now() - memory.lastAccessed.getTime();
+        const elapsedDays = elapsed / (1000 * 60 * 60 * 24);
+        return memory.R0 * Math.exp(-elapsedDays / memory.S);
+    }
+    /**
+     * Get overall memory statistics
+     */
+    getStats() {
+        const episodicStats = this.episodic.stats();
+        const semanticStats = this.semantic.stats();
+        const proceduralStats = this.procedural.stats();
+        return {
+            total: episodicStats.total + semanticStats.total + proceduralStats.total,
+            episodic: episodicStats,
+            semantic: semanticStats,
+            procedural: proceduralStats,
+            forgetting: {
+                episodic: (0, forgetting_js_1.calculateForgettingStats)(this.episodic.getAll()),
+                semantic: (0, forgetting_js_1.calculateForgettingStats)(this.semantic.getAll()),
+                procedural: (0, forgetting_js_1.calculateForgettingStats)(this.procedural.getAll()),
+            },
+            consolidation: this.consolidation.getStats(),
+            workspace: this.workspace.getStats(), // Memory 2.0
+            reuse: this.workspace.getMetrics(), // Memory 2.0
+        };
+    }
+    /**
+     * Clear all memories
+     */
+    clear() {
+        this.episodic.clear();
+        this.semantic.clear();
+        this.procedural.clear();
+        this.workspace.clear(); // Memory 2.0
+    }
+    /**
+     * Shutdown the memory system
+     */
+    shutdown() {
+        this.consolidation.stopBackground();
+        this.workspace.shutdown(); // Memory 2.0
+    }
+    // ============================================================================
+    // Import/Export
+    // ============================================================================
+    /**
+     * Export all memories to JSON
+     */
+    export() {
+        return {
+            episodic: this.episodic.getAll(),
+            semantic: this.semantic.getAll(),
+            procedural: this.procedural.getAll(),
+            exportedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * Import memories from JSON
+     */
+    import(data) {
+        let imported = 0;
+        if (data.episodic) {
+            for (const memory of data.episodic) {
+                this.episodic.store(memory);
+                imported++;
+            }
+        }
+        if (data.semantic) {
+            for (const memory of data.semantic) {
+                this.semantic.store(memory);
+                imported++;
+            }
+        }
+        if (data.procedural) {
+            for (const memory of data.procedural) {
+                this.procedural.store(memory);
+                imported++;
+            }
+        }
+        return { imported };
+    }
+}
+exports.MemorySystem = MemorySystem;
+// ============================================================================
+// Factory
+// ============================================================================
+/**
+ * Create a new memory system
+ */
+function createMemorySystem(config) {
+    return new MemorySystem(config);
+}
+// ============================================================================
+// Singleton Instance (optional)
+// ============================================================================
+let memorySystemInstance = null;
+/**
+ * Get or create the global memory system instance
+ * v7.0: Consolidation auto-starts by default for real memory behavior
+ */
+function getMemorySystem(config) {
+    if (!memorySystemInstance) {
+        // v7.0: Default to autoStart for consolidation
+        const configWithDefaults = {
+            ...config,
+            consolidation: {
+                autoStart: true, // v7.0: Enable consolidation by default
+                backgroundIntervalMs: 10 * 60 * 1000, // 10 minutes
+                ...config?.consolidation,
+            },
+        };
+        memorySystemInstance = createMemorySystem(configWithDefaults);
+    }
+    return memorySystemInstance;
+}
+/**
+ * Reset the global memory system instance
+ */
+function resetMemorySystem() {
+    if (memorySystemInstance) {
+        memorySystemInstance.shutdown();
+        memorySystemInstance = null;
+    }
+}

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

@@ -0,0 +1,123 @@
+/**
+ * Genesis 6.8 - Project Indexer
+ *
+ * Indexes project files for local full-text search.
+ * No LLM needed for code search - instant results.
+ *
+ * Uses JSON storage with in-memory trigram index for fast search.
+ */
+export interface IndexedFile {
+    /** Relative path from project root */
+    path: string;
+    /** File content */
+    content: string;
+    /** Content hash for change detection */
+    hash: string;
+    /** File size in bytes */
+    size: number;
+    /** Last modified timestamp */
+    mtime: number;
+    /** Language/type */
+    language: string;
+    /** Line count */
+    lines: number;
+    /** Extracted symbols (functions, classes, etc.) */
+    symbols: string[];
+}
+export interface SearchResult {
+    /** File path */
+    path: string;
+    /** Matching lines with context */
+    matches: Array<{
+        line: number;
+        content: string;
+        context: string[];
+    }>;
+    /** Relevance score */
+    score: number;
+}
+export interface IndexStats {
+    totalFiles: number;
+    totalLines: number;
+    totalBytes: number;
+    languages: Record<string, number>;
+    lastIndexed: number;
+    indexPath: string;
+}
+export interface IndexerConfig {
+    /** Project root directory */
+    projectRoot: string;
+    /** Index storage path */
+    indexPath: string;
+    /** File patterns to include */
+    include: string[];
+    /** File patterns to exclude */
+    exclude: string[];
+    /** Maximum file size to index (bytes) */
+    maxFileSize: number;
+    /** Enable incremental indexing */
+    incremental: boolean;
+}
+export declare class ProjectIndexer {
+    private config;
+    private index;
+    private trigramIndex;
+    constructor(config?: Partial<IndexerConfig>);
+    /**
+     * Load existing index from disk
+     */
+    private loadIndex;
+    /**
+     * Save index to disk
+     */
+    private saveIndex;
+    /**
+     * Build trigram index for fast search
+     */
+    private rebuildTrigramIndex;
+    /**
+     * Index the entire project
+     */
+    indexProject(): Promise<IndexStats>;
+    /**
+     * Walk directory recursively
+     */
+    private walkDirectory;
+    /**
+     * Search for a string in the codebase
+     */
+    search(query: string, options?: {
+        limit?: number;
+        caseSensitive?: boolean;
+    }): SearchResult[];
+    /**
+     * Find candidate files using trigram index
+     */
+    private findCandidates;
+    /**
+     * Find matches in file content
+     */
+    private findMatches;
+    /**
+     * Search for a symbol (function, class, etc.)
+     */
+    searchSymbol(symbol: string): SearchResult[];
+    /**
+     * Get file content
+     */
+    getFile(filePath: string): IndexedFile | null;
+    /**
+     * List all indexed files
+     */
+    listFiles(): string[];
+    /**
+     * Get index statistics
+     */
+    stats(): IndexStats;
+    /**
+     * Clear the index
+     */
+    clear(): void;
+}
+export declare function getProjectIndexer(config?: Partial<IndexerConfig>): ProjectIndexer;
+export declare function resetProjectIndexer(): void;