@cartisien/engram 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,269 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Engram = exports.TemporalQuery = void 0;
+exports.Engram = void 0;
 const crypto_1 = require("crypto");
 /**
- * Temporal query parser for natural language time expressions
- */
-class TemporalQuery {
-    referenceDate;
-    timezoneOffset;
-    constructor(referenceDate = new Date(), timezoneOffset = -referenceDate.getTimezoneOffset()) {
-        this.referenceDate = new Date(referenceDate);
-        this.timezoneOffset = timezoneOffset;
-    }
-    /**
-     * Parse a natural language time expression into a concrete time range
-     *
-     * Supports:
-     * - Relative: 'today', 'yesterday', 'tomorrow'
-     * - Days ago: '3 days ago', 'a week ago', '2 weeks ago'
-     * - Last: 'last monday', 'last week', 'last month'
-     * - This: 'this week', 'this month', 'this year'
-     * - Recent: 'recent', 'lately', 'recently' (last 7 days)
-     * - Between: 'january 15 to january 20', '3/1 to 3/15'
-     */
-    parse(expression) {
-        const normalized = expression.toLowerCase().trim();
-        const now = new Date(this.referenceDate);
-        // Handle 'now', 'recent', 'lately', 'recently' → last 7 days
-        if (/^(now|recent|lately|recently)$/.test(normalized)) {
-            const end = new Date(now);
-            const start = new Date(now);
-            start.setDate(start.getDate() - 7);
-            return { start, end, description: 'last 7 days' };
-        }
-        // Handle 'today'
-        if (normalized === 'today') {
-            const start = this.startOfDay(now);
-            const end = new Date(now);
-            return { start, end, description: 'today' };
-        }
-        // Handle 'yesterday'
-        if (normalized === 'yesterday') {
-            const start = this.startOfDay(now);
-            start.setDate(start.getDate() - 1);
-            const end = this.endOfDay(start);
-            return { start, end, description: 'yesterday' };
-        }
-        // Handle 'tomorrow' (future, but useful for completeness)
-        if (normalized === 'tomorrow') {
-            const start = this.startOfDay(now);
-            start.setDate(start.getDate() + 1);
-            const end = this.endOfDay(start);
-            return { start, end, description: 'tomorrow' };
-        }
-        // Handle 'N days ago' / 'a week ago' / 'N weeks ago'
-        const daysAgoMatch = normalized.match(/^(?:(\d+)|a|one)\s+(day|week|month)s?\s+ago$/);
-        if (daysAgoMatch) {
-            const num = daysAgoMatch[1] ? parseInt(daysAgoMatch[1]) : 1;
-            const unit = daysAgoMatch[2];
-            const start = this.startOfDay(now);
-            const end = this.endOfDay(now);
-            if (unit === 'day') {
-                start.setDate(start.getDate() - num);
-                end.setDate(end.getDate() - num);
-            }
-            else if (unit === 'week') {
-                start.setDate(start.getDate() - (num * 7));
-                end.setDate(end.getDate() - ((num - 1) * 7) - 1);
-            }
-            else if (unit === 'month') {
-                start.setMonth(start.getMonth() - num);
-                start.setDate(1);
-                end.setMonth(end.getMonth() - num + 1);
-                end.setDate(0);
-            }
-            return { start, end, description: `${num} ${unit}${num > 1 ? 's' : ''} ago` };
-        }
-        // Handle 'last N days/weeks/months' (range ending now)
-        const lastNMatch = normalized.match(/^last\s+(?:(\d+)|a|one)\s+(day|week|month)s?$/);
-        if (lastNMatch) {
-            const num = lastNMatch[1] ? parseInt(lastNMatch[1]) : 1;
-            const unit = lastNMatch[2];
-            const start = new Date(now);
-            const end = new Date(now);
-            if (unit === 'day') {
-                start.setDate(start.getDate() - num);
-            }
-            else if (unit === 'week') {
-                start.setDate(start.getDate() - (num * 7));
-            }
-            else if (unit === 'month') {
-                start.setMonth(start.getMonth() - num);
-            }
-            return { start, end, description: `last ${num} ${unit}${num > 1 ? 's' : ''}` };
-        }
-        // Handle 'this week/month/year'
-        const thisMatch = normalized.match(/^this\s+(week|month|year)$/);
-        if (thisMatch) {
-            const unit = thisMatch[1];
-            const start = new Date(now);
-            const end = new Date(now);
-            if (unit === 'week') {
-                const dayOfWeek = start.getDay();
-                start.setDate(start.getDate() - dayOfWeek);
-                start.setHours(0, 0, 0, 0);
-                end.setDate(start.getDate() + 6);
-                end.setHours(23, 59, 59, 999);
-            }
-            else if (unit === 'month') {
-                start.setDate(1);
-                start.setHours(0, 0, 0, 0);
-                end.setMonth(end.getMonth() + 1);
-                end.setDate(0);
-                end.setHours(23, 59, 59, 999);
-            }
-            else if (unit === 'year') {
-                start.setMonth(0, 1);
-                start.setHours(0, 0, 0, 0);
-                end.setMonth(11, 31);
-                end.setHours(23, 59, 59, 999);
-            }
-            return { start, end, description: `this ${unit}` };
-        }
-        // Handle 'last week/month/year' (previous full period)
-        const lastPeriodMatch = normalized.match(/^last\s+(week|month|year)$/);
-        if (lastPeriodMatch) {
-            const unit = lastPeriodMatch[1];
-            const start = new Date(now);
-            const end = new Date(now);
-            if (unit === 'week') {
-                const dayOfWeek = start.getDay();
-                start.setDate(start.getDate() - dayOfWeek - 7);
-                start.setHours(0, 0, 0, 0);
-                end.setDate(start.getDate() + 6);
-                end.setHours(23, 59, 59, 999);
-            }
-            else if (unit === 'month') {
-                start.setMonth(start.getMonth() - 1);
-                start.setDate(1);
-                start.setHours(0, 0, 0, 0);
-                end.setDate(0);
-                end.setHours(23, 59, 59, 999);
-            }
-            else if (unit === 'year') {
-                start.setFullYear(start.getFullYear() - 1);
-                start.setMonth(0, 1);
-                start.setHours(0, 0, 0, 0);
-                end.setMonth(0, 0);
-                end.setHours(23, 59, 59, 999);
-            }
-            return { start, end, description: `last ${unit}` };
-        }
-        // Handle day names: 'monday', 'last monday', 'tuesday', etc.
-        const dayNames = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
-        const dayMatch = normalized.match(/^(?:last\s+)?(sunday|monday|tuesday|wednesday|thursday|friday|saturday)$/);
-        if (dayMatch) {
-            const targetDay = dayNames.indexOf(dayMatch[1]);
-            const isLast = normalized.startsWith('last ');
-            const start = this.startOfDay(now);
-            let daysDiff = start.getDay() - targetDay;
-            if (daysDiff <= 0) {
-                daysDiff += 7;
-            }
-            if (isLast && daysDiff === 0) {
-                daysDiff = 7;
-            }
-            start.setDate(start.getDate() - daysDiff);
-            const end = this.endOfDay(start);
-            return { start, end, description: isLast ? `last ${dayMatch[1]}` : dayMatch[1] };
-        }
-        // Handle date ranges: 'jan 15 to jan 20', '3/1 to 3/15', '2024-01-15 to 2024-01-20'
-        const rangeMatch = normalized.match(/^(.+?)\s+(?:to|through|until|-)\s+(.+)$/);
-        if (rangeMatch) {
-            const startDate = this.parseDate(rangeMatch[1]);
-            const endDate = this.parseDate(rangeMatch[2]);
-            if (startDate && endDate) {
-                return {
-                    start: this.startOfDay(startDate),
-                    end: this.endOfDay(endDate),
-                    description: `${rangeMatch[1]} to ${rangeMatch[2]}`
-                };
-            }
-        }
-        // Try to parse as single date
-        const singleDate = this.parseDate(normalized);
-        if (singleDate) {
-            return {
-                start: this.startOfDay(singleDate),
-                end: this.endOfDay(singleDate),
-                description: normalized
-            };
-        }
-        return null;
-    }
-    parseDate(expr) {
-        const normalized = expr.trim().toLowerCase();
-        const now = new Date(this.referenceDate);
-        // Try various date formats
-        const formats = [
-            // MM/DD or MM/DD/YY or MM/DD/YYYY
-            { regex: /^(\d{1,2})\/(\d{1,2})(?:\/(\d{2,4}))?$/, fn: (m) => {
-                    const month = parseInt(m[1]) - 1;
-                    const day = parseInt(m[2]);
-                    let year = now.getFullYear();
-                    if (m[3]) {
-                        const y = parseInt(m[3]);
-                        year = y < 100 ? (y < 50 ? 2000 + y : 1900 + y) : y;
-                    }
-                    return new Date(year, month, day);
-                } },
-            // Month name + day (e.g., "january 15" or "jan 15")
-            { regex: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+(\d{1,2})(?:,?\s+(\d{4}))?$/i, fn: (m) => {
-                    const months = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
-                    const month = months.indexOf(m[1].toLowerCase().slice(0, 3));
-                    const day = parseInt(m[2]);
-                    let year = now.getFullYear();
-                    if (m[3])
-                        year = parseInt(m[3]);
-                    return new Date(year, month, day);
-                } },
-            // ISO date YYYY-MM-DD
-            { regex: /^(\d{4})-(\d{2})-(\d{2})$/, fn: (m) => {
-                    return new Date(parseInt(m[1]), parseInt(m[2]) - 1, parseInt(m[3]));
-                } }
-        ];
-        for (const format of formats) {
-            const match = normalized.match(format.regex);
-            if (match) {
-                const date = format.fn(match);
-                if (!isNaN(date.getTime()))
-                    return date;
-            }
-        }
-        return null;
-    }
-    startOfDay(date) {
-        const d = new Date(date);
-        d.setHours(0, 0, 0, 0);
-        return d;
-    }
-    endOfDay(date) {
-        const d = new Date(date);
-        d.setHours(23, 59, 59, 999);
-        return d;
-    }
-}
-exports.TemporalQuery = TemporalQuery;
-/**
- * Engram - Persistent memory for AI assistants
+ * Engram - Persistent semantic memory for AI agents
  *
- * A lightweight, SQLite-backed memory system that gives your AI assistants
- * the ability to remember conversations across sessions.
+ * v0.3 adds graph memory — entity relationships extracted from memories
+ * using a local LLM, enabling richer contextual recall.
  *
  * @example
  * ```typescript
  * import { Engram } from '@cartisien/engram';
  *
- * const memory = new Engram({ dbPath: './memory.db' });
+ * const memory = new Engram({ dbPath: './memory.db', graphMemory: true });
  *
- * // Store a memory
- * await memory.remember('user_123', 'Jeff loves Triumph motorcycles', 'user');
- *
- * // Retrieve with temporal query
- * const yesterday = await memory.recallByTime('user_123', 'yesterday');
- * const lastWeek = await memory.recallByTime('user_123', 'last week');
+ * await memory.remember('session_1', 'Jeff is building GovScout in React 19', 'user');
+ * const context = await memory.recall('session_1', 'what is Jeff building?', 5);
+ * const graph = await memory.graph('session_1', 'GovScout');
+ * // → { entity: 'GovScout', relationships: [{ relation: 'built_with', target: 'React 19' }], ... }
  * ```
  */
 class Engram {
@@ -271,9 +25,19 @@ class Engram {
     maxContextLength;
     dbPath;
     initialized = false;
+    embeddingUrl;
+    embeddingModel;
+    semanticSearch;
+    graphMemory;
+    graphModel;
     constructor(config = {}) {
         this.dbPath = config.dbPath || ':memory:';
         this.maxContextLength = config.maxContextLength || 4000;
+        this.embeddingUrl = config.embeddingUrl || 'http://192.168.68.73:11434';
+        this.embeddingModel = config.embeddingModel || 'nomic-embed-text';
+        this.semanticSearch = config.semanticSearch !== false;
+        this.graphMemory = config.graphMemory === true;
+        this.graphModel = config.graphModel || 'qwen2.5:32b';
     }
     async init() {
         if (this.initialized)
@@ -284,7 +48,7 @@ class Engram {
             filename: this.dbPath,
             driver: sqlite3.Database
         });
-        // Create memories table
+        // Memories table
         await this.db.exec(`
       CREATE TABLE IF NOT EXISTS memories (
         id TEXT PRIMARY KEY,
@@ -293,21 +57,146 @@ class Engram {
         role TEXT CHECK(role IN ('user', 'assistant', 'system')),
         timestamp INTEGER NOT NULL,
         metadata TEXT,
-        content_hash TEXT NOT NULL
+        content_hash TEXT NOT NULL,
+        embedding TEXT
       );
     `);
-        // Create index for fast session lookups
+        // Add embedding column if upgrading from v0.1
+        try {
+            await this.db.exec(`ALTER TABLE memories ADD COLUMN embedding TEXT`);
+        }
+        catch { /* already exists */ }
+        // v0.3: Graph tables
         await this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_session_timestamp 
-      ON memories(session_id, timestamp DESC);
+      CREATE TABLE IF NOT EXISTS graph_nodes (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        entity TEXT NOT NULL,
+        type TEXT,
+        created_at INTEGER NOT NULL
+      );
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_node_entity
+        ON graph_nodes(session_id, entity);
+    `);
+        await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS graph_edges (
+        id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        from_entity TEXT NOT NULL,
+        relation TEXT NOT NULL,
+        to_entity TEXT NOT NULL,
+        confidence REAL DEFAULT 1.0,
+        memory_id TEXT,
+        created_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_edge_from
+        ON graph_edges(session_id, from_entity);
+      CREATE INDEX IF NOT EXISTS idx_edge_to
+        ON graph_edges(session_id, to_entity);
     `);
-        // Create index for content search
         await this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_content 
-      ON memories(content);
+      CREATE INDEX IF NOT EXISTS idx_session_timestamp
+      ON memories(session_id, timestamp DESC);
     `);
         this.initialized = true;
     }
+    /**
+     * Fetch embedding vector from Ollama
+     */
+    async embed(text) {
+        try {
+            const response = await fetch(`${this.embeddingUrl}/api/embeddings`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ model: this.embeddingModel, prompt: text }),
+                signal: AbortSignal.timeout(5000)
+            });
+            if (!response.ok)
+                return null;
+            const data = await response.json();
+            return data.embedding ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Extract entity-relationship triples from text using a local LLM
+     */
+    async extractGraph(text) {
+        const prompt = `Extract entity-relationship triples from this text. Return ONLY a JSON array of objects with keys: "from", "relation", "to". Be concise. Max 5 triples. If nothing to extract, return [].
+
+Text: "${text}"
+
+JSON array:`;
+        try {
+            const response = await fetch(`${this.embeddingUrl}/api/generate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: this.graphModel,
+                    prompt,
+                    stream: false,
+                    options: { temperature: 0, num_predict: 200 }
+                }),
+                signal: AbortSignal.timeout(15000)
+            });
+            if (!response.ok)
+                return [];
+            const data = await response.json();
+            const raw = data.response.trim();
+            // Extract JSON array from response
+            const match = raw.match(/\[[\s\S]*\]/);
+            if (!match)
+                return [];
+            const triples = JSON.parse(match[0]);
+            return triples
+                .filter(t => t.from && t.relation && t.to)
+                .map(t => ({
+                from: t.from.toLowerCase().trim(),
+                relation: t.relation.toLowerCase().trim(),
+                to: t.to.toLowerCase().trim(),
+                confidence: 0.9
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Upsert a graph node
+     */
+    async upsertNode(sessionId, entity, type) {
+        const id = (0, crypto_1.createHash)('sha256').update(`${sessionId}:${entity}`).digest('hex').slice(0, 16);
+        await this.db.run(`INSERT OR IGNORE INTO graph_nodes (id, session_id, entity, type, created_at)
+       VALUES (?, ?, ?, ?, ?)`, [id, sessionId, entity, type || null, Date.now()]);
+    }
+    /**
+     * Store a graph edge
+     */
+    async storeEdge(sessionId, edge, memoryId) {
+        const id = (0, crypto_1.createHash)('sha256')
+            .update(`${sessionId}:${edge.from}:${edge.relation}:${edge.to}`)
+            .digest('hex').slice(0, 16);
+        await this.upsertNode(sessionId, edge.from);
+        await this.upsertNode(sessionId, edge.to);
+        await this.db.run(`INSERT OR REPLACE INTO graph_edges
+       (id, session_id, from_entity, relation, to_entity, confidence, memory_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [id, sessionId, edge.from, edge.relation, edge.to, edge.confidence ?? 1.0, memoryId, Date.now()]);
+    }
+    /**
+     * Cosine similarity between two vectors
+     */
+    cosineSimilarity(a, b) {
+        let dot = 0, magA = 0, magB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dot += a[i] * b[i];
+            magA += a[i] * a[i];
+            magB += b[i] * b[i];
+        }
+        const denom = Math.sqrt(magA) * Math.sqrt(magB);
+        return denom === 0 ? 0 : dot / denom;
+    }
     /**
      * Store a memory entry
      */
@@ -315,59 +204,40 @@ class Engram {
         await this.init();
         const id = (0, crypto_1.createHash)('sha256')
             .update(`${sessionId}:${content}:${Date.now()}`)
-            .digest('hex')
-            .slice(0, 16);
-        const contentHash = (0, crypto_1.createHash)('sha256')
-            .update(content)
-            .digest('hex')
-            .slice(0, 16);
+            .digest('hex').slice(0, 16);
+        const contentHash = (0, crypto_1.createHash)('sha256').update(content).digest('hex').slice(0, 16);
+        const truncated = content.slice(0, this.maxContextLength);
+        // Fetch embedding
+        let embeddingJson = null;
+        if (this.semanticSearch) {
+            const vector = await this.embed(truncated);
+            if (vector)
+                embeddingJson = JSON.stringify(vector);
+        }
         const entry = {
-            id,
-            sessionId,
-            content: content.slice(0, this.maxContextLength),
-            role,
-            timestamp: new Date(),
-            metadata
+            id, sessionId, content: truncated, role,
+            timestamp: new Date(), metadata
         };
-        await this.db.run(`INSERT INTO memories (id, session_id, content, role, timestamp, metadata, content_hash)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`, [
-            entry.id,
-            entry.sessionId,
-            entry.content,
-            entry.role,
-            entry.timestamp.getTime(),
-            metadata ? JSON.stringify(metadata) : null,
-            contentHash
-        ]);
+        await this.db.run(`INSERT INTO memories (id, session_id, content, role, timestamp, metadata, content_hash, embedding)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [id, sessionId, truncated, role, entry.timestamp.getTime(),
+            metadata ? JSON.stringify(metadata) : null, contentHash, embeddingJson]);
+        // v0.3: Extract graph relationships
+        if (this.graphMemory) {
+            const edges = await this.extractGraph(truncated);
+            for (const edge of edges) {
+                await this.storeEdge(sessionId, edge, id);
+            }
+        }
         return entry;
     }
     /**
-     * Recall memories for a session
-     *
-     * Supports temporal queries via options.temporalQuery:
-     * - 'yesterday', 'today', 'tomorrow'
-     * - '3 days ago', 'a week ago', '2 weeks ago'
-     * - 'last monday', 'last week', 'last month'
-     * - 'this week', 'this month'
-     * - 'last 3 days', 'last week'
-     * - 'january 15', '3/15', '2024-01-15'
-     * - 'jan 15 to jan 20', '3/1 to 3/15'
+     * Recall memories with optional graph traversal
      */
     async recall(sessionId, query, limit = 10, options = {}) {
         await this.init();
-        // Handle temporal query if provided
-        if (options.temporalQuery) {
-            const temporal = new TemporalQuery(new Date(), options.timezoneOffset);
-            const range = temporal.parse(options.temporalQuery);
-            if (range) {
-                options.after = range.start;
-                options.before = range.end;
-            }
-        }
         let sql = `
-      SELECT id, session_id, content, role, timestamp, metadata
-      FROM memories
-      WHERE session_id = ?
+      SELECT id, session_id, content, role, timestamp, metadata, embedding
+      FROM memories WHERE session_id = ?
     `;
         const params = [sessionId];
         if (options.role) {
@@ -382,7 +252,43 @@ class Engram {
             sql += ` AND timestamp <= ?`;
             params.push(options.before.getTime());
         }
-        // Simple keyword matching if query provided
+        // Semantic search
+        if (query && query.trim() && this.semanticSearch) {
+            const queryVector = await this.embed(query);
+            if (queryVector) {
+                sql += ` ORDER BY timestamp DESC`;
+                const rows = await this.db.all(sql, params);
+                const scored = rows
+                    .map((row) => {
+                    let similarity = 0;
+                    if (row.embedding) {
+                        try {
+                            const vec = JSON.parse(row.embedding);
+                            similarity = this.cosineSimilarity(queryVector, vec);
+                        }
+                        catch { /* skip */ }
+                    }
+                    return { row, similarity };
+                })
+                    .sort((a, b) => b.similarity - a.similarity)
+                    .slice(0, limit);
+                const results = scored.map(({ row, similarity }) => ({
+                    id: row.id,
+                    sessionId: row.session_id,
+                    content: row.content,
+                    role: row.role,
+                    timestamp: new Date(row.timestamp),
+                    metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+                    similarity
+                }));
+                // v0.3: Augment with graph-connected memories
+                if (this.graphMemory && options.includeGraph !== false) {
+                    return this.augmentWithGraph(sessionId, results, limit);
+                }
+                return results;
+            }
+        }
+        // Keyword fallback
         if (query && query.trim()) {
             const keywords = query.toLowerCase().split(/\s+/).filter(k => k.length > 2);
             if (keywords.length > 0) {
@@ -403,104 +309,97 @@ class Engram {
         }));
     }
     /**
-     * Recall memories by natural language time expression
-     *
-     * @example
-     * ```typescript
-     * // Get yesterday's memories
-     * const yesterday = await memory.recallByTime('session_123', 'yesterday');
-     *
-     * // Get last week's memories
-     * const lastWeek = await memory.recallByTime('session_123', 'last week');
-     *
-     * // Get memories from 3 days ago
-     * const threeDaysAgo = await memory.recallByTime('session_123', '3 days ago');
-     * ```
+     * Augment recall results with graph-connected memories
      */
-    async recallByTime(sessionId, temporalQuery, query, limit = 50, options = {}) {
-        const temporal = new TemporalQuery(new Date(), options.timezoneOffset);
-        const range = temporal.parse(temporalQuery);
-        if (!range) {
-            throw new Error(`Unable to parse temporal query: "${temporalQuery}"`);
+    async augmentWithGraph(sessionId, results, limit) {
+        // Collect memory IDs that appear in graph edges
+        const seenIds = new Set(results.map(r => r.id));
+        const graphMemoryIds = new Set();
+        for (const result of results.slice(0, 3)) { // Only expand top 3
+            const edges = await this.db.all(`SELECT memory_id FROM graph_edges WHERE session_id = ? AND memory_id IS NOT NULL
+         AND (from_entity IN (
+           SELECT from_entity FROM graph_edges WHERE memory_id = ?
+           UNION SELECT to_entity FROM graph_edges WHERE memory_id = ?
+         ))
+         LIMIT 5`, [sessionId, result.id, result.id]);
+            for (const edge of edges) {
+                if (edge.memory_id && !seenIds.has(edge.memory_id)) {
+                    graphMemoryIds.add(edge.memory_id);
+                }
+            }
         }
-        const entries = await this.recall(sessionId, query, limit, {
-            ...options,
-            after: range.start,
-            before: range.end
-        });
-        return { entries, range };
-    }
-    /**
-     * Get memories from the last N days
-     */
-    async recallRecent(sessionId, days = 7, query, limit = 50, options = {}) {
-        const since = new Date();
-        since.setDate(since.getDate() - days);
-        since.setHours(0, 0, 0, 0);
-        const entries = await this.recall(sessionId, query, limit, {
-            ...options,
-            after: since
-        });
-        return { entries, days, since };
-    }
-    /**
-     * Get memories since a specific date
-     */
-    async recallSince(sessionId, since, query, limit = 50, options = {}) {
-        const entries = await this.recall(sessionId, query, limit, {
-            ...options,
-            after: since
-        });
-        return { entries, since, count: entries.length };
-    }
-    /**
-     * Get memories between two dates
-     */
-    async recallBetween(sessionId, start, end, query, limit = 50, options = {}) {
-        const entries = await this.recall(sessionId, query, limit, {
-            ...options,
-            after: start,
-            before: end
-        });
-        return { entries, start, end, count: entries.length };
+        if (graphMemoryIds.size === 0)
+            return results;
+        // Fetch connected memories
+        const placeholders = Array.from(graphMemoryIds).map(() => '?').join(',');
+        const connectedRows = await this.db.all(`SELECT id, session_id, content, role, timestamp, metadata FROM memories
+       WHERE id IN (${placeholders})`, Array.from(graphMemoryIds));
+        const connected = connectedRows.map((row) => ({
+            id: row.id,
+            sessionId: row.session_id,
+            content: row.content,
+            role: row.role,
+            timestamp: new Date(row.timestamp),
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+            similarity: 0 // Graph-connected, not vector-matched
+        }));
+        return [...results, ...connected].slice(0, limit);
     }
     /**
-     * Get a daily summary of memories
-     *
-     * Returns memories grouped by day, useful for "what happened each day" views
+     * v0.3: Query the knowledge graph for an entity
      */
-    async dailySummary(sessionId, days = 7) {
+    async graph(sessionId, entity) {
         await this.init();
-        const since = new Date();
-        since.setDate(since.getDate() - days);
-        since.setHours(0, 0, 0, 0);
-        const entries = await this.recall(sessionId, undefined, 1000, { after: since });
-        // Group by day
-        const grouped = new Map();
-        for (const entry of entries) {
-            const dateKey = entry.timestamp.toISOString().split('T')[0];
-            if (!grouped.has(dateKey)) {
-                grouped.set(dateKey, []);
-            }
-            grouped.get(dateKey).push(entry);
+        const ent = entity.toLowerCase().trim();
+        // Outgoing edges
+        const outgoing = await this.db.all(`SELECT relation, to_entity, confidence, memory_id FROM graph_edges
+       WHERE session_id = ? AND from_entity = ?`, [sessionId, ent]);
+        // Incoming edges
+        const incoming = await this.db.all(`SELECT relation, from_entity, confidence, memory_id FROM graph_edges
+       WHERE session_id = ? AND to_entity = ?`, [sessionId, ent]);
+        const relationships = [
+            ...outgoing.map((e) => ({
+                type: 'outgoing',
+                relation: e.relation,
+                target: e.to_entity,
+                confidence: e.confidence
+            })),
+            ...incoming.map((e) => ({
+                type: 'incoming',
+                relation: e.relation,
+                target: e.from_entity,
+                confidence: e.confidence
+            }))
+        ];
+        // Get source memories
+        const memoryIds = [
+            ...outgoing.map((e) => e.memory_id),
+            ...incoming.map((e) => e.memory_id)
+        ].filter(Boolean);
+        let relatedMemories = [];
+        if (memoryIds.length > 0) {
+            const placeholders = memoryIds.map(() => '?').join(',');
+            const rows = await this.db.all(`SELECT id, session_id, content, role, timestamp, metadata
+         FROM memories WHERE id IN (${placeholders})`, memoryIds);
+            relatedMemories = rows.map((row) => ({
+                id: row.id,
+                sessionId: row.session_id,
+                content: row.content,
+                role: row.role,
+                timestamp: new Date(row.timestamp),
+                metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+            }));
         }
-        // Convert to sorted array
-        return Array.from(grouped.entries())
-            .sort((a, b) => b[0].localeCompare(a[0])) // Descending date order
-            .map(([dateKey, dayEntries]) => ({
-            date: new Date(dateKey),
-            entries: dayEntries.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime()),
-            count: dayEntries.length
-        }));
+        return { entity: ent, relationships, relatedMemories };
     }
     /**
-     * Get recent conversation history for a session
+     * Get recent conversation history
      */
     async history(sessionId, limit = 20) {
         return this.recall(sessionId, undefined, limit, {});
     }
     /**
-     * Forget (delete) memories
+     * Delete memories
      */
     async forget(sessionId, options) {
         await this.init();
@@ -510,10 +409,6 @@ class Engram {
         }
         let sql = 'DELETE FROM memories WHERE session_id = ?';
         const params = [sessionId];
-        if (options?.after) {
-            sql += ' AND timestamp >= ?';
-            params.push(options.after.getTime());
-        }
         if (options?.before) {
             sql += ' AND timestamp < ?';
             params.push(options.before.getTime());
@@ -522,59 +417,31 @@ class Engram {
         return result.changes || 0;
     }
     /**
-     * Get memory statistics for a session
+     * Memory statistics
      */
     async stats(sessionId) {
         await this.init();
         const totalRow = await this.db.get('SELECT COUNT(*) as count FROM memories WHERE session_id = ?', [sessionId]);
-        const total = totalRow?.count || 0;
         const roleRows = await this.db.all('SELECT role, COUNT(*) as count FROM memories WHERE session_id = ? GROUP BY role', [sessionId]);
         const byRole = {};
-        roleRows.forEach((row) => {
-            byRole[row.role] = row.count;
-        });
+        roleRows.forEach((row) => { byRole[row.role] = row.count; });
         const range = await this.db.get('SELECT MIN(timestamp) as oldest, MAX(timestamp) as newest FROM memories WHERE session_id = ?', [sessionId]);
-        return {
-            total,
+        const embRow = await this.db.get('SELECT COUNT(*) as count FROM memories WHERE session_id = ? AND embedding IS NOT NULL', [sessionId]);
+        const stats = {
+            total: totalRow?.count || 0,
             byRole,
             oldest: range?.oldest ? new Date(range.oldest) : null,
-            newest: range?.newest ? new Date(range.newest) : null
+            newest: range?.newest ? new Date(range.newest) : null,
+            withEmbeddings: embRow?.count || 0
         };
-    }
-    /**
-     * Get temporal statistics for a session
-     *
-     * Returns memory counts grouped by day, useful for activity visualization
-     */
-    async temporalStats(sessionId, days = 30) {
-        await this.init();
-        const since = new Date();
-        since.setDate(since.getDate() - days);
-        const rows = await this.db.all(`SELECT 
-        date(timestamp / 1000, 'unixepoch', 'localtime') as date,
-        role,
-        COUNT(*) as count
-      FROM memories 
-      WHERE session_id = ? AND timestamp >= ?
-      GROUP BY date, role
-      ORDER BY date DESC`, [sessionId, since.getTime()]);
-        // Aggregate by date
-        const byDate = new Map();
-        for (const row of rows) {
-            if (!byDate.has(row.date)) {
-                byDate.set(row.date, { count: 0, byRole: {} });
-            }
-            const day = byDate.get(row.date);
-            day.count += row.count;
-            day.byRole[row.role] = row.count;
+        if (this.graphMemory) {
+            const nodeRow = await this.db.get('SELECT COUNT(*) as count FROM graph_nodes WHERE session_id = ?', [sessionId]);
+            const edgeRow = await this.db.get('SELECT COUNT(*) as count FROM graph_edges WHERE session_id = ?', [sessionId]);
+            stats.graphNodes = nodeRow?.count || 0;
+            stats.graphEdges = edgeRow?.count || 0;
         }
-        return Array.from(byDate.entries())
-            .sort((a, b) => b[0].localeCompare(a[0]))
-            .map(([date, stats]) => ({ date, ...stats }));
+        return stats;
     }
-    /**
-     * Close the database connection
-     */
     async close() {
         if (this.db) {
             await this.db.close();