@vheins/local-memory-mcp 0.1.33 → 0.1.35

package/dist/storage/sqlite.js

@@ -26,10 +26,6 @@ function resolveDbPath() {
         return path.join(cwdStorage, "memory.db");
     }
     const projectRootStorage = path.join(__dirname, "../../storage");
-    // If we are in a production/installed environment and none of the above exist,
-    // we SHOULD use the ~/.config path as the default location to create new DBs,
-    // instead of potentially writing into a read-only node_modules/dist folder.
-    // But for backward compatibility with existing project-root storage, we check it last.
     if (fs.existsSync(projectRootStorage)) {
         return path.join(projectRootStorage, "memory.db");
     }
@@ -45,6 +41,9 @@ export class SQLiteStore {
             fs.mkdirSync(dbDir, { recursive: true });
         }
         this.db = new Database(finalPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("synchronous = NORMAL");
+        this.db.pragma("busy_timeout = 5000");
         this.migrate();
     }
     getDbPath() {
@@ -101,9 +100,7 @@ export class SQLiteStore {
         try {
             this.db.exec(`ALTER TABLE memories ADD COLUMN title TEXT`);
         }
-        catch (e) {
-            // Column already exists, ignore
-        }
+        catch (e) { }
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS memories_archive (
         id TEXT PRIMARY KEY,
@@ -135,171 +132,177 @@ export class SQLiteStore {
       CREATE INDEX IF NOT EXISTS idx_action_log_repo ON action_log(repo);
       CREATE INDEX IF NOT EXISTS idx_action_log_created_at ON action_log(created_at);
     `);
-        // Sub-task 2.1: Use PRAGMA table_info to safely add columns
+        // Add missing columns safely
         const existingColumns = this.db.prepare("PRAGMA table_info(memories)").all().map((col) => col.name);
         const columnsToAdd = [
-            { name: "hit_count", definition: "ALTER TABLE memories ADD COLUMN hit_count INTEGER NOT NULL DEFAULT 0" },
-            { name: "recall_count", definition: "ALTER TABLE memories ADD COLUMN recall_count INTEGER NOT NULL DEFAULT 0" },
-            { name: "last_used_at", definition: "ALTER TABLE memories ADD COLUMN last_used_at TEXT" },
-            { name: "expires_at", definition: "ALTER TABLE memories ADD COLUMN expires_at TEXT" },
+            { name: "hit_count", table: "memories", definition: "ALTER TABLE memories ADD COLUMN hit_count INTEGER NOT NULL DEFAULT 0" },
+            { name: "recall_count", table: "memories", definition: "ALTER TABLE memories ADD COLUMN recall_count INTEGER NOT NULL DEFAULT 0" },
+            { name: "last_used_at", table: "memories", definition: "ALTER TABLE memories ADD COLUMN last_used_at TEXT" },
+            { name: "expires_at", table: "memories", definition: "ALTER TABLE memories ADD COLUMN expires_at TEXT" },
+            { name: "supersedes", table: "memories", definition: "ALTER TABLE memories ADD COLUMN supersedes TEXT" },
+            { name: "status", table: "memories", definition: "ALTER TABLE memories ADD COLUMN status TEXT NOT NULL DEFAULT 'active'" },
+            { name: "is_global", table: "memories", definition: "ALTER TABLE memories ADD COLUMN is_global INTEGER NOT NULL DEFAULT 0" },
+            { name: "tags", table: "memories", definition: "ALTER TABLE memories ADD COLUMN tags TEXT" },
+            { name: "vector_version", table: "memory_vectors", definition: "ALTER TABLE memory_vectors ADD COLUMN vector_version INTEGER NOT NULL DEFAULT 1" },
         ];
         for (const col of columnsToAdd) {
-            if (!existingColumns.includes(col.name)) {
+            const existingTableColumns = this.db.prepare(`PRAGMA table_info(${col.table})`).all().map((c) => c.name);
+            if (!existingTableColumns.includes(col.name)) {
                 this.db.exec(col.definition);
             }
         }
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_memories_status ON memories(status);
+      CREATE INDEX IF NOT EXISTS idx_memories_supersedes ON memories(supersedes);
+      CREATE INDEX IF NOT EXISTS idx_memories_is_global ON memories(is_global);
+    `);
     }
     insert(entry) {
-        if (!entry.title) {
-            throw new Error("Title is required for memory entry");
-        }
         const stmt = this.db.prepare(`
       INSERT INTO memories (
         id, repo, type, title, content, importance, folder, language,
-        created_at, updated_at, hit_count, recall_count, last_used_at, expires_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, NULL, ?)
+        created_at, updated_at, hit_count, recall_count, last_used_at, expires_at,
+        supersedes, status, is_global, tags
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, NULL, ?, ?, ?, ?, ?)
     `);
-        stmt.run(entry.id, entry.scope.repo, entry.type, entry.title, entry.content, entry.importance, entry.scope.folder || null, entry.scope.language || null, entry.created_at, entry.updated_at, entry.expires_at ?? null);
+        stmt.run(entry.id, entry.scope.repo, entry.type, entry.title || null, entry.content, entry.importance, entry.scope.folder || null, entry.scope.language || null, entry.created_at, entry.updated_at, entry.expires_at ?? null, entry.supersedes ?? null, entry.status || "active", entry.is_global ? 1 : 0, entry.tags ? JSON.stringify(entry.tags) : null);
     }
     update(id, updates) {
         const fields = [];
         const values = [];
-        if (updates.title !== undefined) {
-            if (updates.title.length < 3) {
-                throw new Error("Title must be at least 3 characters");
+        Object.keys(updates).forEach(key => {
+            if (updates[key] !== undefined) {
+                if (key === 'tags') {
+                    fields.push(`tags = ?`);
+                    values.push(JSON.stringify(updates[key]));
+                }
+                else if (key === 'is_global') {
+                    fields.push(`is_global = ?`);
+                    values.push(updates[key] ? 1 : 0);
+                }
+                else {
+                    fields.push(`${key} = ?`);
+                    values.push(updates[key]);
+                }
             }
-            fields.push("title = ?");
-            values.push(updates.title);
-        }
-        if (updates.content !== undefined) {
-            fields.push("content = ?");
-            values.push(updates.content);
-        }
-        if (updates.importance !== undefined) {
-            fields.push("importance = ?");
-            values.push(updates.importance);
-        }
-        if (fields.length === 0) {
-            return; // Nothing to update
-        }
+        });
+        if (fields.length === 0)
+            return;
         fields.push("updated_at = ?");
         values.push(new Date().toISOString());
         values.push(id);
-        const stmt = this.db.prepare(`
-      UPDATE memories
-      SET ${fields.join(", ")}
-      WHERE id = ?
-    `);
+        const stmt = this.db.prepare(`UPDATE memories SET ${fields.join(", ")} WHERE id = ?`);
         stmt.run(...values);
     }
-    // Sub-task 2.4: Exclude expired memories from searchByRepo
+    getById(id) {
+        const row = this.db.prepare("SELECT * FROM memories WHERE id = ?").get(id);
+        return row ? this.rowToMemoryEntry(row) : null;
+    }
+    getByIdWithStats(id) {
+        const row = this.db.prepare(`
+      SELECT *, CASE WHEN hit_count > 0 THEN CAST(recall_count AS REAL) / hit_count ELSE 0 END AS recall_rate
+      FROM memories WHERE id = ?
+    `).get(id);
+        return row ? { ...this.rowToMemoryEntry(row), recall_rate: row.recall_rate ?? 0 } : null;
+    }
     searchByRepo(repo, options = {}) {
-        let query = `SELECT * FROM memories WHERE repo = ?
-      AND (expires_at IS NULL OR expires_at > datetime('now'))`;
+        let where = ["(repo = ? OR is_global = 1)"];
         const params = [repo];
-        if (options.types && options.types.length > 0) {
-            const placeholders = options.types.map(() => "?").join(", ");
-            query += ` AND type IN (${placeholders})`;
+        if (options.tags?.length) {
+            const tagConditions = options.tags.map(() => "tags LIKE ?").join(" OR ");
+            where.push(`(${tagConditions})`);
+            options.tags.forEach((tag) => params.push(`%${tag}%`));
+        }
+        let query = `SELECT * FROM memories WHERE ${where.join(" AND ")} AND (expires_at IS NULL OR expires_at > datetime('now'))`;
+        if (!options.includeArchived)
+            query += " AND status = 'active'";
+        if (options.types?.length) {
+            query += ` AND type IN (${options.types.map(() => "?").join(",")})`;
             params.push(...options.types);
         }
-        if (options.minImportance !== undefined) {
+        if (options.minImportance) {
             query += " AND importance >= ?";
             params.push(options.minImportance);
         }
-        query += " ORDER BY importance DESC, created_at DESC";
-        if (options.limit !== undefined) {
+        query += " ORDER BY CASE WHEN repo = ? THEN 0 ELSE 1 END, importance DESC, created_at DESC";
+        params.push(repo);
+        if (options.limit) {
             query += " LIMIT ?";
             params.push(options.limit);
         }
-        const stmt = this.db.prepare(query);
-        const rows = stmt.all(...params);
-        return rows.map((row) => this.rowToMemoryEntry(row));
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map(r => this.rowToMemoryEntry(r));
     }
-    getById(id) {
-        const stmt = this.db.prepare("SELECT * FROM memories WHERE id = ?");
-        const row = stmt.get(id);
-        if (!row)
-            return null;
-        return this.rowToMemoryEntry(row);
+    searchBySimilarity(query, repo, limit = 10, includeArchived = false, currentTags = []) {
+        const queryVector = this.computeVector(query);
+        const now = new Date();
+        let where = ["(repo = ? OR is_global = 1)"];
+        const params = [repo];
+        if (currentTags.length > 0) {
+            const tagConditions = currentTags.map(() => "tags LIKE ?").join(" OR ");
+            where.push(`(${tagConditions})`);
+            currentTags.forEach(tag => params.push(`%${tag}%`));
+        }
+        let sql = `SELECT * FROM memories WHERE (${where.join(" OR ")}) AND (expires_at IS NULL OR expires_at > ?)`;
+        if (!includeArchived)
+            sql += " AND status = 'active'";
+        sql += ` ORDER BY CASE WHEN repo = ? THEN 0 ELSE 1 END, importance DESC, created_at DESC LIMIT 100`;
+        let candidates = this.db.prepare(sql).all(...params, now.toISOString(), repo);
+        // Ensure we have at least some candidates for re-ranking
+        if (candidates.length < 5) {
+            const recentSql = `SELECT * FROM memories WHERE (${where.join(" OR ")}) AND status = 'active' AND (expires_at IS NULL OR expires_at > ?) ORDER BY created_at DESC LIMIT 10`;
+            const recent = this.db.prepare(recentSql).all(...params, now.toISOString());
+            for (const r of recent) {
+                if (!candidates.find(c => c.id === r.id))
+                    candidates.push(r);
+            }
+        }
+        return candidates.map(row => {
+            const memory = this.rowToMemoryEntry(row);
+            // Strict validity check
+            const isExpired = row.expires_at && new Date(row.expires_at) <= now;
+            const isArchived = row.status === 'archived' && !includeArchived;
+            if (isExpired || isArchived) {
+                return { ...memory, similarity: 0 };
+            }
+            const similarity = this.cosineSimilarity(queryVector, this.computeVector(memory.content));
+            let score = similarity;
+            if (!score) {
+                score = 0.16; // Baseline for active candidates
+            }
+            if (row.repo === repo)
+                score += 0.1;
+            return { ...memory, similarity: score };
+        }).filter(r => r.similarity > 0)
+            .sort((a, b) => b.similarity - a.similarity)
+            .slice(0, limit);
     }
-    getByIdWithStats(id) {
-        const stmt = this.db.prepare(`
-      SELECT *,
-        CASE WHEN hit_count > 0 THEN CAST(recall_count AS REAL) / hit_count ELSE 0 END AS recall_rate
-      FROM memories
-      WHERE id = ?
-    `);
-        const row = stmt.get(id);
-        if (!row)
-            return null;
-        return {
-            ...this.rowToMemoryEntry(row),
-            recall_rate: row.recall_rate ?? 0,
-        };
+    archiveExpiredMemories(force = false) {
+        if (process.env.ENABLE_AUTO_ARCHIVE !== "true" && !force)
+            return 0;
+        const now = new Date().toISOString();
+        const result = this.db.prepare(`
+      UPDATE memories SET status = 'archived', updated_at = ? 
+      WHERE expires_at IS NOT NULL AND expires_at <= ? AND status = 'active'
+    `).run(now, now);
+        return result.changes;
+    }
+    archiveLowScoreMemories(force = false) {
+        if (process.env.ENABLE_AUTO_ARCHIVE !== "true" && !force)
+            return 0;
+        const result = this.db.prepare(`
+      UPDATE memories SET status = 'archived', updated_at = ? 
+      WHERE status = 'active' AND (
+        (julianday('now') - julianday(COALESCE(last_used_at, created_at)) > 90 AND importance < 3)
+        OR (hit_count > 10 AND recall_count = 0)
+      )
+    `).run(new Date().toISOString());
+        return result.changes;
     }
     listRecent(limit = 10) {
-        const stmt = this.db.prepare(`
-      SELECT id, type, repo
-      FROM memories
-      ORDER BY created_at DESC
-      LIMIT ?
-    `);
+        const stmt = this.db.prepare("SELECT id, type, repo FROM memories ORDER BY created_at DESC LIMIT ?");
         return stmt.all(limit);
     }
-    getSummary(repo) {
-        const stmt = this.db.prepare("SELECT summary, updated_at FROM memory_summary WHERE repo = ?");
-        return stmt.get(repo);
-    }
-    upsertSummary(repo, summary) {
-        const stmt = this.db.prepare(`
-      INSERT INTO memory_summary (repo, summary, updated_at)
-      VALUES (?, ?, ?)
-      ON CONFLICT(repo) DO UPDATE SET
-        summary = excluded.summary,
-        updated_at = excluded.updated_at
-    `);
-        stmt.run(repo, summary, new Date().toISOString());
-    }
-    delete(id) {
-        const stmt = this.db.prepare("DELETE FROM memories WHERE id = ?");
-        stmt.run(id);
-    }
-    // Sub-task 2.5: Renamed from listAllRepos to listRepos
-    listRepos() {
-        const stmt = this.db.prepare("SELECT DISTINCT repo FROM memories ORDER BY repo");
-        const rows = stmt.all();
-        return rows.map((row) => row.repo);
-    }
-    listRepoNavigation() {
-        const stmt = this.db.prepare(`
-      SELECT
-        repo,
-        COUNT(*) AS memory_count,
-        MAX(COALESCE(updated_at, created_at)) AS last_updated_at
-      FROM memories
-      GROUP BY repo
-      ORDER BY last_updated_at DESC, repo ASC
-    `);
-        return stmt.all();
-    }
-    incrementHitCount(id) {
-        const stmt = this.db.prepare(`
-      UPDATE memories
-      SET hit_count = hit_count + 1,
-          last_used_at = ?
-      WHERE id = ?
-    `);
-        stmt.run(new Date().toISOString(), id);
-    }
-    incrementRecallCount(id) {
-        const stmt = this.db.prepare(`
-      UPDATE memories
-      SET recall_count = recall_count + 1,
-          last_used_at = ?
-      WHERE id = ?
-    `);
-        stmt.run(new Date().toISOString(), id);
-    }
     getStats(repo) {
         let query = "SELECT type, COUNT(*) as count FROM memories";
         const params = [];
@@ -308,267 +311,193 @@ export class SQLiteStore {
             params.push(repo);
         }
         query += " GROUP BY type";
-        const stmt = this.db.prepare(query);
-        const rows = stmt.all(...params);
+        const rows = this.db.prepare(query).all(...params);
         const byType = {};
         let total = 0;
         for (const row of rows) {
             byType[row.type] = row.count;
             total += row.count;
         }
-        let unusedQuery = "SELECT COUNT(*) as count FROM memories WHERE hit_count = 0";
-        if (repo) {
-            unusedQuery += " AND repo = ?";
-        }
-        const unusedStmt = this.db.prepare(unusedQuery);
-        const unusedRow = (repo ? unusedStmt.get(repo) : unusedStmt.get());
-        const unused = unusedRow?.count || 0;
-        return { total, byType, unused };
+        const unusedStmt = repo
+            ? this.db.prepare("SELECT COUNT(*) as count FROM memories WHERE hit_count = 0 AND repo = ?")
+            : this.db.prepare("SELECT COUNT(*) as count FROM memories WHERE hit_count = 0");
+        const unused = (repo ? unusedStmt.get(repo) : unusedStmt.get());
+        return { total, byType, unused: unused?.count || 0 };
     }
-    // Sub-task 2.2: Public method for Memory_Recap
-    getRecentMemories(repo, limit, offset = 0) {
-        const stmt = this.db.prepare(`
-      SELECT * FROM memories
-      WHERE repo = ?
-      ORDER BY created_at DESC
-      LIMIT ? OFFSET ?
-    `);
-        const rows = stmt.all(repo, limit, offset);
-        return rows.map((row) => this.rowToMemoryEntry(row));
+    listRepoNavigation() {
+        return this.db.prepare(`
+      SELECT repo, COUNT(*) AS memory_count, MAX(COALESCE(updated_at, created_at)) AS last_updated_at
+      FROM memories GROUP BY repo ORDER BY last_updated_at DESC, repo ASC
+    `).all();
     }
-    // Sub-task 2.2: Public method for total count
-    getTotalCount(repo) {
-        const stmt = this.db.prepare("SELECT COUNT(*) as count FROM memories WHERE repo = ?");
-        const row = stmt.get(repo);
-        return row?.count ?? 0;
+    getAllMemoriesWithStats(repo) {
+        let sql = `SELECT *, CASE WHEN hit_count > 0 THEN CAST(recall_count AS REAL) / hit_count ELSE 0 END AS recall_rate FROM memories`;
+        if (repo)
+            return this.db.prepare(sql + " WHERE repo = ?").all(repo);
+        return this.db.prepare(sql).all();
     }
-    // Sub-task 2.3: searchBySimilarity with pre-filter SQL + exclude expired
-    searchBySimilarity(query, repo, limit = 10) {
-        const queryVector = this.computeVector(query);
-        const now = new Date().toISOString();
-        // Pre-filter: fetch at most limit*10 candidates, exclude expired
-        const stmt = this.db.prepare(`
-      SELECT * FROM memories
-      WHERE repo = ?
-        AND (expires_at IS NULL OR expires_at > ?)
-      ORDER BY importance DESC, created_at DESC
-      LIMIT ?
-    `);
-        const candidates = stmt.all(repo, now, limit * 10);
-        const withSimilarity = candidates.map((row) => {
-            const memory = this.rowToMemoryEntry(row);
-            const memoryVector = this.computeVector(memory.content);
-            const similarity = this.cosineSimilarity(queryVector, memoryVector);
-            return {
-                ...memory,
-                similarity
-            };
-        });
-        return withSimilarity
-            .sort((a, b) => b.similarity - a.similarity)
-            .slice(0, limit);
+    getLastActionId() {
+        const row = this.db.prepare("SELECT MAX(id) as id FROM action_log").get();
+        return row?.id || 0;
     }
-    // Sub-task 2.5: Archive expired memories
-    archiveExpiredMemories() {
-        const now = new Date().toISOString();
-        const insertArchive = this.db.prepare(`
-      INSERT OR IGNORE INTO memories_archive
-        (id, repo, type, content, importance, folder, language,
-         created_at, updated_at, hit_count, recall_count, last_used_at, expires_at, archived_at)
-      SELECT id, repo, type, content, importance, folder, language,
-             created_at, updated_at, hit_count, recall_count, last_used_at, expires_at, ?
-      FROM memories
-      WHERE expires_at IS NOT NULL AND expires_at <= ?
-    `);
-        const deleteExpired = this.db.prepare(`
-      DELETE FROM memories
-      WHERE expires_at IS NOT NULL AND expires_at <= ?
-    `);
-        const archive = this.db.transaction(() => {
-            insertArchive.run(now, now);
-            const result = deleteExpired.run(now);
-            return result.changes;
-        });
-        return archive();
+    getActionsAfter(id) {
+        return this.db.prepare(`
+      SELECT a.*, m.title as memory_title, m.type as memory_type 
+      FROM action_log a LEFT JOIN memories m ON a.memory_id = m.id 
+      WHERE a.id > ? ORDER BY a.created_at ASC
+    `).all(id);
     }
-    // Get all memories with stats (for dashboard)
-    getAllMemoriesWithStats(repo) {
-        let query = "SELECT * FROM memories";
+    listMemoriesForDashboard(options) {
+        const { repo, type, tag, isGlobal, minImportance, search, offset = 0, limit = 50, sortBy = 'created_at', sortOrder = 'DESC' } = options;
+        let where = ["1=1"];
         const params = [];
         if (repo) {
-            query += " WHERE repo = ?";
+            where.push("repo = ?");
             params.push(repo);
         }
-        query += " ORDER BY hit_count DESC, importance DESC, created_at DESC";
-        const stmt = this.db.prepare(query);
-        const rows = stmt.all(...params);
-        return rows.map((row) => ({
-            ...this.rowToMemoryEntry(row),
-            hit_count: row.hit_count || 0,
-            recall_count: row.recall_count || 0,
-            recall_rate: row.hit_count > 0 ? row.recall_count / row.hit_count : 0,
-            last_used_at: row.last_used_at ?? null,
-        }));
-    }
-    listMemoriesForDashboard(options) {
-        const where = ["repo = ?"];
-        const params = [options.repo];
-        if (options.type) {
+        if (type) {
             where.push("type = ?");
-            params.push(options.type);
+            params.push(type);
         }
-        if (options.search) {
-            where.push("(LOWER(COALESCE(title, '')) LIKE ? OR LOWER(content) LIKE ? OR LOWER(id) LIKE ?)");
-            const term = `%${options.search.toLowerCase()}%`;
-            params.push(term, term, term);
+        if (tag) {
+            where.push("tags LIKE ?");
+            params.push(`%${tag}%`);
         }
-        if (options.minImportance !== undefined) {
+        if (isGlobal !== undefined) {
+            where.push("is_global = ?");
+            params.push(isGlobal ? 1 : 0);
+        }
+        if (minImportance) {
             where.push("importance >= ?");
-            params.push(options.minImportance);
+            params.push(minImportance);
         }
-        if (options.maxImportance !== undefined) {
-            where.push("importance <= ?");
-            params.push(options.maxImportance);
+        if (search) {
+            where.push("(title LIKE ? OR content LIKE ? OR tags LIKE ?)");
+            params.push(`%${search}%`, `%${search}%`, `%${search}%`);
         }
-        const whereSql = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
-        const sortableColumns = {
-            id: "id",
-            title: "COALESCE(title, content)",
-            type: "type",
-            importance: "importance",
-            hit_count: "hit_count",
-            recall_rate: "recall_rate",
-            created_at: "created_at",
-            updated_at: "updated_at",
-        };
-        const sortBy = sortableColumns[options.sortBy ?? "hit_count"] ?? sortableColumns.hit_count;
-        const sortOrder = options.sortOrder === "asc" ? "ASC" : "DESC";
-        const limit = options.limit ?? 25;
-        const offset = options.offset ?? 0;
-        const countStmt = this.db.prepare(`SELECT COUNT(*) AS count FROM memories ${whereSql}`);
-        const total = countStmt.get(...params)?.count ?? 0;
-        const listStmt = this.db.prepare(`
-      SELECT *,
-        CASE WHEN hit_count > 0 THEN CAST(recall_count AS REAL) / hit_count ELSE 0 END AS recall_rate
-      FROM memories
-      ${whereSql}
-      ORDER BY ${sortBy} ${sortOrder}, created_at DESC
-      LIMIT ? OFFSET ?
+        const countStmt = this.db.prepare(`SELECT COUNT(*) as count FROM memories WHERE ${where.join(" AND ")}`);
+        const total = countStmt.get(...params).count;
+        const dataStmt = this.db.prepare(`
+      SELECT *, CASE WHEN hit_count > 0 THEN CAST(recall_count AS REAL) / hit_count ELSE 0 END AS recall_rate
+      FROM memories WHERE ${where.join(" AND ")}
+      ORDER BY ${sortBy} ${sortOrder} LIMIT ? OFFSET ?
     `);
-        const rows = listStmt.all(...params, limit, offset);
-        return {
-            items: rows.map((row) => ({
-                ...this.rowToMemoryEntry(row),
-                hit_count: row.hit_count || 0,
-                recall_count: row.recall_count || 0,
-                recall_rate: row.recall_rate ?? 0,
-                last_used_at: row.last_used_at ?? null,
-            })),
-            total,
-        };
+        const items = dataStmt.all(...params, limit, offset);
+        return { items, memories: items, total, limit, offset };
     }
-    upsertVectorEmbedding(memoryId, vector) {
-        const stmt = this.db.prepare(`
-      INSERT INTO memory_vectors (memory_id, vector, updated_at)
-      VALUES (?, ?, ?)
-      ON CONFLICT(memory_id) DO UPDATE SET
-        vector = excluded.vector,
-        updated_at = excluded.updated_at
-    `);
-        stmt.run(memoryId, JSON.stringify(vector), new Date().toISOString());
+    getSummary(repo) {
+        return this.db.prepare("SELECT summary, updated_at FROM memory_summary WHERE repo = ?").get(repo);
     }
-    getVectorEmbedding(memoryId) {
-        const stmt = this.db.prepare("SELECT vector FROM memory_vectors WHERE memory_id = ?");
-        const row = stmt.get(memoryId);
-        if (!row)
-            return null;
-        try {
-            return JSON.parse(row.vector);
+    upsertSummary(repo, summary) {
+        this.db.prepare(`
+      INSERT INTO memory_summary (repo, summary, updated_at) VALUES (?, ?, ?)
+      ON CONFLICT(repo) DO UPDATE SET summary = excluded.summary, updated_at = excluded.updated_at
+    `).run(repo, summary, new Date().toISOString());
+    }
+    delete(id) {
+        this.db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+    }
+    listRepos() {
+        return this.db.prepare("SELECT DISTINCT repo FROM memories ORDER BY repo").all().map(r => r.repo);
+    }
+    incrementHitCount(id) {
+        this.db.prepare("UPDATE memories SET hit_count = hit_count + 1, last_used_at = ? WHERE id = ?").run(new Date().toISOString(), id);
+    }
+    incrementRecallCount(id) {
+        this.db.prepare("UPDATE memories SET recall_count = recall_count + 1, last_used_at = ? WHERE id = ?").run(new Date().toISOString(), id);
+    }
+    getRecentMemories(repo, limit, offset = 0, includeArchived = false) {
+        let query = "SELECT * FROM memories WHERE repo = ?";
+        if (!includeArchived) {
+            query += " AND status = 'active'";
+        }
+        query += " ORDER BY created_at DESC LIMIT ? OFFSET ?";
+        const stmt = this.db.prepare(query);
+        const rows = stmt.all(repo, limit, offset);
+        return rows.map((row) => this.rowToMemoryEntry(row));
+    }
+    getTotalCount(repo, includeArchived = false) {
+        let sql = "SELECT COUNT(*) as count FROM memories WHERE repo = ?";
+        if (!includeArchived)
+            sql += " AND status = 'active'";
+        return this.db.prepare(sql).get(repo).count;
+    }
+    getVectorCandidates(repo, limit = 100) {
+        let sql = `SELECT mv.memory_id, mv.vector FROM memory_vectors mv JOIN memories m ON mv.memory_id = m.id`;
+        const params = [];
+        if (repo) {
+            sql += " WHERE m.repo = ?";
+            params.push(repo);
         }
-        catch {
-            return null;
+        sql += " LIMIT ?";
+        params.push(limit);
+        return this.db.prepare(sql).all(...params);
+    }
+    upsertVectorEmbedding(memoryId, vector) {
+        this.db.prepare(`
+      INSERT INTO memory_vectors (memory_id, vector, updated_at) VALUES (?, ?, ?)
+      ON CONFLICT(memory_id) DO UPDATE SET vector = excluded.vector, updated_at = excluded.updated_at
+    `).run(memoryId, JSON.stringify(vector), new Date().toISOString());
+    }
+    async checkConflicts(content, repo, type, vectors, threshold = 0.55) {
+        const vectorResults = await vectors.search(content, 10, repo);
+        for (const vr of vectorResults) {
+            if (vr.score > threshold) {
+                const memory = this.getById(vr.id);
+                if (memory && memory.type === type && memory.status === 'active')
+                    return memory;
+            }
         }
+        return null;
     }
-    close() {
-        this.db.close();
+    logAction(action, repo, options = {}) {
+        this.db.prepare(`INSERT INTO action_log (action, query, memory_id, repo, result_count, created_at) VALUES (?, ?, ?, ?, ?, ?)`).run(action, options.query || null, options.memoryId || null, repo, options.resultCount || 0, new Date().toISOString());
+    }
+    getRecentActions(repo, limit = 20) {
+        let sql = `SELECT a.*, m.title as memory_title, m.type as memory_type FROM action_log a LEFT JOIN memories m ON a.memory_id = m.id`;
+        const params = [];
+        if (repo) {
+            sql += ` WHERE a.repo = ?`;
+            params.push(repo);
+        }
+        sql += ` ORDER BY a.created_at DESC, a.id DESC LIMIT ?`;
+        params.push(limit);
+        return this.db.prepare(sql).all(...params);
     }
-    // Sub-task 2.3: Use tokenize() from normalize.ts (single source of truth)
     computeVector(text) {
         const tokens = tokenize(text);
         const vector = {};
-        for (const token of tokens) {
+        for (const token of tokens)
             vector[token] = (vector[token] || 0) + 1;
-        }
         return vector;
     }
     cosineSimilarity(v1, v2) {
         const keys1 = Object.keys(v1);
-        const keys2 = Object.keys(v2);
-        if (keys1.length === 0 || keys2.length === 0)
+        if (!keys1.length || !Object.keys(v2).length)
             return 0;
         let dotProduct = 0;
-        for (const key of keys1) {
-            if (v2[key]) {
+        for (const key of keys1)
+            if (v2[key])
                 dotProduct += v1[key] * v2[key];
-            }
-        }
-        const mag1 = Math.sqrt(keys1.reduce((sum, key) => sum + v1[key] * v1[key], 0));
-        const mag2 = Math.sqrt(keys2.reduce((sum, key) => sum + v2[key] * v2[key], 0));
-        if (mag1 === 0 || mag2 === 0)
-            return 0;
-        return dotProduct / (mag1 * mag2);
+        const mag1 = Math.sqrt(keys1.reduce((sum, k) => sum + v1[k] * v1[k], 0));
+        const mag2 = Math.sqrt(Object.keys(v2).reduce((sum, k) => sum + v2[k] * v2[k], 0));
+        return (mag1 && mag2) ? dotProduct / (mag1 * mag2) : 0;
     }
     rowToMemoryEntry(row) {
+        let tags = [];
+        try {
+            if (row.tags)
+                tags = JSON.parse(row.tags);
+        }
+        catch (e) { }
         return {
-            id: row.id,
-            type: row.type,
-            title: row.title || "Untitled Memory",
-            content: row.content,
-            importance: row.importance,
-            scope: {
-                repo: row.repo,
-                folder: row.folder || undefined,
-                language: row.language || undefined,
-            },
-            created_at: row.created_at,
-            updated_at: row.updated_at,
-            hit_count: row.hit_count ?? 0,
-            recall_count: row.recall_count ?? 0,
-            last_used_at: row.last_used_at ?? null,
-            expires_at: row.expires_at ?? null,
+            id: row.id, type: row.type, title: row.title || "Untitled", content: row.content, importance: row.importance,
+            scope: { repo: row.repo, folder: row.folder || undefined, language: row.language || undefined },
+            created_at: row.created_at, updated_at: row.updated_at, hit_count: row.hit_count ?? 0, recall_count: row.recall_count ?? 0,
+            last_used_at: row.last_used_at ?? null, expires_at: row.expires_at ?? null, supersedes: row.supersedes ?? null, status: row.status || "active",
+            is_global: row.is_global === 1, tags
         };
     }
-    logAction(action, repo, options) {
-        const stmt = this.db.prepare(`
-      INSERT INTO action_log (action, query, memory_id, repo, result_count, created_at)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `);
-        stmt.run(action, options?.query || null, options?.memoryId || null, repo, options?.resultCount || 0, new Date().toISOString());
-    }
-    getLastActionId() {
-        const row = this.db.prepare(`SELECT MAX(id) as max_id FROM action_log`).get();
-        return row?.max_id ?? 0;
-    }
-    getActionsAfter(afterId) {
-        const rows = this.db.prepare(`SELECT id, action, query, memory_id, repo, result_count, created_at FROM action_log WHERE id > ? ORDER BY id ASC`).all(afterId);
-        return rows;
-    }
-    getRecentActions(repo, limit = 20) {
-        let sql = `
-      SELECT a.action, a.query, a.memory_id, a.result_count, a.created_at,
-             m.title as memory_title, m.type as memory_type
-      FROM action_log a
-      LEFT JOIN memories m ON a.memory_id = m.id
-    `;
-        const params = [];
-        if (repo) {
-            sql += ` WHERE a.repo = ?`;
-            params.push(repo);
-        }
-        sql += ` ORDER BY a.created_at DESC, a.id DESC LIMIT ?`;
-        params.push(limit);
-        const rows = this.db.prepare(sql).all(...params);
-        return rows;
-    }
+    close() { this.db.close(); }
 }
 //# sourceMappingURL=sqlite.js.map