genesis-ai-cli 7.4.5

package/dist/src/memory/procedural.js

@@ -0,0 +1,479 @@
+"use strict";
+/**
+ * Genesis 6.0 - Procedural Memory Store
+ *
+ * Stores skills and workflows - know-how.
+ * "How to do things"
+ *
+ * Key features:
+ * - Step-by-step procedures
+ * - Success rate tracking
+ * - Skill improvement over time
+ * - Prerequisites and dependencies
+ *
+ * Reference: Anderson, J. R. (1982). Acquisition of cognitive skill.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProceduralStore = void 0;
+exports.createProceduralStore = createProceduralStore;
+const crypto_1 = require("crypto");
+const forgetting_js_1 = require("./forgetting.js");
+// ============================================================================
+// Procedural Store
+// ============================================================================
+class ProceduralStore {
+    memories = new Map();
+    config;
+    // Indexes
+    byName = new Map(); // name -> id
+    byTag = new Map();
+    dependencies = new Map(); // skill -> skills that require it
+    constructor(config = {}) {
+        this.config = {
+            maxSize: 5000,
+            autoForget: true,
+            forgetThreshold: forgetting_js_1.FORGETTING_THRESHOLDS.FORGET,
+            minSuccessRate: 0.2,
+            ...config,
+        };
+    }
+    // ============================================================================
+    // Store
+    // ============================================================================
+    store(input) {
+        const now = new Date();
+        const id = (0, crypto_1.randomUUID)();
+        const memory = {
+            ...input,
+            id,
+            created: now,
+            lastAccessed: now,
+            accessCount: 1,
+        };
+        // Check for existing skill
+        const existingId = this.byName.get(memory.content.name.toLowerCase());
+        if (existingId) {
+            // Update existing skill
+            return this.improveSkill(existingId, memory);
+        }
+        this.memories.set(id, memory);
+        this.updateIndexes(memory);
+        this.maintainSize();
+        return memory;
+    }
+    /**
+     * Convenience method to create a procedural memory from options
+     */
+    createSkill(options) {
+        const now = new Date();
+        const params = (0, forgetting_js_1.calculateInitialParams)({
+            importance: options.importance,
+            complexity: Math.min(1, options.steps.length / 10), // More steps = more complex
+        });
+        // Skills have higher base stability (muscle memory)
+        params.S = 7; // 1 week base stability
+        const steps = options.steps.map((s, i) => ({
+            order: i + 1,
+            action: s.action,
+            params: s.params,
+            condition: s.condition,
+            fallback: s.fallback,
+        }));
+        return this.store({
+            type: 'procedural',
+            content: {
+                name: options.name,
+                description: options.description,
+                steps,
+            },
+            requires: options.requires || [],
+            inputs: options.inputs || [],
+            outputs: options.outputs || [],
+            successRate: 0.5, // Initial neutral rate
+            avgDuration: 0,
+            executionCount: 0,
+            version: 1,
+            improvements: [],
+            R0: params.R0,
+            S: params.S,
+            importance: options.importance || 0.5,
+            emotionalValence: 0,
+            associations: options.associations || [],
+            tags: options.tags || [],
+            consolidated: true, // Procedural memories are already consolidated
+            source: options.source,
+        });
+    }
+    /**
+     * Improve an existing skill with new information
+     */
+    improveSkill(existingId, newMemory) {
+        const existing = this.memories.get(existingId);
+        if (!existing) {
+            return newMemory;
+        }
+        // Compare steps and merge improvements
+        if (newMemory.content.steps.length !== existing.content.steps.length) {
+            // Steps changed - this is a new version
+            existing.version++;
+            existing.improvements.push(`v${existing.version}: Steps updated from ${existing.content.steps.length} to ${newMemory.content.steps.length}`);
+            existing.content.steps = newMemory.content.steps;
+        }
+        // Merge prerequisites
+        existing.requires = [...new Set([...existing.requires, ...newMemory.requires])];
+        // Update description if better
+        if (newMemory.content.description.length > existing.content.description.length) {
+            existing.content.description = newMemory.content.description;
+        }
+        // Strengthen memory
+        existing.S = (0, forgetting_js_1.updateStabilityOnRecall)(existing, true);
+        existing.lastAccessed = new Date();
+        return existing;
+    }
+    // ============================================================================
+    // Get / Update / Delete
+    // ============================================================================
+    get(id) {
+        const memory = this.memories.get(id);
+        if (memory) {
+            this.accessMemory(memory);
+        }
+        return memory;
+    }
+    /**
+     * Get by skill name
+     */
+    getByName(name) {
+        const id = this.byName.get(name.toLowerCase());
+        if (id) {
+            return this.get(id);
+        }
+        return undefined;
+    }
+    /**
+     * Get without updating access (for internal use)
+     */
+    peek(id) {
+        return this.memories.get(id);
+    }
+    update(id, updates) {
+        const memory = this.memories.get(id);
+        if (!memory)
+            return undefined;
+        // Remove from indexes before update
+        this.removeFromIndexes(memory);
+        // Apply updates
+        Object.assign(memory, updates);
+        // Re-add to indexes
+        this.updateIndexes(memory);
+        return memory;
+    }
+    delete(id) {
+        const memory = this.memories.get(id);
+        if (!memory)
+            return false;
+        this.removeFromIndexes(memory);
+        this.memories.delete(id);
+        return true;
+    }
+    // ============================================================================
+    // Query
+    // ============================================================================
+    query(filter) {
+        let results = this.getAll();
+        if (filter.minImportance !== undefined) {
+            results = results.filter((m) => m.importance >= filter.minImportance);
+        }
+        if (filter.maxAge !== undefined) {
+            const cutoff = Date.now() - filter.maxAge * 24 * 60 * 60 * 1000;
+            results = results.filter((m) => m.created.getTime() >= cutoff);
+        }
+        if (filter.minRetention !== undefined) {
+            results = results.filter((m) => {
+                const retention = (0, forgetting_js_1.calculateRetention)({ R0: m.R0, S: m.S }, m.lastAccessed.getTime());
+                return retention >= filter.minRetention;
+            });
+        }
+        if (filter.tags && filter.tags.length > 0) {
+            results = results.filter((m) => filter.tags.some((t) => m.tags.includes(t)));
+        }
+        if (filter.custom) {
+            results = results.filter(filter.custom);
+        }
+        return results;
+    }
+    /**
+     * Search by keyword in name and description
+     */
+    search(queryStr, limit = 10) {
+        const keywords = queryStr.toLowerCase().split(/\s+/);
+        const results = this.getAll().filter((m) => {
+            const searchable = [
+                m.content.name,
+                m.content.description,
+                ...m.tags,
+            ].join(' ').toLowerCase();
+            return keywords.some((k) => searchable.includes(k));
+        });
+        // Sort by success rate * retention
+        results.sort((a, b) => {
+            const scoreA = a.successRate * (0, forgetting_js_1.calculateRetention)({ R0: a.R0, S: a.S }, a.lastAccessed.getTime());
+            const scoreB = b.successRate * (0, forgetting_js_1.calculateRetention)({ R0: b.R0, S: b.S }, b.lastAccessed.getTime());
+            return scoreB - scoreA;
+        });
+        return results.slice(0, limit);
+    }
+    // ============================================================================
+    // Execution Tracking
+    // ============================================================================
+    /**
+     * Record execution of a skill
+     */
+    recordExecution(id, result) {
+        const memory = this.memories.get(id);
+        if (!memory)
+            return;
+        memory.executionCount++;
+        // Update success rate (exponential moving average)
+        const alpha = 0.2;
+        memory.successRate = alpha * (result.success ? 1 : 0) + (1 - alpha) * memory.successRate;
+        // Update average duration
+        if (result.duration > 0) {
+            if (memory.avgDuration === 0) {
+                memory.avgDuration = result.duration;
+            }
+            else {
+                memory.avgDuration = alpha * result.duration + (1 - alpha) * memory.avgDuration;
+            }
+        }
+        // Update stability based on success
+        memory.S = (0, forgetting_js_1.updateStabilityOnRecall)(memory, result.success);
+        memory.lastAccessed = new Date();
+        // Track improvements
+        if (result.success && memory.successRate > 0.8 && !memory.improvements.includes('Mastered')) {
+            memory.improvements.push('Mastered');
+        }
+    }
+    /**
+     * Get skills that need practice (low success rate or retention)
+     */
+    getSkillsNeedingPractice() {
+        return this.getAll().filter((m) => {
+            const retention = (0, forgetting_js_1.calculateRetention)({ R0: m.R0, S: m.S }, m.lastAccessed.getTime());
+            return (m.successRate < 0.7 || retention < 0.5) &&
+                retention >= forgetting_js_1.FORGETTING_THRESHOLDS.FORGET;
+        });
+    }
+    /**
+     * Get mastered skills (high success rate and retention)
+     */
+    getMasteredSkills() {
+        return this.getAll().filter((m) => {
+            const retention = (0, forgetting_js_1.calculateRetention)({ R0: m.R0, S: m.S }, m.lastAccessed.getTime());
+            return m.successRate >= 0.9 && retention >= 0.8;
+        });
+    }
+    // ============================================================================
+    // Dependency Queries
+    // ============================================================================
+    /**
+     * Get prerequisites for a skill
+     */
+    getPrerequisites(id) {
+        const memory = this.memories.get(id);
+        if (!memory)
+            return [];
+        return memory.requires
+            .map((name) => this.getByName(name))
+            .filter((m) => m !== undefined);
+    }
+    /**
+     * Get skills that depend on this skill
+     */
+    getDependents(id) {
+        const memory = this.memories.get(id);
+        if (!memory)
+            return [];
+        const dependentIds = this.dependencies.get(memory.content.name.toLowerCase());
+        if (!dependentIds)
+            return [];
+        return Array.from(dependentIds)
+            .map((depId) => this.memories.get(depId))
+            .filter((m) => m !== undefined);
+    }
+    /**
+     * Check if all prerequisites are met for a skill
+     */
+    canExecute(id, minSuccessRate = 0.5) {
+        const prerequisites = this.getPrerequisites(id);
+        return prerequisites.every((p) => p.successRate >= minSuccessRate);
+    }
+    // ============================================================================
+    // Bulk Operations
+    // ============================================================================
+    getAll() {
+        return Array.from(this.memories.values());
+    }
+    clear() {
+        this.memories.clear();
+        this.byName.clear();
+        this.byTag.clear();
+        this.dependencies.clear();
+    }
+    count() {
+        return this.memories.size;
+    }
+    // ============================================================================
+    // Stats
+    // ============================================================================
+    stats() {
+        const all = this.getAll();
+        let totalRetention = 0;
+        let totalImportance = 0;
+        let consolidated = 0;
+        let oldest;
+        let newest;
+        for (const memory of all) {
+            totalRetention += (0, forgetting_js_1.calculateRetention)({ R0: memory.R0, S: memory.S }, memory.lastAccessed.getTime());
+            totalImportance += memory.importance;
+            if (memory.consolidated)
+                consolidated++;
+            if (!oldest || memory.created < oldest)
+                oldest = memory.created;
+            if (!newest || memory.created > newest)
+                newest = memory.created;
+        }
+        return {
+            total: all.length,
+            byType: {
+                episodic: 0,
+                semantic: 0,
+                procedural: all.length,
+            },
+            consolidated,
+            avgRetention: all.length > 0 ? totalRetention / all.length : 0,
+            avgImportance: all.length > 0 ? totalImportance / all.length : 0,
+            oldestMemory: oldest,
+            newestMemory: newest,
+        };
+    }
+    /**
+     * Get additional procedural-specific stats
+     */
+    proceduralStats() {
+        const all = this.getAll();
+        let totalSuccessRate = 0;
+        let totalExecutions = 0;
+        for (const m of all) {
+            totalSuccessRate += m.successRate;
+            totalExecutions += m.executionCount;
+        }
+        const mastered = this.getMasteredSkills().length;
+        const needsPractice = this.getSkillsNeedingPractice().length;
+        const mostUsed = [...all]
+            .sort((a, b) => b.executionCount - a.executionCount)
+            .slice(0, 10);
+        return {
+            totalSkills: all.length,
+            mastered,
+            needsPractice,
+            avgSuccessRate: all.length > 0 ? totalSuccessRate / all.length : 0,
+            avgExecutions: all.length > 0 ? totalExecutions / all.length : 0,
+            mostUsed,
+        };
+    }
+    // ============================================================================
+    // Forgetting Integration
+    // ============================================================================
+    /**
+     * Get skills that should be forgotten (low retention AND low success)
+     */
+    getForgotten() {
+        return this.getAll().filter((m) => {
+            const retention = (0, forgetting_js_1.calculateRetention)({ R0: m.R0, S: m.S }, m.lastAccessed.getTime());
+            return retention < this.config.forgetThreshold &&
+                m.successRate < this.config.minSuccessRate;
+        });
+    }
+    /**
+     * Run forgetting cycle
+     */
+    runForgetting() {
+        const toForget = this.getForgotten();
+        const ids = toForget.map((m) => m.id);
+        for (const id of ids) {
+            this.delete(id);
+        }
+        return { forgotten: ids.length, ids };
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    accessMemory(memory) {
+        memory.lastAccessed = new Date();
+        memory.accessCount++;
+        memory.S = (0, forgetting_js_1.updateStabilityOnRecall)(memory, true);
+    }
+    updateIndexes(memory) {
+        // Name index
+        this.byName.set(memory.content.name.toLowerCase(), memory.id);
+        // Tag index
+        for (const tag of memory.tags) {
+            if (!this.byTag.has(tag)) {
+                this.byTag.set(tag, new Set());
+            }
+            this.byTag.get(tag).add(memory.id);
+        }
+        // Dependency index
+        for (const req of memory.requires) {
+            const reqLower = req.toLowerCase();
+            if (!this.dependencies.has(reqLower)) {
+                this.dependencies.set(reqLower, new Set());
+            }
+            this.dependencies.get(reqLower).add(memory.id);
+        }
+    }
+    removeFromIndexes(memory) {
+        this.byName.delete(memory.content.name.toLowerCase());
+        for (const tag of memory.tags) {
+            this.byTag.get(tag)?.delete(memory.id);
+        }
+        for (const req of memory.requires) {
+            this.dependencies.get(req.toLowerCase())?.delete(memory.id);
+        }
+    }
+    maintainSize() {
+        if (!this.config.autoForget)
+            return;
+        if (this.memories.size <= this.config.maxSize)
+            return;
+        // First, forget low-performance skills
+        this.runForgetting();
+        // If still over limit, remove lowest scoring skills
+        while (this.memories.size > this.config.maxSize) {
+            let weakest = null;
+            let weakestScore = Infinity;
+            for (const memory of this.memories.values()) {
+                const retention = (0, forgetting_js_1.calculateRetention)({ R0: memory.R0, S: memory.S }, memory.lastAccessed.getTime());
+                const score = memory.successRate * retention;
+                if (score < weakestScore) {
+                    weakestScore = score;
+                    weakest = memory;
+                }
+            }
+            if (weakest) {
+                this.delete(weakest.id);
+            }
+            else {
+                break;
+            }
+        }
+    }
+}
+exports.ProceduralStore = ProceduralStore;
+// ============================================================================
+// Factory
+// ============================================================================
+function createProceduralStore(config) {
+    return new ProceduralStore(config);
+}

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

@@ -0,0 +1,132 @@
+/**
+ * Genesis 6.0 - Semantic Memory Store
+ *
+ * Stores facts and concepts - encyclopedic knowledge.
+ * "What things mean, general knowledge"
+ *
+ * Key features:
+ * - Concept hierarchy (superordinates, subordinates)
+ * - Category-based organization
+ * - Confidence tracking
+ * - Contradiction detection
+ *
+ * Reference: Tulving, E. (1972). Episodic and semantic memory.
+ */
+import { SemanticMemory, IMemoryStore, MemoryFilter, StoreStats } from './types.js';
+export interface SemanticStoreConfig {
+    maxSize: number;
+    autoForget: boolean;
+    forgetThreshold: number;
+    defaultStability: number;
+    minConfidence: number;
+}
+export interface CreateSemanticOptions {
+    concept: string;
+    definition?: string;
+    properties?: Record<string, any>;
+    category: string;
+    superordinates?: string[];
+    subordinates?: string[];
+    related?: string[];
+    confidence?: number;
+    sources?: string[];
+    importance?: number;
+    tags?: string[];
+    associations?: string[];
+}
+export declare class SemanticStore implements IMemoryStore<SemanticMemory> {
+    private memories;
+    private config;
+    private byConcept;
+    private byCategory;
+    private byTag;
+    private hierarchy;
+    constructor(config?: Partial<SemanticStoreConfig>);
+    store(input: Omit<SemanticMemory, 'id' | 'created' | 'lastAccessed' | 'accessCount'>): SemanticMemory;
+    /**
+     * Convenience method to create a semantic memory from options
+     */
+    createFact(options: CreateSemanticOptions): SemanticMemory;
+    /**
+     * Merge new information with existing concept
+     */
+    private mergeWith;
+    get(id: string): SemanticMemory | undefined;
+    /**
+     * Get by concept name
+     */
+    getByConcept(concept: string): SemanticMemory | undefined;
+    /**
+     * Get without updating access (for internal use)
+     */
+    peek(id: string): SemanticMemory | undefined;
+    update(id: string, updates: Partial<SemanticMemory>): SemanticMemory | undefined;
+    delete(id: string): boolean;
+    query(filter: MemoryFilter<SemanticMemory>): SemanticMemory[];
+    /**
+     * Search by keyword in concept and definition
+     */
+    search(queryStr: string, limit?: number): SemanticMemory[];
+    /**
+     * Get all facts in a category
+     */
+    getByCategory(category: string): SemanticMemory[];
+    /**
+     * Get all categories
+     */
+    getCategories(): string[];
+    /**
+     * Get superordinate concepts (more general)
+     */
+    getSuperordinates(id: string): SemanticMemory[];
+    /**
+     * Get subordinate concepts (more specific)
+     */
+    getSubordinates(id: string): SemanticMemory[];
+    /**
+     * Get related concepts
+     */
+    getRelated(id: string): SemanticMemory[];
+    /**
+     * Check if a new fact contradicts existing knowledge
+     */
+    findContradictions(concept: string, properties: Record<string, any>): SemanticMemory[];
+    /**
+     * Get all facts with contradictions
+     */
+    getContradictedFacts(): SemanticMemory[];
+    /**
+     * Record a contradiction
+     */
+    addContradiction(id: string, contradictingId: string): void;
+    getAll(): SemanticMemory[];
+    clear(): void;
+    count(): number;
+    stats(): StoreStats;
+    /**
+     * Get additional semantic-specific stats
+     */
+    semanticStats(): {
+        totalFacts: number;
+        categories: number;
+        avgConfidence: number;
+        contradictions: number;
+        mostUsed: SemanticMemory[];
+    };
+    /**
+     * Get facts that should be forgotten (low retention AND low confidence)
+     */
+    getForgotten(): SemanticMemory[];
+    /**
+     * Run forgetting cycle
+     */
+    runForgetting(): {
+        forgotten: number;
+        ids: string[];
+    };
+    private accessMemory;
+    private updateIndexes;
+    private removeFromIndexes;
+    private maintainSize;
+}
+export declare function createSemanticStore(config?: Partial<SemanticStoreConfig>): SemanticStore;