genesis-ai-cli 7.4.5

package/dist/src/memory/semantic.js

@@ -0,0 +1,497 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticStore = void 0;
+exports.createSemanticStore = createSemanticStore;
+const crypto_1 = require("crypto");
+const forgetting_js_1 = require("./forgetting.js");
+// ============================================================================
+// Semantic Store
+// ============================================================================
+class SemanticStore {
+    memories = new Map();
+    config;
+    // Indexes for efficient querying
+    byConcept = new Map(); // concept name -> id
+    byCategory = new Map();
+    byTag = new Map();
+    hierarchy = new Map(); // parent -> children
+    constructor(config = {}) {
+        this.config = {
+            maxSize: 50000,
+            autoForget: true,
+            forgetThreshold: forgetting_js_1.FORGETTING_THRESHOLDS.FORGET,
+            defaultStability: 30, // Semantic memories are more stable
+            minConfidence: 0.3,
+            ...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 concept
+        const existingId = this.byConcept.get(memory.content.concept.toLowerCase());
+        if (existingId) {
+            // Merge with existing
+            return this.mergeWith(existingId, memory);
+        }
+        this.memories.set(id, memory);
+        this.updateIndexes(memory);
+        this.maintainSize();
+        return memory;
+    }
+    /**
+     * Convenience method to create a semantic memory from options
+     */
+    createFact(options) {
+        const now = new Date();
+        const params = (0, forgetting_js_1.calculateInitialParams)({
+            importance: options.importance,
+            complexity: 0.3, // Facts are generally less complex than episodes
+            priorKnowledge: (options.related?.length || 0) > 0,
+        });
+        // Higher stability for semantic memories
+        params.S = this.config.defaultStability;
+        return this.store({
+            type: 'semantic',
+            content: {
+                concept: options.concept,
+                definition: options.definition,
+                properties: options.properties || {},
+            },
+            category: options.category,
+            superordinates: options.superordinates || [],
+            subordinates: options.subordinates || [],
+            related: options.related || [],
+            confidence: options.confidence || 0.8,
+            sources: options.sources || [],
+            contradictions: [],
+            usageCount: 0,
+            lastUsed: now,
+            R0: params.R0,
+            S: params.S,
+            importance: options.importance || 0.5,
+            emotionalValence: 0, // Facts are neutral
+            associations: options.associations || [],
+            tags: options.tags || [],
+            consolidated: true, // Semantic memories are already consolidated
+        });
+    }
+    /**
+     * Merge new information with existing concept
+     */
+    mergeWith(existingId, newMemory) {
+        const existing = this.memories.get(existingId);
+        if (!existing) {
+            return newMemory;
+        }
+        // Merge properties
+        existing.content.properties = {
+            ...existing.content.properties,
+            ...newMemory.content.properties,
+        };
+        // Update definition if new one provided
+        if (newMemory.content.definition) {
+            existing.content.definition = newMemory.content.definition;
+        }
+        // Merge relationships
+        existing.superordinates = [...new Set([...existing.superordinates, ...newMemory.superordinates])];
+        existing.subordinates = [...new Set([...existing.subordinates, ...newMemory.subordinates])];
+        existing.related = [...new Set([...existing.related, ...newMemory.related])];
+        existing.sources = [...new Set([...existing.sources, ...newMemory.sources])];
+        existing.tags = [...new Set([...existing.tags, ...newMemory.tags])];
+        // Update confidence (weighted average)
+        existing.confidence = (existing.confidence + newMemory.confidence) / 2;
+        // Strengthen memory
+        existing.S = (0, forgetting_js_1.updateStabilityOnRecall)(existing, true);
+        existing.lastAccessed = new Date();
+        existing.usageCount++;
+        return existing;
+    }
+    // ============================================================================
+    // Get / Update / Delete
+    // ============================================================================
+    get(id) {
+        const memory = this.memories.get(id);
+        if (memory) {
+            this.accessMemory(memory);
+        }
+        return memory;
+    }
+    /**
+     * Get by concept name
+     */
+    getByConcept(concept) {
+        const id = this.byConcept.get(concept.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 concept and definition
+     */
+    search(queryStr, limit = 10) {
+        const keywords = queryStr.toLowerCase().split(/\s+/);
+        const results = this.getAll().filter((m) => {
+            const searchable = [
+                m.content.concept,
+                m.content.definition || '',
+                m.category,
+                ...m.tags,
+            ].join(' ').toLowerCase();
+            return keywords.some((k) => searchable.includes(k));
+        });
+        // Sort by confidence * retention
+        results.sort((a, b) => {
+            const scoreA = a.confidence * (0, forgetting_js_1.calculateRetention)({ R0: a.R0, S: a.S }, a.lastAccessed.getTime());
+            const scoreB = b.confidence * (0, forgetting_js_1.calculateRetention)({ R0: b.R0, S: b.S }, b.lastAccessed.getTime());
+            return scoreB - scoreA;
+        });
+        return results.slice(0, limit);
+    }
+    // ============================================================================
+    // Category and Hierarchy Queries
+    // ============================================================================
+    /**
+     * Get all facts in a category
+     */
+    getByCategory(category) {
+        const ids = this.byCategory.get(category);
+        if (!ids)
+            return [];
+        return Array.from(ids)
+            .map((id) => this.memories.get(id))
+            .filter((m) => m !== undefined);
+    }
+    /**
+     * Get all categories
+     */
+    getCategories() {
+        return Array.from(this.byCategory.keys());
+    }
+    /**
+     * Get superordinate concepts (more general)
+     */
+    getSuperordinates(id) {
+        const memory = this.memories.get(id);
+        if (!memory)
+            return [];
+        return memory.superordinates
+            .map((name) => this.getByConcept(name))
+            .filter((m) => m !== undefined);
+    }
+    /**
+     * Get subordinate concepts (more specific)
+     */
+    getSubordinates(id) {
+        const memory = this.memories.get(id);
+        if (!memory)
+            return [];
+        return memory.subordinates
+            .map((name) => this.getByConcept(name))
+            .filter((m) => m !== undefined);
+    }
+    /**
+     * Get related concepts
+     */
+    getRelated(id) {
+        const memory = this.memories.get(id);
+        if (!memory)
+            return [];
+        return memory.related
+            .map((name) => this.getByConcept(name))
+            .filter((m) => m !== undefined);
+    }
+    // ============================================================================
+    // Contradiction Detection
+    // ============================================================================
+    /**
+     * Check if a new fact contradicts existing knowledge
+     */
+    findContradictions(concept, properties) {
+        const existing = this.getByConcept(concept);
+        if (!existing)
+            return [];
+        const contradictions = [];
+        // Check for property conflicts
+        for (const [key, value] of Object.entries(properties)) {
+            if (existing.content.properties[key] !== undefined &&
+                existing.content.properties[key] !== value) {
+                contradictions.push(existing);
+                break;
+            }
+        }
+        return contradictions;
+    }
+    /**
+     * Get all facts with contradictions
+     */
+    getContradictedFacts() {
+        return this.getAll().filter((m) => m.contradictions && m.contradictions.length > 0);
+    }
+    /**
+     * Record a contradiction
+     */
+    addContradiction(id, contradictingId) {
+        const memory = this.memories.get(id);
+        if (!memory)
+            return;
+        if (!memory.contradictions) {
+            memory.contradictions = [];
+        }
+        if (!memory.contradictions.includes(contradictingId)) {
+            memory.contradictions.push(contradictingId);
+        }
+    }
+    // ============================================================================
+    // Bulk Operations
+    // ============================================================================
+    getAll() {
+        return Array.from(this.memories.values());
+    }
+    clear() {
+        this.memories.clear();
+        this.byConcept.clear();
+        this.byCategory.clear();
+        this.byTag.clear();
+        this.hierarchy.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: all.length,
+                procedural: 0,
+            },
+            consolidated,
+            avgRetention: all.length > 0 ? totalRetention / all.length : 0,
+            avgImportance: all.length > 0 ? totalImportance / all.length : 0,
+            oldestMemory: oldest,
+            newestMemory: newest,
+        };
+    }
+    /**
+     * Get additional semantic-specific stats
+     */
+    semanticStats() {
+        const all = this.getAll();
+        let totalConfidence = 0;
+        let contradictions = 0;
+        for (const m of all) {
+            totalConfidence += m.confidence;
+            if (m.contradictions && m.contradictions.length > 0) {
+                contradictions++;
+            }
+        }
+        const mostUsed = [...all]
+            .sort((a, b) => b.usageCount - a.usageCount)
+            .slice(0, 10);
+        return {
+            totalFacts: all.length,
+            categories: this.byCategory.size,
+            avgConfidence: all.length > 0 ? totalConfidence / all.length : 0,
+            contradictions,
+            mostUsed,
+        };
+    }
+    // ============================================================================
+    // Forgetting Integration
+    // ============================================================================
+    /**
+     * Get facts that should be forgotten (low retention AND low confidence)
+     */
+    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.confidence < this.config.minConfidence;
+        });
+    }
+    /**
+     * 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.lastUsed = new Date();
+        memory.accessCount++;
+        memory.usageCount++;
+        memory.S = (0, forgetting_js_1.updateStabilityOnRecall)(memory, true);
+    }
+    updateIndexes(memory) {
+        // Concept index
+        this.byConcept.set(memory.content.concept.toLowerCase(), memory.id);
+        // Category index
+        if (!this.byCategory.has(memory.category)) {
+            this.byCategory.set(memory.category, new Set());
+        }
+        this.byCategory.get(memory.category).add(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);
+        }
+        // Hierarchy index
+        for (const parent of memory.superordinates) {
+            if (!this.hierarchy.has(parent)) {
+                this.hierarchy.set(parent, new Set());
+            }
+            this.hierarchy.get(parent).add(memory.content.concept);
+        }
+    }
+    removeFromIndexes(memory) {
+        this.byConcept.delete(memory.content.concept.toLowerCase());
+        this.byCategory.get(memory.category)?.delete(memory.id);
+        for (const tag of memory.tags) {
+            this.byTag.get(tag)?.delete(memory.id);
+        }
+        for (const parent of memory.superordinates) {
+            this.hierarchy.get(parent)?.delete(memory.content.concept);
+        }
+    }
+    maintainSize() {
+        if (!this.config.autoForget)
+            return;
+        if (this.memories.size <= this.config.maxSize)
+            return;
+        // First, forget low-confidence memories
+        this.runForgetting();
+        // If still over limit, remove lowest confidence * retention
+        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.confidence * retention;
+                if (score < weakestScore) {
+                    weakestScore = score;
+                    weakest = memory;
+                }
+            }
+            if (weakest) {
+                this.delete(weakest.id);
+            }
+            else {
+                break;
+            }
+        }
+    }
+}
+exports.SemanticStore = SemanticStore;
+// ============================================================================
+// Factory
+// ============================================================================
+function createSemanticStore(config) {
+    return new SemanticStore(config);
+}

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

@@ -0,0 +1,193 @@
+/**
+ * Genesis 6.0 - Memory Module Types
+ *
+ * Based on cognitive science memory architecture:
+ * - Episodic: Events with when/where/who (autobiographical)
+ * - Semantic: Facts and concepts (encyclopedic)
+ * - Procedural: Skills and workflows (know-how)
+ *
+ * References:
+ * - Tulving (1972): Episodic vs Semantic distinction
+ * - Ebbinghaus (1885): Forgetting curve R = e^(-t/S)
+ * - FSRS: Free Spaced Repetition Scheduler
+ */
+/**
+ * Memory type classification (Tulving model)
+ */
+export type MemoryType = 'episodic' | 'semantic' | 'procedural';
+/**
+ * Base interface for all memory items
+ */
+export interface BaseMemory {
+    id: string;
+    type: MemoryType;
+    created: Date;
+    lastAccessed: Date;
+    accessCount: number;
+    R0: number;
+    S: number;
+    importance: number;
+    emotionalValence: number;
+    associations: string[];
+    tags: string[];
+    consolidated: boolean;
+    source?: string;
+}
+/**
+ * Episodic memories are events with context
+ * "What happened, when, where, who was involved"
+ */
+export interface EpisodicMemory extends BaseMemory {
+    type: 'episodic';
+    content: {
+        what: string;
+        details: any;
+    };
+    when: {
+        timestamp: Date;
+        duration?: number;
+        sequence?: number;
+    };
+    where?: {
+        location: string;
+        context: string;
+    };
+    who?: {
+        agents: string[];
+        roles: Record<string, string>;
+    };
+    feeling?: {
+        valence: number;
+        arousal: number;
+        label?: string;
+    };
+}
+/**
+ * Semantic memories are facts and concepts
+ * "What things mean, general knowledge"
+ */
+export interface SemanticMemory extends BaseMemory {
+    type: 'semantic';
+    content: {
+        concept: string;
+        definition?: string;
+        properties: Record<string, any>;
+    };
+    category: string;
+    superordinates: string[];
+    subordinates: string[];
+    related: string[];
+    confidence: number;
+    sources: string[];
+    contradictions?: string[];
+    usageCount: number;
+    lastUsed: Date;
+}
+/**
+ * Procedural memories are skills and workflows
+ * "How to do things"
+ */
+export interface ProceduralMemory extends BaseMemory {
+    type: 'procedural';
+    content: {
+        name: string;
+        description: string;
+        steps: ProceduralStep[];
+    };
+    requires: string[];
+    inputs: ParameterDef[];
+    outputs: ParameterDef[];
+    successRate: number;
+    avgDuration: number;
+    executionCount: number;
+    version: number;
+    improvements: string[];
+}
+export interface ProceduralStep {
+    order: number;
+    action: string;
+    params?: Record<string, any>;
+    condition?: string;
+    fallback?: string;
+}
+export interface ParameterDef {
+    name: string;
+    type: string;
+    required: boolean;
+    default?: any;
+    description?: string;
+}
+export type Memory = EpisodicMemory | SemanticMemory | ProceduralMemory;
+/**
+ * Interface for memory stores
+ */
+export interface IMemoryStore<T extends BaseMemory> {
+    store(memory: Omit<T, 'id' | 'created' | 'lastAccessed' | 'accessCount'>): T;
+    get(id: string): T | undefined;
+    update(id: string, updates: Partial<T>): T | undefined;
+    delete(id: string): boolean;
+    query(filter: MemoryFilter<T>): T[];
+    search(query: string, limit?: number): T[];
+    getAll(): T[];
+    clear(): void;
+    count(): number;
+    stats(): StoreStats;
+}
+export interface MemoryFilter<T extends BaseMemory> {
+    type?: MemoryType;
+    minImportance?: number;
+    maxAge?: number;
+    minRetention?: number;
+    tags?: string[];
+    consolidated?: boolean;
+    custom?: (memory: T) => boolean;
+}
+export interface StoreStats {
+    total: number;
+    byType: Record<MemoryType, number>;
+    consolidated: number;
+    avgRetention: number;
+    avgImportance: number;
+    oldestMemory?: Date;
+    newestMemory?: Date;
+}
+export type ConsolidationMode = 'background' | 'sleep' | 'immediate';
+export interface ConsolidationResult {
+    mode: ConsolidationMode;
+    timestamp: Date;
+    duration: number;
+    episodicProcessed: number;
+    semanticCreated: number;
+    proceduralUpdated: number;
+    forgotten: number;
+    merged: number;
+    newFacts: string[];
+    updatedSkills: string[];
+}
+export interface ConsolidationConfig {
+    retentionThreshold: number;
+    consolidationThreshold: number;
+    mergeThreshold: number;
+    backgroundIntervalMs: number;
+    sleepDurationMs: number;
+    maxEpisodicAge: number;
+    maxSemanticSize: number;
+}
+export interface ForgettingParams {
+    R0: number;
+    S: number;
+}
+export interface RetentionResult {
+    retention: number;
+    elapsedDays: number;
+    predictedHalfLife: number;
+    shouldForget: boolean;
+}
+export type MemoryEventType = 'STORE' | 'ACCESS' | 'UPDATE' | 'DELETE' | 'CONSOLIDATE' | 'FORGET' | 'MERGE' | 'ASSOCIATE';
+export interface MemoryEvent {
+    type: MemoryEventType;
+    memoryId: string;
+    memoryType: MemoryType;
+    timestamp: Date;
+    details?: Record<string, any>;
+}

package/dist/src/memory/types.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Genesis 6.0 - Memory Module Types
+ *
+ * Based on cognitive science memory architecture:
+ * - Episodic: Events with when/where/who (autobiographical)
+ * - Semantic: Facts and concepts (encyclopedic)
+ * - Procedural: Skills and workflows (know-how)
+ *
+ * References:
+ * - Tulving (1972): Episodic vs Semantic distinction
+ * - Ebbinghaus (1885): Forgetting curve R = e^(-t/S)
+ * - FSRS: Free Spaced Repetition Scheduler
+ */
+Object.defineProperty(exports, "__esModule", { value: true });