@phuetz/code-buddy 0.3.0 → 1.0.0-rc.8

package/dist/memory/knowledge-graph.js

@@ -0,0 +1,887 @@
+/**
+ * Knowledge Graph Memory — memU-inspired persistent memory
+ *
+ * Local knowledge graph that memorizes user preferences, habits, temporal
+ * patterns, and entity relationships. The agent improves over time.
+ *
+ * Unlike flat memory (MEMORY.md, EnhancedMemory), this captures RELATIONS
+ * between entities — enabling context-aware recall like:
+ *   "User → prefers → short responses" + "time:morning → weight:0.9"
+ *   "User → works_on → ProjectX" + "ProjectX → uses → TypeScript"
+ *   "Client → named → Jean" + "Jean → is → VIP"
+ *
+ * Storage: JSON file (lightweight, no Neo4j dependency)
+ *
+ * memU parity features:
+ *   - 3-layer hierarchy (entities → relations → categories with auto-summaries)
+ *   - Salience scoring: similarity * log(reinforcement+1) * recency_decay
+ *   - Content-hash dedup (SHA256 normalized)
+ *   - Intent routing (skip injection for trivial messages)
+ *   - Category auto-summaries (compressed topic representations)
+ *   - Background-safe extraction (fire-and-forget)
+ *   - Reinforcement counting (frequently mentioned = more important)
+ */
+import { createHash } from 'crypto';
+import { existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { logger } from '../utils/logger.js';
+import { shouldWriteProjectRuntimeFiles } from '../utils/runtime-flags.js';
+// ============================================================================
+// memU Salience Scoring
+// ============================================================================
+/**
+ * Salience score: combines relevance, reinforcement, and recency.
+ * Formula from memU: similarity * log(reinforcement+1) * exp(-0.693 * days / halfLife)
+ */
+export function computeSalience(mentions, updatedAt, halfLifeDays = 60, baseSimilarity = 1.0) {
+    const daysSinceUpdate = (Date.now() - updatedAt.getTime()) / (1000 * 60 * 60 * 24);
+    const reinforcement = Math.log(mentions + 1);
+    const recencyDecay = Math.exp(-0.693 * daysSinceUpdate / halfLifeDays);
+    return baseSimilarity * reinforcement * recencyDecay;
+}
+// ============================================================================
+// memU Content-Hash Dedup
+// ============================================================================
+/**
+ * Content hash for deduplication (memU pattern: SHA256 of normalized text).
+ */
+export function contentHash(type, text) {
+    const normalized = text.toLowerCase().replace(/\s+/g, ' ').trim();
+    return createHash('sha256').update(`${type}:${normalized}`).digest('hex').substring(0, 16);
+}
+// ============================================================================
+// memU Intent Router (skip retrieval for trivial messages)
+// ============================================================================
+const TRIVIAL_PATTERNS = [
+    /^(hi|hello|hey|bonjour|salut|coucou|merci|thanks|thank you|ok|okay|oui|non|yes|no)\s*[.!?]?$/i,
+    /^(good\s+(?:morning|afternoon|evening|night)|bonne?\s+(?:matin|journée|soirée|nuit))\s*[.!?]?$/i,
+    /^\/\w+/, // slash commands
+    /^\s*$/, // empty
+];
+/**
+ * Determine if a message is trivial (no memory retrieval needed).
+ * memU pattern: intent routing to skip retrieval for greetings/commands.
+ */
+export function isTrivialMessage(message) {
+    return TRIVIAL_PATTERNS.some(p => p.test(message.trim()));
+}
+// ============================================================================
+// Entity Extraction Patterns
+// ============================================================================
+const EXTRACTION_PATTERNS = [
+    // Preferences: "I prefer X", "I like X", "je préfère X"
+    {
+        pattern: /(?:i\s+prefer|i\s+like|je\s+pr[ée]f[èe]re|j'aime)\s+(.+?)(?:\.|$)/i,
+        entityType: 'preference',
+        relationType: 'prefers',
+        extract: (m) => ({ entity: (m[1] ?? '').trim() }),
+    },
+    // Dislikes: "I don't like X", "I hate X", "je déteste X"
+    {
+        pattern: /(?:i\s+(?:don'?t|do\s+not)\s+like|i\s+hate|i\s+dislike|je\s+d[ée]teste|je\s+n'aime\s+pas)\s+(.+?)(?:\.|$)/i,
+        entityType: 'preference',
+        relationType: 'dislikes',
+        extract: (m) => ({ entity: (m[1] ?? '').trim() }),
+    },
+    // Working on: "I'm working on X", "je travaille sur X"
+    {
+        pattern: /(?:i(?:'m|\s+am)\s+working\s+on|je\s+travaille\s+sur)\s+(.+?)(?:\.|$)/i,
+        entityType: 'project',
+        relationType: 'works_on',
+        extract: (m) => ({ entity: (m[1] ?? '').trim() }),
+    },
+    // Uses: "I use X", "we use X", "on utilise X"
+    {
+        pattern: /(?:i\s+use|we\s+use|on\s+utilise|j'utilise|nous\s+utilisons)\s+(.+?)(?:\s+for\s+|\.|\s+pour\s+|$)/i,
+        entityType: 'technology',
+        relationType: 'uses',
+        extract: (m) => ({ entity: (m[1] ?? '').trim() }),
+    },
+    // Knows person: "my colleague X", "mon collègue X", "X is a VIP"
+    {
+        pattern: /(?:my\s+(?:colleague|client|boss|manager|friend)|mon\s+(?:coll[èe]gue|client|chef))\s+(?:is\s+)?(\w+)/i,
+        entityType: 'person',
+        relationType: 'knows',
+        extract: (m) => ({ entity: (m[1] ?? '').trim() }),
+    },
+    // VIP/important: "X is a VIP", "X is important"
+    {
+        pattern: /(\w+)\s+(?:is\s+(?:a\s+)?(?:VIP|important|key|critical)|est\s+(?:un\s+)?(?:VIP|important))/i,
+        entityType: 'person',
+        relationType: 'related_to',
+        extract: (m) => ({ entity: (m[1] ?? '').trim(), properties: { importance: 'vip' } }),
+    },
+    // Temporal: "in the morning I prefer X", "le matin je préfère X"
+    {
+        pattern: /(?:in\s+the\s+)?(?:morning|matin|evening|soir|afternoon|apr[èe]s-midi|friday|vendredi|weekend)\s+(?:i\s+prefer|je\s+pr[ée]f[èe]re)\s+(.+?)(?:\.|$)/i,
+        entityType: 'habit',
+        relationType: 'temporal_pattern',
+        extract: (m) => {
+            const temporal = (m[0] ?? '').match(/morning|matin|evening|soir|afternoon|apr[èe]s-midi|friday|vendredi|weekend/i);
+            return { entity: (m[1] ?? '').trim(), properties: { temporal: temporal?.[0]?.toLowerCase() } };
+        },
+    },
+    // Style: "always use X", "toujours utiliser X"
+    {
+        pattern: /(?:always\s+use|toujours\s+utiliser|never\s+use|jamais\s+utiliser)\s+(.+?)(?:\.|$)/i,
+        entityType: 'preference',
+        relationType: 'has_style',
+        extract: (m) => ({ entity: (m[1] ?? '').trim(), properties: { strength: (m[0] ?? '').match(/never|jamais/i) ? 'avoid' : 'always' } }),
+    },
+];
+// ============================================================================
+// Temporal Utilities
+// ============================================================================
+function getCurrentTemporalContext() {
+    const now = new Date();
+    const hour = now.getHours();
+    const day = now.getDay();
+    const contexts = [];
+    if (hour >= 5 && hour < 12)
+        contexts.push('morning', 'matin');
+    else if (hour >= 12 && hour < 14)
+        contexts.push('midday', 'midi');
+    else if (hour >= 14 && hour < 18)
+        contexts.push('afternoon', 'après-midi');
+    else if (hour >= 18 && hour < 22)
+        contexts.push('evening', 'soir');
+    else
+        contexts.push('night', 'nuit');
+    if (day === 0 || day === 6)
+        contexts.push('weekend');
+    else
+        contexts.push('weekday');
+    const dayNames = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+    const dayNamesFr = ['dimanche', 'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi'];
+    // day is Date.getDay() (0-6); both arrays have 7 entries so lookups are in-bounds.
+    // Guard preserves behavior: push only the entries that exist (always true here).
+    const dayName = dayNames[day];
+    const dayNameFr = dayNamesFr[day];
+    if (dayName !== undefined)
+        contexts.push(dayName);
+    if (dayNameFr !== undefined)
+        contexts.push(dayNameFr);
+    return contexts;
+}
+// ============================================================================
+// Knowledge Graph
+// ============================================================================
+export class KnowledgeGraph {
+    entities = new Map();
+    relations = new Map();
+    /** Adjacency list: entityId -> Set of relationIds */
+    adjacency = new Map();
+    /** Reverse adjacency: targetId -> Set of relationIds */
+    reverseAdjacency = new Map();
+    dbPath;
+    dirty = false;
+    loaded = false;
+    saveTimer = null;
+    idCounter = 0;
+    /** memU Layer 3: auto-categories with summaries */
+    categories = new Map();
+    /** memU: content-hash index for O(1) dedup */
+    contentHashes = new Set();
+    constructor(cwd = process.cwd()) {
+        const dir = join(cwd, '.codebuddy');
+        this.dbPath = join(dir, 'knowledge-graph.json');
+    }
+    // ──────────────────────────────────────────────────────────────
+    // Entity CRUD
+    // ──────────────────────────────────────────────────────────────
+    addEntity(type, name, properties = {}, confidence = 0.7) {
+        // Check for existing entity with same name+type
+        const existing = this.findEntity(name, type);
+        if (existing) {
+            existing.mentions++;
+            existing.confidence = Math.min(1, existing.confidence + 0.05);
+            existing.updatedAt = new Date();
+            Object.assign(existing.properties, properties);
+            this.markDirty();
+            return existing;
+        }
+        const id = `e_${++this.idCounter}_${Date.now()}`;
+        const entity = {
+            id,
+            type,
+            name: name.toLowerCase().trim(),
+            properties,
+            confidence,
+            mentions: 1,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        this.entities.set(id, entity);
+        this.adjacency.set(id, new Set());
+        this.reverseAdjacency.set(id, new Set());
+        this.markDirty();
+        return entity;
+    }
+    findEntity(name, type) {
+        const normalized = name.toLowerCase().trim();
+        for (const entity of this.entities.values()) {
+            if (entity.name === normalized && (!type || entity.type === type)) {
+                return entity;
+            }
+        }
+        return undefined;
+    }
+    getEntity(id) {
+        return this.entities.get(id);
+    }
+    removeEntity(id) {
+        if (!this.entities.has(id))
+            return false;
+        // Remove all relations involving this entity
+        const outgoing = this.adjacency.get(id) || new Set();
+        const incoming = this.reverseAdjacency.get(id) || new Set();
+        for (const relId of [...outgoing, ...incoming]) {
+            this.relations.delete(relId);
+        }
+        this.adjacency.delete(id);
+        this.reverseAdjacency.delete(id);
+        this.entities.delete(id);
+        this.markDirty();
+        return true;
+    }
+    // ──────────────────────────────────────────────────────────────
+    // Relation CRUD
+    // ──────────────────────────────────────────────────────────────
+    addRelation(sourceId, targetId, type, properties = {}, temporalContext, weight = 0.7) {
+        if (!this.entities.has(sourceId) || !this.entities.has(targetId))
+            return null;
+        // Check for existing relation
+        const existing = this.findRelation(sourceId, targetId, type);
+        if (existing) {
+            existing.mentions++;
+            existing.weight = Math.min(1, existing.weight + 0.05);
+            existing.updatedAt = new Date();
+            if (temporalContext)
+                existing.temporalContext = temporalContext;
+            Object.assign(existing.properties, properties);
+            this.markDirty();
+            return existing;
+        }
+        const id = `r_${++this.idCounter}_${Date.now()}`;
+        const relation = {
+            id,
+            sourceId,
+            targetId,
+            type,
+            weight,
+            properties,
+            temporalContext,
+            confidence: 0.7,
+            mentions: 1,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        this.relations.set(id, relation);
+        if (!this.adjacency.has(sourceId))
+            this.adjacency.set(sourceId, new Set());
+        if (!this.reverseAdjacency.has(targetId))
+            this.reverseAdjacency.set(targetId, new Set());
+        this.adjacency.get(sourceId).add(id);
+        this.reverseAdjacency.get(targetId).add(id);
+        this.markDirty();
+        return relation;
+    }
+    findRelation(sourceId, targetId, type) {
+        const outgoing = this.adjacency.get(sourceId);
+        if (!outgoing)
+            return undefined;
+        for (const relId of outgoing) {
+            const rel = this.relations.get(relId);
+            if (rel && rel.targetId === targetId && (!type || rel.type === type)) {
+                return rel;
+            }
+        }
+        return undefined;
+    }
+    // ──────────────────────────────────────────────────────────────
+    // Graph Traversal
+    // ──────────────────────────────────────────────────────────────
+    /**
+     * Get all relations from an entity (outgoing).
+     */
+    getRelationsFrom(entityId, type) {
+        const outgoing = this.adjacency.get(entityId);
+        if (!outgoing)
+            return [];
+        const results = [];
+        for (const relId of outgoing) {
+            const rel = this.relations.get(relId);
+            if (rel && (!type || rel.type === type)) {
+                results.push(rel);
+            }
+        }
+        return results.sort((a, b) => b.weight - a.weight);
+    }
+    /**
+     * Get all relations to an entity (incoming).
+     */
+    getRelationsTo(entityId, type) {
+        const incoming = this.reverseAdjacency.get(entityId);
+        if (!incoming)
+            return [];
+        const results = [];
+        for (const relId of incoming) {
+            const rel = this.relations.get(relId);
+            if (rel && (!type || rel.type === type)) {
+                results.push(rel);
+            }
+        }
+        return results.sort((a, b) => b.weight - a.weight);
+    }
+    /**
+     * BFS traversal from an entity up to a given depth.
+     */
+    traverse(startId, depth = 2, minConfidence = 0.3) {
+        const results = [];
+        const visited = new Set([startId]);
+        const queue = [{ entityId: startId, currentDepth: 0 }];
+        while (queue.length > 0) {
+            const { entityId, currentDepth } = queue.shift();
+            if (currentDepth >= depth)
+                continue;
+            const outgoing = this.adjacency.get(entityId) || new Set();
+            for (const relId of outgoing) {
+                const rel = this.relations.get(relId);
+                if (!rel || rel.confidence < minConfidence)
+                    continue;
+                const target = this.entities.get(rel.targetId);
+                if (!target || visited.has(target.id))
+                    continue;
+                visited.add(target.id);
+                results.push({ entity: target, relation: rel, depth: currentDepth + 1 });
+                queue.push({ entityId: target.id, currentDepth: currentDepth + 1 });
+            }
+        }
+        return results;
+    }
+    /**
+     * Query the graph with filters.
+     */
+    query(q) {
+        const results = [];
+        const limit = q.limit || 20;
+        const minConf = q.minConfidence || 0.3;
+        // Find starting entities
+        let candidates;
+        if (q.from) {
+            const entity = this.findEntity(q.from) || this.getEntity(q.from);
+            if (!entity)
+                return [];
+            // Traverse from this entity
+            const traversed = this.traverse(entity.id, q.depth || 2, minConf);
+            candidates = traversed.map(t => t.entity);
+        }
+        else {
+            candidates = [...this.entities.values()];
+        }
+        // Apply filters
+        for (const entity of candidates) {
+            if (q.entityType && entity.type !== q.entityType)
+                continue;
+            if (entity.confidence < minConf)
+                continue;
+            let relations = [...this.getRelationsFrom(entity.id), ...this.getRelationsTo(entity.id)];
+            if (q.relationType) {
+                relations = relations.filter(r => r.type === q.relationType);
+            }
+            if (q.temporalFilter) {
+                relations = relations.filter(r => !r.temporalContext || r.temporalContext.includes(q.temporalFilter));
+            }
+            if (relations.length > 0 || !q.relationType) {
+                results.push({ entity, relations });
+            }
+            if (results.length >= limit)
+                break;
+        }
+        return results;
+    }
+    // ──────────────────────────────────────────────────────────────
+    // Auto-Extraction from User Messages
+    // ──────────────────────────────────────────────────────────────
+    /**
+     * Extract entities and relations from a user message.
+     * Returns the number of new facts extracted.
+     */
+    extractFromMessage(message) {
+        let extracted = 0;
+        const userEntity = this.ensureUserEntity();
+        for (const pattern of EXTRACTION_PATTERNS) {
+            const match = message.match(pattern.pattern);
+            if (!match)
+                continue;
+            const { entity: name, properties } = pattern.extract(match);
+            if (!name || name.length < 2 || name.length > 100)
+                continue;
+            const target = this.addEntity(pattern.entityType, name, properties || {});
+            const temporal = properties?.temporal;
+            this.addRelation(userEntity.id, target.id, pattern.relationType, properties || {}, temporal);
+            extracted++;
+        }
+        return extracted;
+    }
+    /**
+     * Ensure the "user" entity exists.
+     */
+    ensureUserEntity() {
+        const existing = this.findEntity('user', 'user');
+        if (existing)
+            return existing;
+        return this.addEntity('user', 'user', {}, 1.0);
+    }
+    // ──────────────────────────────────────────────────────────────
+    // Context Generation (for system prompt injection)
+    // ──────────────────────────────────────────────────────────────
+    /**
+     * Build a context block for the current turn.
+     * Returns relevant facts, preferences, and temporal habits.
+     */
+    buildContextBlock(currentQuery, maxTokens = 600) {
+        const context = {
+            facts: [],
+            preferences: [],
+            temporalHabits: [],
+            relatedEntities: [],
+            tokenEstimate: 0,
+        };
+        const userEntity = this.findEntity('user', 'user');
+        if (!userEntity)
+            return context;
+        const temporalContexts = getCurrentTemporalContext();
+        // 1. User preferences
+        const prefRelations = this.getRelationsFrom(userEntity.id, 'prefers');
+        for (const rel of prefRelations.slice(0, 10)) {
+            const target = this.entities.get(rel.targetId);
+            if (!target)
+                continue;
+            context.preferences.push(`Prefers: ${target.name}${rel.temporalContext ? ` (${rel.temporalContext})` : ''}`);
+        }
+        // 2. User dislikes
+        const dislikeRelations = this.getRelationsFrom(userEntity.id, 'dislikes');
+        for (const rel of dislikeRelations.slice(0, 5)) {
+            const target = this.entities.get(rel.targetId);
+            if (!target)
+                continue;
+            context.preferences.push(`Dislikes: ${target.name}`);
+        }
+        // 3. Style preferences
+        const styleRelations = this.getRelationsFrom(userEntity.id, 'has_style');
+        for (const rel of styleRelations.slice(0, 5)) {
+            const target = this.entities.get(rel.targetId);
+            if (!target)
+                continue;
+            const strength = rel.properties?.strength === 'avoid' ? 'Never use' : 'Always use';
+            context.preferences.push(`${strength}: ${target.name}`);
+        }
+        // 4. Temporal habits (active NOW)
+        const temporalRelations = this.getRelationsFrom(userEntity.id, 'temporal_pattern');
+        for (const rel of temporalRelations) {
+            if (!rel.temporalContext)
+                continue;
+            const isActive = temporalContexts.some(tc => rel.temporalContext.toLowerCase().includes(tc));
+            if (isActive) {
+                const target = this.entities.get(rel.targetId);
+                if (target) {
+                    context.temporalHabits.push(`Now (${rel.temporalContext}): ${target.name}`);
+                }
+            }
+        }
+        // 5. Projects and technologies
+        const workRelations = this.getRelationsFrom(userEntity.id, 'works_on');
+        for (const rel of workRelations.slice(0, 3)) {
+            const project = this.entities.get(rel.targetId);
+            if (!project)
+                continue;
+            const techRels = this.getRelationsFrom(project.id, 'uses');
+            const techs = techRels
+                .map(tr => this.entities.get(tr.targetId)?.name)
+                .filter(Boolean)
+                .join(', ');
+            context.facts.push(`Works on: ${project.name}${techs ? ` (${techs})` : ''}`);
+        }
+        // 6. Known people
+        const knowsRelations = this.getRelationsFrom(userEntity.id, 'knows');
+        for (const rel of knowsRelations.slice(0, 5)) {
+            const person = this.entities.get(rel.targetId);
+            if (!person)
+                continue;
+            const importance = person.properties?.importance;
+            context.relatedEntities.push(`Knows: ${person.name}${importance ? ` (${importance})` : ''}`);
+        }
+        // Estimate tokens (~4 chars per token)
+        const allItems = [...context.facts, ...context.preferences, ...context.temporalHabits, ...context.relatedEntities];
+        context.tokenEstimate = Math.ceil(allItems.join('\n').length / 4);
+        // Trim to budget
+        if (context.tokenEstimate > maxTokens) {
+            const ratio = maxTokens / context.tokenEstimate;
+            const trimTo = (arr) => arr.slice(0, Math.max(1, Math.floor(arr.length * ratio)));
+            context.facts = trimTo(context.facts);
+            context.preferences = trimTo(context.preferences);
+            context.temporalHabits = trimTo(context.temporalHabits);
+            context.relatedEntities = trimTo(context.relatedEntities);
+            context.tokenEstimate = maxTokens;
+        }
+        return context;
+    }
+    /**
+     * Format the context block as a string for system prompt injection.
+     */
+    formatContextBlock(currentQuery, maxTokens = 600) {
+        const ctx = this.buildContextBlock(currentQuery, maxTokens);
+        const sections = [];
+        if (ctx.temporalHabits.length > 0) {
+            sections.push(`Active habits:\n${ctx.temporalHabits.map(h => `  - ${h}`).join('\n')}`);
+        }
+        if (ctx.preferences.length > 0) {
+            sections.push(`Preferences:\n${ctx.preferences.map(p => `  - ${p}`).join('\n')}`);
+        }
+        if (ctx.facts.length > 0) {
+            sections.push(`Context:\n${ctx.facts.map(f => `  - ${f}`).join('\n')}`);
+        }
+        if (ctx.relatedEntities.length > 0) {
+            sections.push(`People:\n${ctx.relatedEntities.map(r => `  - ${r}`).join('\n')}`);
+        }
+        if (sections.length === 0)
+            return '';
+        return `<knowledge_graph>\n${sections.join('\n')}\n</knowledge_graph>`;
+    }
+    // ──────────────────────────────────────────────────────────────
+    // memU Layer 3: Category Management
+    // ──────────────────────────────────────────────────────────────
+    /**
+     * Auto-categorize entities into topic groups.
+     * Call periodically (e.g., after batch extraction or on session end).
+     */
+    autoCategorizе() {
+        // Group entities by type as categories
+        const typeGroups = new Map();
+        for (const entity of this.entities.values()) {
+            if (entity.type === 'user')
+                continue; // skip meta-entity
+            const key = entity.type;
+            if (!typeGroups.has(key))
+                typeGroups.set(key, []);
+            typeGroups.get(key).push(entity.id);
+        }
+        for (const [type, entityIds] of typeGroups) {
+            const existing = this.categories.get(type);
+            const entities = entityIds.map(id => this.entities.get(id)).filter(Boolean);
+            const summary = entities
+                .sort((a, b) => computeSalience(b.mentions, b.updatedAt) - computeSalience(a.mentions, a.updatedAt))
+                .slice(0, 15)
+                .map(e => `${e.name} (${e.mentions}×, conf:${e.confidence.toFixed(2)})`)
+                .join(', ');
+            if (existing) {
+                existing.entityIds = entityIds;
+                existing.summary = summary;
+                existing.itemCount = entityIds.length;
+                existing.updatedAt = new Date();
+            }
+            else {
+                this.categories.set(type, {
+                    name: type,
+                    summary,
+                    entityIds,
+                    itemCount: entityIds.length,
+                    updatedAt: new Date(),
+                });
+            }
+        }
+        this.markDirty();
+    }
+    /**
+     * Get category summaries (memU tiered retrieval: check categories first).
+     */
+    getCategorySummaries() {
+        return [...this.categories.values()].sort((a, b) => b.itemCount - a.itemCount);
+    }
+    /**
+     * Get entities in a category, ranked by salience score.
+     */
+    getCategoryEntities(categoryName, limit = 10) {
+        const cat = this.categories.get(categoryName);
+        if (!cat)
+            return [];
+        return cat.entityIds
+            .map(id => this.entities.get(id))
+            .filter(Boolean)
+            .map(e => ({
+            entity: e,
+            salience: computeSalience(e.mentions, e.updatedAt),
+        }))
+            .sort((a, b) => b.salience - a.salience)
+            .slice(0, limit);
+    }
+    // ──────────────────────────────────────────────────────────────
+    // memU: Intent-Aware Context Generation
+    // ──────────────────────────────────────────────────────────────
+    /**
+     * Smart context generation with intent routing (memU pattern).
+     * Skips injection for trivial messages. Uses tiered retrieval:
+     * 1. Check if message is trivial → return empty
+     * 2. Check category summaries → if sufficient, return summary-level context
+     * 3. Drill into entities → return full context
+     */
+    formatContextBlockSmart(message, maxTokens = 600) {
+        // Intent routing: skip for trivial messages
+        if (isTrivialMessage(message)) {
+            return '';
+        }
+        return this.formatContextBlock(message, maxTokens);
+    }
+    // ──────────────────────────────────────────────────────────────
+    // memU: Reinforcement-Aware Extraction
+    // ──────────────────────────────────────────────────────────────
+    /**
+     * Extract with content-hash dedup (memU pattern).
+     * Returns number of NEW facts (deduped entries return 0 but still reinforce).
+     */
+    extractFromMessageDeduped(message) {
+        let extracted = 0;
+        let reinforced = 0;
+        const userEntity = this.ensureUserEntity();
+        for (const pattern of EXTRACTION_PATTERNS) {
+            const match = message.match(pattern.pattern);
+            if (!match)
+                continue;
+            const { entity: name, properties } = pattern.extract(match);
+            if (!name || name.length < 2 || name.length > 100)
+                continue;
+            // Content-hash dedup
+            const hash = contentHash(pattern.entityType, name);
+            const isNew = !this.contentHashes.has(hash);
+            this.contentHashes.add(hash);
+            const target = this.addEntity(pattern.entityType, name, properties || {});
+            const temporal = properties?.temporal;
+            this.addRelation(userEntity.id, target.id, pattern.relationType, properties || {}, temporal);
+            if (isNew)
+                extracted++;
+            else
+                reinforced++;
+        }
+        return { extracted, reinforced };
+    }
+    // ──────────────────────────────────────────────────────────────
+    // Decay & Maintenance
+    // ──────────────────────────────────────────────────────────────
+    /**
+     * Decay confidence of old, unused entities and relations.
+     * Call periodically (e.g., daily or on session start).
+     */
+    decay(halfLifeDays = 60) {
+        let decayed = 0;
+        const now = Date.now();
+        for (const entity of this.entities.values()) {
+            const ageDays = (now - entity.updatedAt.getTime()) / (1000 * 60 * 60 * 24);
+            if (ageDays > halfLifeDays / 2) {
+                const factor = Math.exp(-Math.LN2 * ageDays / halfLifeDays);
+                entity.confidence = Math.max(0.1, entity.confidence * factor);
+                decayed++;
+            }
+        }
+        // Remove entities with very low confidence and no recent mentions
+        const toRemove = [];
+        for (const entity of this.entities.values()) {
+            if (entity.confidence < 0.15 && entity.mentions <= 1) {
+                toRemove.push(entity.id);
+            }
+        }
+        for (const id of toRemove) {
+            this.removeEntity(id);
+        }
+        if (decayed > 0 || toRemove.length > 0) {
+            this.markDirty();
+            logger.debug(`KnowledgeGraph: decayed ${decayed} entities, removed ${toRemove.length}`);
+        }
+        return decayed;
+    }
+    // ──────────────────────────────────────────────────────────────
+    // Stats
+    // ──────────────────────────────────────────────────────────────
+    getStats() {
+        const entityTypes = {};
+        const relationTypes = {};
+        let totalConf = 0;
+        for (const e of this.entities.values()) {
+            entityTypes[e.type] = (entityTypes[e.type] || 0) + 1;
+            totalConf += e.confidence;
+        }
+        for (const r of this.relations.values()) {
+            relationTypes[r.type] = (relationTypes[r.type] || 0) + 1;
+        }
+        return {
+            entityCount: this.entities.size,
+            relationCount: this.relations.size,
+            entityTypes,
+            relationTypes,
+            avgConfidence: this.entities.size > 0 ? totalConf / this.entities.size : 0,
+        };
+    }
+    /**
+     * Get all entities, optionally filtered by type.
+     */
+    getAllEntities(type) {
+        const results = [];
+        for (const entity of this.entities.values()) {
+            if (!type || entity.type === type) {
+                results.push(entity);
+            }
+        }
+        return results.sort((a, b) => b.mentions - a.mentions);
+    }
+    /**
+     * Get all relations for a given entity (both directions).
+     */
+    getAllRelations(entityName) {
+        const entity = this.findEntity(entityName);
+        if (!entity)
+            return [];
+        const results = [];
+        const outgoing = this.getRelationsFrom(entity.id);
+        for (const rel of outgoing) {
+            const target = this.entities.get(rel.targetId);
+            if (target)
+                results.push({ relation: rel, source: entity, target });
+        }
+        const incoming = this.getRelationsTo(entity.id);
+        for (const rel of incoming) {
+            const source = this.entities.get(rel.sourceId);
+            if (source)
+                results.push({ relation: rel, source, target: entity });
+        }
+        return results;
+    }
+    /**
+     * Clear all entities and relations.
+     */
+    clear() {
+        this.entities.clear();
+        this.relations.clear();
+        this.adjacency.clear();
+        this.reverseAdjacency.clear();
+        this.idCounter = 0;
+        this.markDirty();
+    }
+    // ──────────────────────────────────────────────────────────────
+    // Persistence (JSON file)
+    // ──────────────────────────────────────────────────────────────
+    async load() {
+        if (this.loaded)
+            return;
+        this.loaded = true;
+        try {
+            if (!existsSync(this.dbPath))
+                return;
+            const { readFile } = await import('fs/promises');
+            const content = await readFile(this.dbPath, 'utf-8');
+            const data = JSON.parse(content);
+            // Restore entities
+            for (const e of data.entities || []) {
+                e.createdAt = new Date(e.createdAt);
+                e.updatedAt = new Date(e.updatedAt);
+                this.entities.set(e.id, e);
+                this.adjacency.set(e.id, new Set());
+                this.reverseAdjacency.set(e.id, new Set());
+                const idNum = parseInt(e.id.split('_')[1] || '0');
+                if (idNum > this.idCounter)
+                    this.idCounter = idNum;
+            }
+            // Restore relations
+            for (const r of data.relations || []) {
+                r.createdAt = new Date(r.createdAt);
+                r.updatedAt = new Date(r.updatedAt);
+                this.relations.set(r.id, r);
+                if (this.adjacency.has(r.sourceId))
+                    this.adjacency.get(r.sourceId).add(r.id);
+                if (this.reverseAdjacency.has(r.targetId))
+                    this.reverseAdjacency.get(r.targetId).add(r.id);
+                const idNum = parseInt(r.id.split('_')[1] || '0');
+                if (idNum > this.idCounter)
+                    this.idCounter = idNum;
+            }
+            // Restore categories (memU Layer 3)
+            for (const c of data.categories || []) {
+                c.updatedAt = new Date(c.updatedAt);
+                this.categories.set(c.name, c);
+            }
+            // Restore content hashes
+            for (const h of data.contentHashes || []) {
+                this.contentHashes.add(h);
+            }
+            logger.debug(`KnowledgeGraph: loaded ${this.entities.size} entities, ${this.relations.size} relations, ${this.categories.size} categories`);
+        }
+        catch (err) {
+            logger.debug(`KnowledgeGraph load failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    async save() {
+        if (!this.dirty)
+            return;
+        if (!shouldWriteProjectRuntimeFiles()) {
+            this.dirty = false;
+            return;
+        }
+        try {
+            const { mkdir, writeFile } = await import('fs/promises');
+            const data = {
+                version: 2,
+                savedAt: new Date().toISOString(),
+                entities: [...this.entities.values()],
+                relations: [...this.relations.values()],
+                categories: [...this.categories.values()],
+                contentHashes: [...this.contentHashes],
+            };
+            await mkdir(dirname(this.dbPath), { recursive: true });
+            await writeFile(this.dbPath, JSON.stringify(data, null, 2), 'utf-8');
+            this.dirty = false;
+            logger.debug(`KnowledgeGraph: saved ${data.entities.length} entities, ${data.relations.length} relations, ${data.categories.length} categories`);
+        }
+        catch (err) {
+            logger.debug(`KnowledgeGraph save failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    markDirty() {
+        this.dirty = true;
+        // Debounced auto-save (5 seconds)
+        if (this.saveTimer)
+            clearTimeout(this.saveTimer);
+        this.saveTimer = setTimeout(() => this.save(), 5000);
+    }
+    /**
+     * Force immediate save (for session end).
+     */
+    async flush() {
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+        await this.save();
+    }
+    dispose() {
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+    }
+}
+// ============================================================================
+// Singleton
+// ============================================================================
+let _graph = null;
+export function getKnowledgeGraph(cwd) {
+    if (!_graph) {
+        _graph = new KnowledgeGraph(cwd);
+    }
+    return _graph;
+}
+export function resetKnowledgeGraph() {
+    if (_graph) {
+        _graph.dispose();
+        _graph = null;
+    }
+}
+//# sourceMappingURL=knowledge-graph.js.map