codestrate 0.1.0

package/dist/store/sqlite.js

@@ -0,0 +1,1018 @@
+/**
+ * SQLite Store — default production storage backend.
+ *
+ * Uses better-sqlite3 for synchronous, fast SQLite access.
+ * Implements the full Store interface with schema migration support.
+ *
+ * @module store/sqlite
+ */
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+// ─── Schema migrations ─────────────────────────────────────
+const MIGRATIONS = [
+    {
+        version: 1,
+        name: "initial-schema",
+        sql: [
+            `CREATE TABLE IF NOT EXISTS schema_version (
+        version INTEGER PRIMARY KEY,
+        applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+      )`,
+            `CREATE TABLE IF NOT EXISTS repository_snapshot (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        repo_fingerprint TEXT,
+        commit_sha TEXT,
+        branch TEXT,
+        build_system TEXT,
+        repo_path TEXT,
+        indexed_at TEXT,
+        snapshot_json TEXT
+      )`,
+            `CREATE TABLE IF NOT EXISTS symbols (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        file TEXT NOT NULL,
+        line INTEGER NOT NULL DEFAULT 0,
+        column INTEGER NOT NULL DEFAULT 0,
+        signature TEXT NOT NULL DEFAULT '',
+        summary TEXT NOT NULL DEFAULT '',
+        imports TEXT DEFAULT '[]',
+        calls TEXT DEFAULT '[]',
+        called_by TEXT DEFAULT '[]',
+        related_tests TEXT DEFAULT '[]',
+        commit_sha TEXT,
+        repo_fingerprint TEXT,
+        UNIQUE(name, file)
+      )`,
+            `CREATE TABLE IF NOT EXISTS relations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        source_symbol TEXT NOT NULL,
+        target_symbol TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        UNIQUE(source_symbol, target_symbol, kind)
+      )`,
+            `CREATE TABLE IF NOT EXISTS files_by_language (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        language TEXT NOT NULL,
+        file_path TEXT NOT NULL,
+        UNIQUE(language, file_path)
+      )`,
+            `CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name)`,
+            `CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file)`,
+            `CREATE INDEX IF NOT EXISTS idx_symbols_kind ON symbols(kind)`,
+            `CREATE INDEX IF NOT EXISTS idx_relations_source ON relations(source_symbol)`,
+            `CREATE INDEX IF NOT EXISTS idx_relations_target ON relations(target_symbol)`,
+            `CREATE INDEX IF NOT EXISTS idx_files_language ON files_by_language(language)`,
+        ],
+    },
+    {
+        version: 2,
+        name: "experiences-and-memories",
+        sql: [
+            `CREATE TABLE IF NOT EXISTS experiences (
+        id TEXT PRIMARY KEY,
+        repo TEXT,
+        task TEXT NOT NULL,
+        diagnosis TEXT NOT NULL,
+        solution TEXT NOT NULL,
+        changed_files TEXT NOT NULL,
+        "commit" TEXT NOT NULL,
+        validation TEXT DEFAULT '[]',
+        failed_attempts TEXT DEFAULT '[]',
+        evidence TEXT,
+        quality REAL DEFAULT 0.5,
+        timestamp TEXT NOT NULL DEFAULT (datetime('now')),
+        type TEXT NOT NULL DEFAULT 'episodic'
+      )`,
+            `CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        repo TEXT,
+        type TEXT NOT NULL CHECK (type IN ('semantic', 'episodic', 'procedural', 'negative')),
+        content TEXT NOT NULL,
+        symbols TEXT DEFAULT '[]',
+        files TEXT DEFAULT '[]',
+        "commit" TEXT,
+        quality REAL DEFAULT 0.3,
+        timestamp TEXT NOT NULL DEFAULT (datetime('now')),
+        source TEXT NOT NULL DEFAULT 'manual'
+      )`,
+            `CREATE INDEX IF NOT EXISTS idx_experiences_repo ON experiences(repo)`,
+            `CREATE INDEX IF NOT EXISTS idx_memories_repo ON memories(repo)`,
+            `CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type)`,
+        ],
+    },
+    {
+        version: 3,
+        name: "validation-results",
+        sql: [
+            `CREATE TABLE IF NOT EXISTS validation_results (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        repo TEXT,
+        type TEXT NOT NULL CHECK (type IN ('build','test','lint')),
+        passed INTEGER NOT NULL,
+        command TEXT NOT NULL,
+        output TEXT DEFAULT '',
+        errors TEXT DEFAULT '[]',
+        duration REAL,
+        exit_code INTEGER,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      )`,
+            `CREATE INDEX IF NOT EXISTS idx_validation_repo ON validation_results(repo)`,
+            `CREATE INDEX IF NOT EXISTS idx_validation_created ON validation_results(created_at DESC)`,
+        ],
+    },
+    {
+        version: 4,
+        name: "full-text-search",
+        sql: [
+            `CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(
+        name,
+        signature,
+        summary,
+        file,
+        content='symbols',
+        content_rowid='id',
+        tokenize='unicode61'
+      )`,
+            `CREATE TRIGGER IF NOT EXISTS symbols_fts_ai AFTER INSERT ON symbols BEGIN
+        INSERT INTO symbols_fts(rowid, name, signature, summary, file)
+        VALUES (NEW.id, NEW.name, NEW.signature, NEW.summary, NEW.file);
+      END`,
+            `CREATE TRIGGER IF NOT EXISTS symbols_fts_ad AFTER DELETE ON symbols BEGIN
+        INSERT INTO symbols_fts(symbols_fts, rowid, name, signature, summary, file)
+        VALUES ('delete', OLD.id, OLD.name, OLD.signature, OLD.summary, OLD.file);
+      END`,
+            `CREATE TRIGGER IF NOT EXISTS symbols_fts_au AFTER UPDATE ON symbols BEGIN
+        INSERT INTO symbols_fts(symbols_fts, rowid, name, signature, summary, file)
+        VALUES ('delete', OLD.id, OLD.name, OLD.signature, OLD.summary, OLD.file);
+        INSERT INTO symbols_fts(rowid, name, signature, summary, file)
+        VALUES (NEW.id, NEW.name, NEW.signature, NEW.summary, NEW.file);
+      END`,
+            // Backfill: index all existing symbols so FTS5 works immediately
+            // after migration. INSERT OR IGNORE skips rows already indexed
+            // (idempotent on re-run).
+            `INSERT OR IGNORE INTO symbols_fts(rowid, name, signature, summary, file)
+       SELECT id, name, signature, summary, file FROM symbols`,
+        ],
+    },
+    {
+        version: 5,
+        name: "graph-nodes-edges",
+        sql: [
+            `CREATE TABLE IF NOT EXISTS graph_nodes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        symbol_id INTEGER REFERENCES symbols(id) ON DELETE CASCADE,
+        file TEXT NOT NULL,
+        name TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        signature TEXT NOT NULL DEFAULT '',
+        line INTEGER,
+        "column" INTEGER,
+        UNIQUE(symbol_id)
+      )`,
+            `CREATE TABLE IF NOT EXISTS graph_edges (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        source_node_id INTEGER NOT NULL REFERENCES graph_nodes(id) ON DELETE CASCADE,
+        target_node_id INTEGER NOT NULL REFERENCES graph_nodes(id) ON DELETE CASCADE,
+        kind TEXT NOT NULL,
+        line INTEGER,
+        "column" INTEGER,
+        UNIQUE(source_node_id, target_node_id, kind)
+      )`,
+            `CREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(
+        name, file, signature,
+        content='graph_nodes',
+        content_rowid='id',
+        tokenize='unicode61'
+      )`,
+            `CREATE TRIGGER IF NOT EXISTS nodes_fts_ai AFTER INSERT ON graph_nodes BEGIN
+        INSERT INTO nodes_fts(rowid, name, file, signature)
+        VALUES (NEW.id, NEW.name, NEW.file, NEW.signature);
+      END`,
+            `CREATE TRIGGER IF NOT EXISTS nodes_fts_ad AFTER DELETE ON graph_nodes BEGIN
+        INSERT INTO nodes_fts(nodes_fts, rowid, name, file, signature)
+        VALUES ('delete', OLD.id, OLD.name, OLD.file, OLD.signature);
+      END`,
+            `CREATE TRIGGER IF NOT EXISTS nodes_fts_au AFTER UPDATE ON graph_nodes BEGIN
+        INSERT INTO nodes_fts(nodes_fts, rowid, name, file, signature)
+        VALUES ('delete', OLD.id, OLD.name, OLD.file, OLD.signature);
+        INSERT INTO nodes_fts(rowid, name, file, signature)
+        VALUES (NEW.id, NEW.name, NEW.file, NEW.signature);
+      END`,
+            `INSERT OR IGNORE INTO nodes_fts(rowid, name, file, signature)
+       SELECT id, name, file, signature FROM graph_nodes`,
+            `CREATE INDEX IF NOT EXISTS idx_graph_edges_source ON graph_edges(source_node_id)`,
+            `CREATE INDEX IF NOT EXISTS idx_graph_edges_target ON graph_edges(target_node_id)`,
+            `CREATE INDEX IF NOT EXISTS idx_graph_edges_kind ON graph_edges(kind)`,
+            `CREATE INDEX IF NOT EXISTS idx_graph_nodes_kind ON graph_nodes(kind)`,
+            `CREATE INDEX IF NOT EXISTS idx_graph_nodes_file ON graph_nodes(file)`,
+            `CREATE UNIQUE INDEX IF NOT EXISTS idx_graph_nodes_symbol ON graph_nodes(symbol_id)`,
+        ],
+    },
+];
+export class SQLiteStore {
+    db = null;
+    dbPath;
+    constructor(dbPath) {
+        this.dbPath = dbPath ?? join(process.cwd(), ".ci-mcp", "store.db");
+    }
+    // ── Lifecycle ──────────────────────────────────────────
+    open() {
+        if (this.db)
+            return;
+        const dir = dirname(this.dbPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        this.db = new Database(this.dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("foreign_keys = ON");
+    }
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+    isOpen() {
+        return this.db !== null;
+    }
+    // ── Migration ─────────────────────────────────────────
+    getCurrentVersion() {
+        this.ensureOpen();
+        try {
+            const row = this.db.prepare("SELECT MAX(version) as version FROM schema_version").get();
+            return row?.version ?? 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    migrate(targetVersion) {
+        this.ensureOpen();
+        const current = this.getCurrentVersion();
+        const target = targetVersion ?? MIGRATIONS.length;
+        for (const migration of MIGRATIONS) {
+            if (migration.version > current && migration.version <= target) {
+                const run = this.db.transaction(() => {
+                    for (const sql of migration.sql) {
+                        this.db.exec(sql);
+                    }
+                    this.db
+                        .prepare("INSERT INTO schema_version (version) VALUES (?)")
+                        .run(migration.version);
+                });
+                run();
+            }
+        }
+    }
+    // ── Repository snapshot (IndexStore) ──────────────────
+    getSnapshot() {
+        this.ensureOpen();
+        const row = this.db
+            .prepare("SELECT snapshot_json FROM repository_snapshot WHERE id = 1")
+            .get();
+        return row ? JSON.parse(row.snapshot_json) : null;
+    }
+    setSnapshot(snapshot) {
+        this.ensureOpen();
+        this.db
+            .prepare(`INSERT INTO repository_snapshot (id, repo_fingerprint, commit_sha, branch,
+          build_system, repo_path, snapshot_json)
+         VALUES (1, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+          repo_fingerprint = excluded.repo_fingerprint,
+          commit_sha = excluded.commit_sha,
+          branch = excluded.branch,
+          build_system = excluded.build_system,
+          repo_path = excluded.repo_path,
+          snapshot_json = excluded.snapshot_json`)
+            .run(snapshot.repoFingerprint ?? null, snapshot.commitSha ?? null, snapshot.branch ?? null, snapshot.buildSystem ?? null, snapshot.path ?? null, JSON.stringify(snapshot));
+    }
+    getRepoFingerprint() {
+        this.ensureOpen();
+        const row = this.db
+            .prepare("SELECT repo_fingerprint FROM repository_snapshot WHERE id = 1")
+            .get();
+        return row?.repo_fingerprint ?? null;
+    }
+    setRepoFingerprint(fingerprint) {
+        this.ensureOpen();
+        this.db
+            .prepare(`INSERT INTO repository_snapshot (id, repo_fingerprint)
+         VALUES (1, ?)
+         ON CONFLICT(id) DO UPDATE SET repo_fingerprint = excluded.repo_fingerprint`)
+            .run(fingerprint);
+    }
+    // ── Symbols (IndexStore) ──────────────────────────────
+    getSymbols() {
+        this.ensureOpen();
+        const rows = this.db.prepare("SELECT * FROM symbols").all();
+        return rows.map(this.rowToSymbol);
+    }
+    getSymbol(name, file) {
+        this.ensureOpen();
+        let row;
+        if (file) {
+            row = this.db
+                .prepare("SELECT * FROM symbols WHERE name = ? AND file = ?")
+                .get(name, file);
+        }
+        else {
+            row = this.db
+                .prepare("SELECT * FROM symbols WHERE name = ? LIMIT 1")
+                .get(name);
+        }
+        return row ? this.rowToSymbol(row) : null;
+    }
+    addSymbol(symbol) {
+        this.ensureOpen();
+        this.db
+            .prepare(`INSERT OR REPLACE INTO symbols
+         (name, kind, file, line, "column", signature, summary,
+          imports, calls, called_by, related_tests,
+          commit_sha, repo_fingerprint)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(symbol.name, symbol.kind, symbol.file, symbol.line, symbol.column, symbol.signature, symbol.summary, JSON.stringify(symbol.imports ?? []), JSON.stringify(symbol.calls ?? []), JSON.stringify(symbol.calledBy ?? []), JSON.stringify(symbol.relatedTests ?? []), symbol.commitSha, symbol.repoFingerprint);
+    }
+    addSymbols(symbols) {
+        const insert = this.db.prepare(`INSERT OR REPLACE INTO symbols
+       (name, kind, file, line, "column", signature, summary,
+        imports, calls, called_by, related_tests,
+        commit_sha, repo_fingerprint)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        const batch = this.db.transaction((symbols) => {
+            for (const s of symbols) {
+                insert.run(s.name, s.kind, s.file, s.line, s.column, s.signature, s.summary, JSON.stringify(s.imports ?? []), JSON.stringify(s.calls ?? []), JSON.stringify(s.calledBy ?? []), JSON.stringify(s.relatedTests ?? []), s.commitSha, s.repoFingerprint);
+            }
+        });
+        batch(symbols);
+    }
+    removeSymbolsByFile(file) {
+        this.ensureOpen();
+        this.db.prepare("DELETE FROM symbols WHERE file = ?").run(file);
+    }
+    clearSymbols() {
+        this.ensureOpen();
+        this.db.exec("DELETE FROM symbols; DELETE FROM relations");
+    }
+    // ── Full-text search (SQLite-only, requires migration v4) ──
+    // These methods use the FTS5 virtual table for fast symbol search.
+    // The JSON store doesn't support FTS — use `findSymbols()` there.
+    /**
+     * Search symbols using FTS5 full-text index.
+     * Returns symbols ranked by relevance (BM25).
+     * Limited to `limit` results (default 20, max 50).
+     * Falls back to name LIKE search when FTS is unavailable
+     * (pre-v4 migration databases).
+     */
+    searchSymbolsFTS(query, limit = 20) {
+        this.ensureOpen();
+        const safeLimit = Math.min(Math.max(1, limit), 50);
+        try {
+            // FTS5 query: escape special chars, use BM25 ranking.
+            // `rank` column is auto-generated by FTS5 — lower = more relevant.
+            const stmt = this.db.prepare(`
+        SELECT s.* FROM symbols s
+        JOIN symbols_fts fts ON s.id = fts.rowid
+        WHERE symbols_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `);
+            const rows = stmt.all(query, safeLimit);
+            return rows.map(r => this.rowToSymbol(r));
+        }
+        catch {
+            // Fallback: FTS5 table doesn't exist yet (pre-v4).
+            // Use LIKE search on name + file as best-effort.
+            const likeQuery = `%${query}%`;
+            const stmt = this.db.prepare(`
+        SELECT * FROM symbols
+        WHERE name LIKE ? OR file LIKE ?
+        LIMIT ?
+      `);
+            const rows = stmt.all(likeQuery, likeQuery, safeLimit);
+            return rows.map(r => this.rowToSymbol(r));
+        }
+    }
+    /** Populate graph nodes and edges from symbol data.
+     *  Accepts symbols directly to decouple from store backend.
+     *  Clears previous graph data first. */
+    populateGraph(symbols, relations) {
+        this.ensureOpen();
+        this.db.exec("DELETE FROM graph_edges; DELETE FROM graph_nodes");
+        // Insert graph nodes from symbols
+        const insertNode = this.db.prepare(`
+      INSERT INTO graph_nodes (symbol_id, file, name, kind, signature, line, "column")
+      VALUES (NULL, ?, ?, ?, ?, ?, ?)
+    `);
+        const nodeIds = this.db.transaction(() => {
+            const ids = new Map();
+            for (let i = 0; i < symbols.length; i++) {
+                const s = symbols[i];
+                const result = insertNode.run(s.file, s.name, s.kind, s.signature, s.line, s.column);
+                ids.set(s.file + ":" + s.name, Number(result.lastInsertRowid));
+            }
+            return ids;
+        })();
+        // Build name-based lookup (includes all nodes)
+        const nameToId = new Map();
+        for (const [key, id] of nodeIds) {
+            const name = key.split(":")[1];
+            nameToId.set(name, id);
+        }
+        // Insert edges from call/called_by/imports in symbols
+        const insertEdge = this.db.prepare(`
+      INSERT OR IGNORE INTO graph_edges (source_node_id, target_node_id, kind)
+      VALUES (?, ?, ?)
+    `);
+        const parseArr = (val) => {
+            if (Array.isArray(val))
+                return val;
+            const s = String(val ?? "[]");
+            try {
+                return JSON.parse(s);
+            }
+            catch {
+                return [];
+            }
+        };
+        this.db.transaction(() => {
+            // calls/called_by from SymbolInfo
+            for (let i = 0; i < symbols.length; i++) {
+                const sym = symbols[i];
+                const myNodeId = nodeIds.get(sym.file + ":" + sym.name);
+                if (!myNodeId)
+                    continue;
+                for (const targetName of parseArr(sym.calls)) {
+                    const targetId = nameToId.get(targetName);
+                    if (targetId && targetId !== myNodeId) {
+                        insertEdge.run(myNodeId, targetId, "calls");
+                    }
+                }
+            }
+            // relations edges
+            for (const rel of relations) {
+                const sourceId = nameToId.get(rel.source);
+                const targetId = nameToId.get(rel.target);
+                if (sourceId && targetId && sourceId !== targetId) {
+                    insertEdge.run(sourceId, targetId, rel.kind);
+                }
+            }
+        })();
+    }
+    /** Get a graph node by ID. */
+    getGraphNode(id) {
+        this.ensureOpen();
+        const row = this.db.prepare("SELECT * FROM graph_nodes WHERE id = ?").get(id);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            symbolId: row.symbol_id ?? undefined,
+            file: row.file,
+            name: row.name,
+            kind: row.kind,
+            signature: row.signature,
+            line: row.line ?? undefined,
+            column: row.column ?? undefined,
+        };
+    }
+    /** Get edges for a graph node. */
+    getGraphEdges(nodeId, direction = "both", kind) {
+        this.ensureOpen();
+        let query;
+        const params = [];
+        if (direction === "incoming" || direction === "both") {
+            query = "SELECT id, source_node_id, target_node_id, kind, line, \"column\" FROM graph_edges WHERE target_node_id = ?";
+            params.push(nodeId);
+        }
+        else {
+            query = "SELECT id, source_node_id, target_node_id, kind, line, \"column\" FROM graph_edges WHERE source_node_id = ?";
+            params.push(nodeId);
+        }
+        if (kind) {
+            query += " AND kind = ?";
+            params.push(kind);
+        }
+        const rows = this.db.prepare(query).all(...params);
+        let edges = rows.map(r => ({
+            id: r.id,
+            sourceNodeId: r.source_node_id,
+            targetNodeId: r.target_node_id,
+            kind: r.kind,
+            line: r.line ?? undefined,
+            column: r.column ?? undefined,
+        }));
+        // For "both", also query incoming edges
+        if (direction === "both") {
+            let incomingQuery = "SELECT id, source_node_id, target_node_id, kind, line, \"column\" FROM graph_edges WHERE source_node_id = ?";
+            if (kind)
+                incomingQuery += " AND kind = ?";
+            const incomingParams = [nodeId];
+            if (kind)
+                incomingParams.push(kind);
+            const incomingRows = this.db.prepare(incomingQuery).all(...incomingParams);
+            const incomingEdges = incomingRows.map(r => ({
+                id: r.id,
+                sourceNodeId: r.source_node_id,
+                targetNodeId: r.target_node_id,
+                kind: r.kind,
+                line: r.line ?? undefined,
+                column: r.column ?? undefined,
+            }));
+            edges = [...edges, ...incomingEdges];
+        }
+        return edges;
+    }
+    /** Search graph nodes by name (LIKE fallback). */
+    searchGraphNodes(query, limit = 20) {
+        this.ensureOpen();
+        const safeLimit = Math.min(Math.max(1, limit), 50);
+        const pattern = `%${query}%`;
+        const rows = this.db
+            .prepare("SELECT * FROM graph_nodes WHERE name LIKE ? ORDER BY kind, name LIMIT ?")
+            .all(pattern, safeLimit);
+        return rows.map(r => ({
+            id: r.id,
+            symbolId: r.symbol_id ?? undefined,
+            file: r.file,
+            name: r.name,
+            kind: r.kind,
+            signature: r.signature,
+            line: r.line ?? undefined,
+            column: r.column ?? undefined,
+        }));
+    }
+    /** Search graph nodes by name using FTS5. */
+    searchGraphNodesFTS(query, limit = 20) {
+        this.ensureOpen();
+        const safeLimit = Math.min(Math.max(1, limit), 50);
+        try {
+            const stmt = this.db.prepare(`
+        SELECT gn.* FROM graph_nodes gn
+        JOIN nodes_fts fts ON gn.id = fts.rowid
+        WHERE nodes_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `);
+            const rows = stmt.all(query, safeLimit);
+            return rows.map(r => ({
+                id: r.id,
+                symbolId: r.symbol_id ?? undefined,
+                file: r.file,
+                name: r.name,
+                kind: r.kind,
+                signature: r.signature,
+                line: r.line ?? undefined,
+                column: r.column ?? undefined,
+            }));
+        }
+        catch {
+            const likeQuery = `%${query}%`;
+            const stmt = this.db.prepare(`
+        SELECT * FROM graph_nodes
+        WHERE name LIKE ? OR file LIKE ?
+        LIMIT ?
+      `);
+            const rows = stmt.all(likeQuery, likeQuery, safeLimit);
+            return rows.map(r => ({
+                id: r.id,
+                symbolId: r.symbol_id ?? undefined,
+                file: r.file,
+                name: r.name,
+                kind: r.kind,
+                signature: r.signature,
+                line: r.line ?? undefined,
+                column: r.column ?? undefined,
+            }));
+        }
+    }
+    /** CamelCase-aware graph search — split query into segments. */
+    searchGraphNodesCamel(query, limit = 20) {
+        const segments = nameSegmentVocab(query);
+        if (segments.length === 0)
+            return this.searchGraphNodesFTS(query, limit);
+        const pattern = segments.map(s => `%${s}%`).join("");
+        const safeLimit = Math.min(Math.max(1, limit), 50);
+        try {
+            const rows = this.db
+                .prepare("SELECT * FROM graph_nodes WHERE name LIKE ? ORDER BY kind, name LIMIT ?")
+                .all(pattern, safeLimit);
+            return rows.map(r => ({
+                id: r.id,
+                symbolId: r.symbol_id ?? undefined,
+                file: r.file,
+                name: r.name,
+                kind: r.kind,
+                signature: r.signature,
+                line: r.line ?? undefined,
+                column: r.column ?? undefined,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Find a path between two graph nodes using BFS. */
+    findGraphPath(fromNodeId, toNodeId, maxDepth = 5) {
+        this.ensureOpen();
+        // BFS on graph_edges
+        const visited = new Set();
+        const parent = new Map();
+        const queue = [fromNodeId];
+        visited.add(fromNodeId);
+        for (let depth = 0; queue.length > 0 && depth < maxDepth; depth++) {
+            const levelSize = queue.length;
+            for (let i = 0; i < levelSize; i++) {
+                const currentId = queue.shift();
+                if (currentId === toNodeId) {
+                    // Reconstruct path
+                    const path = [];
+                    let nodeId = toNodeId;
+                    while (parent.has(nodeId)) {
+                        const p = parent.get(nodeId);
+                        path.unshift(p.edge);
+                        nodeId = p.parentId;
+                    }
+                    return path;
+                }
+                // Get outgoing edges from current node
+                const edges = this.db
+                    .prepare("SELECT * FROM graph_edges WHERE source_node_id = ?")
+                    .all(currentId);
+                for (const edge of edges) {
+                    if (!visited.has(edge.target_node_id)) {
+                        visited.add(edge.target_node_id);
+                        parent.set(edge.target_node_id, { parentId: currentId, edge });
+                        queue.push(edge.target_node_id);
+                    }
+                }
+                // Get incoming edges
+                const inEdges = this.db
+                    .prepare("SELECT * FROM graph_edges WHERE target_node_id = ?")
+                    .all(currentId);
+                for (const edge of inEdges) {
+                    if (!visited.has(edge.source_node_id)) {
+                        visited.add(edge.source_node_id);
+                        parent.set(edge.source_node_id, { parentId: currentId, edge });
+                        queue.push(edge.source_node_id);
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /** Remove graph entries for a file (cascade via FK — foreign_keys must be ON). */
+    removeGraphForFile(file) {
+        this.ensureOpen();
+        this.db.prepare("DELETE FROM graph_nodes WHERE file = ?").run(file);
+    }
+    /** Clear all graph data. */
+    clearGraph() {
+        this.ensureOpen();
+        this.db.exec("DELETE FROM graph_edges; DELETE FROM graph_nodes");
+    }
+    // ── Relations (IndexStore) ────────────────────────────
+    getRelations() {
+        this.ensureOpen();
+        const rows = this.db.prepare("SELECT * FROM relations").all();
+        return rows.map((r) => ({
+            source: r.source_symbol,
+            target: r.target_symbol,
+            kind: r.kind,
+        }));
+    }
+    getRelationsForSymbol(symbol) {
+        this.ensureOpen();
+        const rows = this.db
+            .prepare("SELECT * FROM relations WHERE source_symbol = ? OR target_symbol = ?")
+            .all(symbol, symbol);
+        return rows.map((r) => ({
+            source: r.source_symbol,
+            target: r.target_symbol,
+            kind: r.kind,
+        }));
+    }
+    addRelation(relation) {
+        this.ensureOpen();
+        this.db
+            .prepare("INSERT OR REPLACE INTO relations (source_symbol, target_symbol, kind) VALUES (?, ?, ?)")
+            .run(relation.source, relation.target, relation.kind);
+    }
+    addRelations(relations) {
+        const insert = this.db.prepare("INSERT OR REPLACE INTO relations (source_symbol, target_symbol, kind) VALUES (?, ?, ?)");
+        const batch = this.db.transaction((rels) => {
+            for (const r of rels) {
+                insert.run(r.source, r.target, r.kind);
+            }
+        });
+        batch(relations);
+    }
+    clearRelations() {
+        this.ensureOpen();
+        this.db.exec("DELETE FROM relations");
+    }
+    // ── Files by language (IndexStore) ────────────────────
+    getFilesByLanguage() {
+        this.ensureOpen();
+        const rows = this.db
+            .prepare("SELECT language, file_path FROM files_by_language ORDER BY language, file_path")
+            .all();
+        const result = {};
+        for (const r of rows) {
+            if (!result[r.language])
+                result[r.language] = [];
+            result[r.language].push(r.file_path);
+        }
+        return result;
+    }
+    addFile(language, filePath) {
+        this.ensureOpen();
+        this.db
+            .prepare("INSERT OR IGNORE INTO files_by_language (language, file_path) VALUES (?, ?)")
+            .run(language, filePath);
+    }
+    setFilesByLanguage(files) {
+        this.ensureOpen();
+        const clear = this.db.prepare("DELETE FROM files_by_language");
+        const insert = this.db.prepare("INSERT INTO files_by_language (language, file_path) VALUES (?, ?)");
+        const batch = this.db.transaction(() => {
+            clear.run();
+            for (const [lang, paths] of Object.entries(files)) {
+                for (const p of paths) {
+                    insert.run(lang, p);
+                }
+            }
+        });
+        batch();
+    }
+    // ── Index tracking (IndexStore) ───────────────────────
+    getIndexedCommit() {
+        this.ensureOpen();
+        const row = this.db
+            .prepare("SELECT commit_sha FROM repository_snapshot WHERE id = 1")
+            .get();
+        return row?.commit_sha ?? null;
+    }
+    setIndexedCommit(sha) {
+        this.ensureOpen();
+        this.db
+            .prepare(`INSERT INTO repository_snapshot (id, commit_sha) VALUES (1, ?)
+         ON CONFLICT(id) DO UPDATE SET commit_sha = excluded.commit_sha`)
+            .run(sha);
+    }
+    getIndexedAt() {
+        this.ensureOpen();
+        const row = this.db
+            .prepare("SELECT indexed_at FROM repository_snapshot WHERE id = 1")
+            .get();
+        return row?.indexed_at ?? null;
+    }
+    setIndexedAt(ts) {
+        this.ensureOpen();
+        this.db
+            .prepare(`INSERT INTO repository_snapshot (id, indexed_at) VALUES (1, ?)
+         ON CONFLICT(id) DO UPDATE SET indexed_at = excluded.indexed_at`)
+            .run(ts);
+    }
+    // ── Purge (IndexStore) ────────────────────────────────
+    purge() {
+        this.ensureOpen();
+        this.db.exec(`DELETE FROM symbols; DELETE FROM relations;
+       DELETE FROM files_by_language; DELETE FROM repository_snapshot;
+       DELETE FROM experiences; DELETE FROM memories;
+       DELETE FROM validation_results`);
+    }
+    // ── Experiences (MemoryStore) ─────────────────────────
+    addExperience(exp) {
+        this.ensureOpen();
+        this.db
+            .prepare(`INSERT OR REPLACE INTO experiences
+         (id, repo, task, diagnosis, solution, changed_files,
+          "commit", validation, failed_attempts, evidence,
+          quality, timestamp, type)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(exp.id, exp.repo, exp.task, exp.diagnosis, exp.solution, JSON.stringify(exp.changedFiles), exp.commit, JSON.stringify(exp.validation ?? []), JSON.stringify(exp.failedAttempts ?? []), exp.evidence ? JSON.stringify(exp.evidence) : null, exp.quality, exp.timestamp, exp.type);
+    }
+    getExperience(id) {
+        this.ensureOpen();
+        const row = this.db
+            .prepare("SELECT * FROM experiences WHERE id = ?")
+            .get(id);
+        return row ? this.rowToExperience(row) : null;
+    }
+    getAllExperiences(repo) {
+        this.ensureOpen();
+        let rows;
+        if (repo) {
+            rows = this.db
+                .prepare("SELECT * FROM experiences WHERE repo = ? ORDER BY timestamp DESC")
+                .all(repo);
+        }
+        else {
+            rows = this.db
+                .prepare("SELECT * FROM experiences ORDER BY timestamp DESC")
+                .all();
+        }
+        return rows.map((r) => this.rowToExperience(r));
+    }
+    updateExperience(id, updates) {
+        this.ensureOpen();
+        const existing = this.getExperience(id);
+        if (!existing)
+            return;
+        const merged = { ...existing, ...updates };
+        this.addExperience(merged);
+    }
+    deleteExperience(id) {
+        this.ensureOpen();
+        this.db.prepare("DELETE FROM experiences WHERE id = ?").run(id);
+    }
+    // ── Memories (MemoryStore) ────────────────────────────
+    addMemory(mem) {
+        this.ensureOpen();
+        this.db
+            .prepare(`INSERT OR REPLACE INTO memories
+         (id, repo, type, content, symbols, files,
+          "commit", quality, timestamp, source)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(mem.id, mem.repo, mem.type, mem.content, JSON.stringify(mem.symbols ?? []), JSON.stringify(mem.files ?? []), mem.commit, mem.quality, mem.timestamp, mem.source);
+    }
+    getMemory(id) {
+        this.ensureOpen();
+        const row = this.db
+            .prepare("SELECT * FROM memories WHERE id = ?")
+            .get(id);
+        return row ? this.rowToMemory(row) : null;
+    }
+    getAllMemories(repo) {
+        this.ensureOpen();
+        let rows;
+        if (repo) {
+            rows = this.db
+                .prepare("SELECT * FROM memories WHERE repo = ? ORDER BY timestamp DESC")
+                .all(repo);
+        }
+        else {
+            rows = this.db
+                .prepare("SELECT * FROM memories ORDER BY timestamp DESC")
+                .all();
+        }
+        return rows.map((r) => this.rowToMemory(r));
+    }
+    updateMemory(id, updates) {
+        this.ensureOpen();
+        const existing = this.getMemory(id);
+        if (!existing)
+            return;
+        const merged = { ...existing, ...updates };
+        this.addMemory(merged);
+    }
+    deleteMemory(id) {
+        this.ensureOpen();
+        this.db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+    }
+    updateQualityScore(id, delta) {
+        this.ensureOpen();
+        this.db
+            .prepare("UPDATE experiences SET quality = MIN(1.0, MAX(0.0, quality + ?)) WHERE id = ?")
+            .run(delta, id);
+        this.db
+            .prepare("UPDATE memories SET quality = MIN(1.0, MAX(0.0, quality + ?)) WHERE id = ?")
+            .run(delta, id);
+    }
+    // ── Validation results ────────────────────────────────
+    save(result) {
+        this.ensureOpen();
+        this.db
+            .prepare(`INSERT INTO validation_results
+         (repo, type, passed, command, output, errors, duration, exit_code)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(null, // repo — not in ValidationResult type
+        result.type, result.passed ? 1 : 0, result.command, result.output, JSON.stringify(result.errors ?? []), result.duration ?? null, result.exitCode ?? null);
+    }
+    getLatest(limit = 10) {
+        this.ensureOpen();
+        const rows = this.db
+            .prepare("SELECT * FROM validation_results ORDER BY created_at DESC LIMIT ?")
+            .all(limit);
+        return rows.map((r) => ({
+            type: r.type,
+            passed: r.passed === 1,
+            command: r.command,
+            output: r.output,
+            errors: r.errors ? JSON.parse(r.errors) : [],
+            duration: r.duration,
+            exitCode: r.exit_code ?? null,
+        }));
+    }
+    // ── Maintenance ───────────────────────────────────────
+    vacuum() {
+        this.ensureOpen();
+        this.db.exec("VACUUM");
+    }
+    backup(destPath) {
+        this.ensureOpen();
+        this.db.backup(destPath);
+    }
+    // ── Helpers ──────────────────────────────────────────
+    ensureOpen() {
+        if (!this.db) {
+            throw new Error("Store not opened. Call store.open() first.");
+        }
+    }
+    rowToSymbol(row) {
+        const json = (v, fallback) => {
+            const s = String(v ?? fallback);
+            try {
+                return JSON.parse(s);
+            }
+            catch {
+                return [];
+            }
+        };
+        return {
+            name: String(row.name ?? ""),
+            kind: String(row.kind ?? "unknown"),
+            file: String(row.file ?? ""),
+            line: Number(row.line ?? 0),
+            column: Number(row.column ?? 0),
+            signature: String(row.signature ?? ""),
+            summary: String(row.summary ?? ""),
+            imports: json(row.imports, "[]"),
+            calls: json(row.calls, "[]"),
+            calledBy: json(row.called_by, "[]"),
+            relatedTests: json(row.related_tests, "[]"),
+            commitSha: String(row.commit_sha ?? ""),
+            repoFingerprint: String(row.repo_fingerprint ?? ""),
+        };
+    }
+    rowToExperience(row) {
+        return {
+            id: row.id,
+            task: row.task,
+            diagnosis: row.diagnosis,
+            solution: row.solution,
+            changedFiles: JSON.parse(row.changed_files),
+            commit: row.commit,
+            validation: JSON.parse(row.validation ?? "[]"),
+            failedAttempts: JSON.parse(row.failed_attempts ?? "[]"),
+            evidence: row.evidence ? JSON.parse(row.evidence) : undefined,
+            quality: row.quality,
+            timestamp: row.timestamp,
+            repo: row.repo,
+            type: row.type,
+        };
+    }
+    rowToMemory(row) {
+        return {
+            id: row.id,
+            type: row.type,
+            content: row.content,
+            symbols: row.symbols ? JSON.parse(row.symbols) : [],
+            files: row.files ? JSON.parse(row.files) : [],
+            commit: row.commit ?? null,
+            quality: row.quality,
+            timestamp: row.timestamp,
+            repo: row.repo,
+            source: row.source,
+        };
+    }
+}
+// ─── Factory ───────────────────────────────────────────────
+let globalStore = null;
+export function getStore(dbPath) {
+    if (!globalStore) {
+        globalStore = new SQLiteStore(dbPath);
+        globalStore.open();
+        globalStore.migrate();
+    }
+    return globalStore;
+}
+export function closeStore() {
+    if (globalStore) {
+        globalStore.close();
+        globalStore = null;
+    }
+}
+/** CamelCase / snake_case splitting for fuzzy symbol matching. */
+export function nameSegmentVocab(name) {
+    if (!name)
+        return [];
+    // Split on camelCase boundaries + non-alphanumeric
+    // "getUserData" → ["get", "User", "Data"]
+    // "SymbolIndexer" → ["Symbol", "Indexer"]
+    // "parse_file_name" → ["parse", "file", "name"]
+    const parts = name
+        .replace(/([A-Z])/g, " $1")
+        .replace(/[_-]+/g, " ")
+        .replace(/[^a-zA-Z0-9 ]/g, "")
+        .split(/\s+/)
+        .filter(Boolean);
+    // Only return segments that are useful (skip single chars)
+    return parts.filter(s => s.length > 1);
+}
+//# sourceMappingURL=sqlite.js.map