genesis-ai-cli 7.4.5

package/dist/src/memory/cache.js

@@ -0,0 +1,356 @@
+"use strict";
+/**
+ * Genesis 6.8 - SQLite Fix Cache
+ *
+ * Stores successful fixes from Self-Healing module for instant reuse.
+ * Uses better-sqlite3 for synchronous, high-performance operations.
+ *
+ * Key: SHA256(error_message + file_path + context)
+ * Value: Applied fix with metadata
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FixCache = void 0;
+exports.getFixCache = getFixCache;
+exports.resetFixCache = resetFixCache;
+exports.getCachedFixOrGenerate = getCachedFixOrGenerate;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// ============================================================================
+// Default Config
+// ============================================================================
+const DEFAULT_CONFIG = {
+    dbPath: path.join(process.env.HOME || '/tmp', '.genesis', 'fix-cache.db'),
+    maxFixes: 10000,
+    minSuccessCount: 1,
+    enableFTS: true,
+};
+// ============================================================================
+// Pure Node.js SQLite Wrapper (no native dependencies)
+// ============================================================================
+/**
+ * Simple JSON file-based cache as SQLite fallback
+ * Works without native dependencies
+ */
+class JSONCache {
+    data = new Map();
+    dbPath;
+    hits = 0;
+    misses = 0;
+    constructor(dbPath) {
+        this.dbPath = dbPath.replace('.db', '.json');
+        this.load();
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.dbPath)) {
+                const raw = fs.readFileSync(this.dbPath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                this.data = new Map(Object.entries(parsed.fixes || {}));
+                this.hits = parsed.hits || 0;
+                this.misses = parsed.misses || 0;
+            }
+        }
+        catch {
+            this.data = new Map();
+        }
+    }
+    save() {
+        try {
+            const dir = path.dirname(this.dbPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.dbPath, JSON.stringify({
+                fixes: Object.fromEntries(this.data),
+                hits: this.hits,
+                misses: this.misses,
+            }, null, 2));
+        }
+        catch (e) {
+            console.error('[Cache] Failed to save:', e);
+        }
+    }
+    get(id) {
+        const fix = this.data.get(id);
+        if (fix) {
+            this.hits++;
+            fix.successCount++;
+            fix.lastUsed = Date.now();
+            this.save();
+        }
+        else {
+            this.misses++;
+        }
+        return fix;
+    }
+    set(fix) {
+        this.data.set(fix.id, fix);
+        this.save();
+    }
+    delete(id) {
+        const result = this.data.delete(id);
+        if (result)
+            this.save();
+        return result;
+    }
+    all() {
+        return Array.from(this.data.values());
+    }
+    search(query) {
+        const lower = query.toLowerCase();
+        return this.all().filter(f => f.errorMessage.toLowerCase().includes(lower) ||
+            f.fix.toLowerCase().includes(lower) ||
+            f.context.toLowerCase().includes(lower));
+    }
+    size() {
+        return this.data.size;
+    }
+    stats() {
+        const fixes = this.all();
+        const errorTypes = new Map();
+        let totalLatency = 0;
+        let latencyCount = 0;
+        for (const fix of fixes) {
+            errorTypes.set(fix.errorType, (errorTypes.get(fix.errorType) || 0) + 1);
+            if (fix.latencyMs) {
+                totalLatency += fix.latencyMs;
+                latencyCount++;
+            }
+        }
+        const topErrors = Array.from(errorTypes.entries())
+            .map(([type, count]) => ({ type, count }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 5);
+        let dbSize = 0;
+        try {
+            if (fs.existsSync(this.dbPath)) {
+                dbSize = fs.statSync(this.dbPath).size;
+            }
+        }
+        catch { }
+        return {
+            totalFixes: fixes.length,
+            totalHits: this.hits,
+            hitRate: this.hits / Math.max(1, this.hits + this.misses),
+            avgLatencySaved: latencyCount > 0 ? totalLatency / latencyCount : 0,
+            topErrors,
+            dbSizeBytes: dbSize,
+        };
+    }
+    clear() {
+        this.data.clear();
+        this.hits = 0;
+        this.misses = 0;
+        this.save();
+    }
+    close() {
+        this.save();
+    }
+}
+// ============================================================================
+// Fix Cache Class
+// ============================================================================
+class FixCache {
+    config;
+    cache;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        // Ensure directory exists
+        const dir = path.dirname(this.config.dbPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // Use JSON cache (no native dependencies)
+        this.cache = new JSONCache(this.config.dbPath);
+    }
+    // ==========================================================================
+    // Core Operations
+    // ==========================================================================
+    /**
+     * Generate cache key from error details
+     */
+    generateKey(errorMessage, filePath, context = '') {
+        const normalized = `${errorMessage.trim()}|${filePath}|${context.slice(0, 500)}`;
+        return crypto.createHash('sha256').update(normalized).digest('hex').slice(0, 16);
+    }
+    /**
+     * Look up a cached fix
+     */
+    lookup(errorMessage, filePath, context = '') {
+        const key = this.generateKey(errorMessage, filePath, context);
+        return this.cache.get(key) || null;
+    }
+    /**
+     * Store a successful fix
+     */
+    store(params) {
+        const id = this.generateKey(params.errorMessage, params.filePath, params.context);
+        const existing = this.cache.get(id);
+        if (existing) {
+            // Update existing
+            existing.successCount++;
+            existing.lastUsed = Date.now();
+            this.cache.set(existing);
+            return existing;
+        }
+        const fix = {
+            id,
+            errorMessage: params.errorMessage,
+            errorType: params.errorType,
+            filePath: params.filePath,
+            context: params.context.slice(0, 2000), // Limit context size
+            fix: params.fix,
+            successCount: 1,
+            lastUsed: Date.now(),
+            createdAt: Date.now(),
+            provider: params.provider,
+            latencyMs: params.latencyMs,
+        };
+        this.cache.set(fix);
+        this.evictIfNeeded();
+        return fix;
+    }
+    /**
+     * Search for similar errors
+     */
+    searchSimilar(query, limit = 5) {
+        return this.cache.search(query).slice(0, limit);
+    }
+    /**
+     * Get all cached fixes
+     */
+    getAll() {
+        return this.cache.all();
+    }
+    /**
+     * Get cache statistics
+     */
+    stats() {
+        return this.cache.stats();
+    }
+    /**
+     * Clear all cached fixes
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Delete a specific fix
+     */
+    delete(id) {
+        return this.cache.delete(id);
+    }
+    /**
+     * Close the cache (save to disk)
+     */
+    close() {
+        this.cache.close();
+    }
+    // ==========================================================================
+    // Eviction
+    // ==========================================================================
+    evictIfNeeded() {
+        const fixes = this.cache.all();
+        if (fixes.length <= this.config.maxFixes)
+            return;
+        // Sort by LRU (least recently used first)
+        const sorted = fixes
+            .filter(f => f.successCount < this.config.minSuccessCount)
+            .sort((a, b) => a.lastUsed - b.lastUsed);
+        // Evict oldest 10%
+        const toEvict = Math.ceil(sorted.length * 0.1);
+        for (let i = 0; i < toEvict && i < sorted.length; i++) {
+            this.cache.delete(sorted[i].id);
+        }
+    }
+}
+exports.FixCache = FixCache;
+// ============================================================================
+// Singleton
+// ============================================================================
+let fixCacheInstance = null;
+function getFixCache(config) {
+    if (!fixCacheInstance) {
+        fixCacheInstance = new FixCache(config);
+    }
+    return fixCacheInstance;
+}
+function resetFixCache() {
+    if (fixCacheInstance) {
+        fixCacheInstance.close();
+        fixCacheInstance = null;
+    }
+}
+// ============================================================================
+// Integration with Self-Healing
+// ============================================================================
+/**
+ * Try to get a cached fix before calling LLM
+ */
+async function getCachedFixOrGenerate(errorMessage, errorType, filePath, context, generateFix) {
+    const cache = getFixCache();
+    // Try cache first
+    const cached = cache.lookup(errorMessage, filePath, context);
+    if (cached) {
+        console.log(`[Cache] HIT: Reusing fix for ${errorType} error (${cached.successCount} uses)`);
+        return {
+            fix: cached.fix,
+            cached: true,
+            latencyMs: 0, // Instant!
+        };
+    }
+    // Cache miss - generate new fix
+    console.log(`[Cache] MISS: Generating new fix for ${errorType} error...`);
+    const startTime = Date.now();
+    const result = await generateFix();
+    const latencyMs = Date.now() - startTime;
+    // Store for future use
+    cache.store({
+        errorMessage,
+        errorType,
+        filePath,
+        context,
+        fix: result.fix,
+        provider: result.provider,
+        latencyMs,
+    });
+    return {
+        fix: result.fix,
+        cached: false,
+        latencyMs,
+    };
+}

package/dist/src/memory/cognitive-workspace.d.ts

@@ -0,0 +1,231 @@
+/**
+ * Genesis 6.3 - Cognitive Workspace (Memory 2.0)
+ *
+ * Working memory with attention-based selection and anticipatory retrieval.
+ *
+ * Based on:
+ * - Baddeley's Working Memory Model (central executive + buffers)
+ * - Global Workspace Theory (Baars) - capacity-limited broadcast
+ * - Active Inference (anticipatory recall)
+ *
+ * Key features:
+ * - Capacity-limited buffer (like human 7±2 items)
+ * - Attention-based selection and eviction
+ * - Anticipatory pre-loading based on context
+ * - Integration with episodic/semantic/procedural stores
+ *
+ * Architecture:
+ * ```
+ * Context → anticipate() → Pre-load
+ *              ↓
+ *         [Working Memory Buffer]
+ *              ↓
+ *         curate() → Select/Evict
+ *              ↓
+ *         [Active Items for Reasoning]
+ * ```
+ */
+import { Memory, EpisodicMemory, SemanticMemory, ProceduralMemory, MemoryType } from './types.js';
+/**
+ * Store interface for episodic memories
+ */
+export interface EpisodicStoreInterface {
+    search: (query: string, limit: number) => EpisodicMemory[];
+    get: (id: string) => EpisodicMemory | undefined;
+}
+/**
+ * Store interface for semantic memories
+ */
+export interface SemanticStoreInterface {
+    search: (query: string, limit: number) => SemanticMemory[];
+    getByConcept: (concept: string) => SemanticMemory | undefined;
+}
+/**
+ * Store interface for procedural memories
+ */
+export interface ProceduralStoreInterface {
+    search: (query: string, limit: number) => ProceduralMemory[];
+    getByName: (name: string) => ProceduralMemory | undefined;
+}
+/**
+ * Item in working memory with activation level
+ */
+export interface WorkingMemoryItem {
+    id: string;
+    memory: Memory;
+    activation: number;
+    relevance: number;
+    accessCount: number;
+    addedAt: Date;
+    lastAccessed: Date;
+    source: 'anticipate' | 'recall' | 'association' | 'manual';
+}
+/**
+ * Context for anticipatory retrieval
+ */
+export interface AnticipationContext {
+    task?: string;
+    goal?: string;
+    recentActions?: string[];
+    recentTopics?: string[];
+    activeAgents?: string[];
+    activeLocation?: string;
+    emotionalState?: {
+        valence: number;
+        arousal: number;
+    };
+    keywords?: string[];
+    tags?: string[];
+}
+/**
+ * Configuration for cognitive workspace
+ */
+export interface CognitiveWorkspaceConfig {
+    maxItems: number;
+    maxTokens: number;
+    decayRate: number;
+    boostOnAccess: number;
+    minActivation: number;
+    anticipationDepth: number;
+    associationStrength: number;
+    curationInterval: number;
+    autoCurate: boolean;
+}
+export declare const DEFAULT_WORKSPACE_CONFIG: CognitiveWorkspaceConfig;
+/**
+ * Memory reuse metrics for tracking efficiency
+ */
+export interface MemoryReuseMetrics {
+    totalRecalls: number;
+    cacheHits: number;
+    storeHits: number;
+    newCreations: number;
+    anticipationHits: number;
+    anticipationMisses: number;
+    reuseRate: number;
+    anticipationAccuracy: number;
+}
+/**
+ * Working memory with attention-based selection and anticipatory retrieval
+ */
+export declare class CognitiveWorkspace {
+    private config;
+    private buffer;
+    private episodicStore?;
+    private semanticStore?;
+    private proceduralStore?;
+    private metrics;
+    private anticipatedIds;
+    private curationTimer?;
+    constructor(config?: Partial<CognitiveWorkspaceConfig>);
+    /**
+     * Connect to memory stores for retrieval
+     */
+    connectStores(stores: {
+        episodic?: EpisodicStoreInterface;
+        semantic?: SemanticStoreInterface;
+        procedural?: ProceduralStoreInterface;
+    }): void;
+    /**
+     * Anticipate needed memories based on context
+     *
+     * Uses context cues to predict which memories will be needed,
+     * and pre-loads them into working memory.
+     */
+    anticipate(context: AnticipationContext): Promise<WorkingMemoryItem[]>;
+    /**
+     * Calculate relevance of a memory to the current context
+     */
+    private calculateRelevance;
+    /**
+     * Add a memory to working memory buffer
+     */
+    addToBuffer(memory: Memory, source?: WorkingMemoryItem['source'], relevance?: number): WorkingMemoryItem;
+    /**
+     * Access a memory in working memory (boosts activation)
+     */
+    access(id: string): WorkingMemoryItem | undefined;
+    /**
+     * Recall a memory (from buffer or stores)
+     */
+    recall(id: string): Memory | undefined;
+    /**
+     * Get all items currently in working memory
+     */
+    getActive(): WorkingMemoryItem[];
+    /**
+     * Get items by type
+     */
+    getByType(type: MemoryType): WorkingMemoryItem[];
+    /**
+     * Check if a memory is in working memory
+     */
+    isActive(id: string): boolean;
+    /**
+     * Get working memory size
+     */
+    size(): number;
+    /**
+     * Curate working memory: decay activations and evict low-activation items
+     */
+    curate(): {
+        decayed: number;
+        evicted: string[];
+    };
+    /**
+     * Start automatic curation
+     */
+    startAutoCuration(): void;
+    /**
+     * Stop automatic curation
+     */
+    stopAutoCuration(): void;
+    /**
+     * Maintain working memory capacity by evicting low-activation items
+     */
+    private maintainCapacity;
+    /**
+     * Evict the item with lowest activation
+     */
+    private evictLowest;
+    /**
+     * Update computed metrics
+     */
+    private updateMetrics;
+    /**
+     * Get memory reuse metrics
+     */
+    getMetrics(): MemoryReuseMetrics;
+    /**
+     * Record a new memory creation (for metrics)
+     */
+    recordNewCreation(): void;
+    /**
+     * Reset metrics
+     */
+    resetMetrics(): void;
+    /**
+     * Get workspace statistics
+     */
+    getStats(): {
+        itemCount: number;
+        maxItems: number;
+        estimatedTokens: number;
+        maxTokens: number;
+        avgActivation: number;
+        avgRelevance: number;
+        byType: Record<MemoryType, number>;
+        bySource: Record<WorkingMemoryItem['source'], number>;
+    };
+    /**
+     * Clear working memory
+     */
+    clear(): void;
+    /**
+     * Shutdown workspace
+     */
+    shutdown(): void;
+}
+export declare function createCognitiveWorkspace(config?: Partial<CognitiveWorkspaceConfig>): CognitiveWorkspace;
+export declare function getCognitiveWorkspace(config?: Partial<CognitiveWorkspaceConfig>): CognitiveWorkspace;
+export declare function resetCognitiveWorkspace(): void;