@mcp-graph-workflow/mcp-graph 3.0.0

package/dist/core/store/sqlite-store.js

@@ -0,0 +1,707 @@
+import Database from "better-sqlite3";
+import { mkdirSync, existsSync, renameSync } from "node:fs";
+import path from "node:path";
+import { buildIndexes } from "../graph/graph-indexes.js";
+import { generateId } from "../utils/id.js";
+import { now } from "../utils/time.js";
+import { configureDb, runMigrations } from "./migrations.js";
+import { logger } from "../utils/logger.js";
+import { GraphNotInitializedError, ValidationError, SnapshotNotFoundError } from "../utils/errors.js";
+import { GraphNodeSchema } from "../../schemas/node.schema.js";
+import { GraphEdgeSchema } from "../../schemas/edge.schema.js";
+import { z } from "zod/v4";
+import { STORE_DIR, LEGACY_STORE_DIR, DB_FILE } from "../utils/constants.js";
+// ── Mapping helpers ──────────────────────────────────────
+function nodeToRow(node, projectId) {
+    return {
+        id: node.id,
+        project_id: projectId,
+        type: node.type,
+        title: node.title,
+        description: node.description ?? null,
+        status: node.status,
+        priority: node.priority,
+        xp_size: node.xpSize ?? null,
+        estimate_minutes: node.estimateMinutes ?? null,
+        tags: node.tags ? JSON.stringify(node.tags) : null,
+        parent_id: node.parentId ?? null,
+        sprint: node.sprint ?? null,
+        source_file: node.sourceRef?.file ?? null,
+        source_start_line: node.sourceRef?.startLine ?? null,
+        source_end_line: node.sourceRef?.endLine ?? null,
+        source_confidence: node.sourceRef?.confidence ?? null,
+        acceptance_criteria: node.acceptanceCriteria
+            ? JSON.stringify(node.acceptanceCriteria)
+            : null,
+        blocked: node.blocked ? 1 : 0,
+        metadata: node.metadata ? JSON.stringify(node.metadata) : null,
+        created_at: node.createdAt,
+        updated_at: node.updatedAt,
+    };
+}
+function rowToNode(row) {
+    const node = {
+        id: row.id,
+        type: row.type,
+        title: row.title,
+        status: row.status,
+        priority: row.priority,
+        blocked: row.blocked === 1,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+    if (row.description)
+        node.description = row.description;
+    if (row.xp_size)
+        node.xpSize = row.xp_size;
+    if (row.estimate_minutes != null)
+        node.estimateMinutes = row.estimate_minutes;
+    if (row.tags)
+        node.tags = JSON.parse(row.tags);
+    if (row.parent_id)
+        node.parentId = row.parent_id;
+    if (row.sprint)
+        node.sprint = row.sprint;
+    if (row.acceptance_criteria)
+        node.acceptanceCriteria = JSON.parse(row.acceptance_criteria);
+    if (row.metadata)
+        node.metadata = JSON.parse(row.metadata);
+    if (row.source_file) {
+        const ref = { file: row.source_file };
+        if (row.source_start_line != null)
+            ref.startLine = row.source_start_line;
+        if (row.source_end_line != null)
+            ref.endLine = row.source_end_line;
+        if (row.source_confidence != null)
+            ref.confidence = row.source_confidence;
+        node.sourceRef = ref;
+    }
+    return node;
+}
+function edgeToRow(edge, projectId) {
+    return {
+        id: edge.id,
+        project_id: projectId,
+        from_node: edge.from,
+        to_node: edge.to,
+        relation_type: edge.relationType,
+        weight: edge.weight ?? null,
+        reason: edge.reason ?? null,
+        metadata: edge.metadata ? JSON.stringify(edge.metadata) : null,
+        created_at: edge.createdAt,
+    };
+}
+function rowToEdge(row) {
+    const edge = {
+        id: row.id,
+        from: row.from_node,
+        to: row.to_node,
+        relationType: row.relation_type,
+        createdAt: row.created_at,
+    };
+    if (row.weight != null)
+        edge.weight = row.weight;
+    if (row.reason)
+        edge.reason = row.reason;
+    if (row.metadata)
+        edge.metadata = JSON.parse(row.metadata);
+    return edge;
+}
+// ── SqliteStore ──────────────────────────────────────────
+export class SqliteStore {
+    db;
+    projectId = null;
+    _eventBus = null;
+    constructor(db) {
+        this.db = db;
+    }
+    /** Attach an event bus to emit mutation events */
+    set eventBus(bus) {
+        this._eventBus = bus;
+    }
+    get eventBus() {
+        return this._eventBus;
+    }
+    /**
+     * Open (or create) a store at basePath/workflow-graph/graph.db.
+     * Pass ":memory:" for in-memory testing.
+     *
+     * Handles automatic migration from legacy `.mcp-graph/` directory:
+     * - If only `.mcp-graph/` exists → rename to `workflow-graph/`
+     * - If both exist → use `workflow-graph/`, log warning
+     * - If neither → create `workflow-graph/`
+     */
+    static open(basePath = process.cwd()) {
+        let db;
+        if (basePath === ":memory:") {
+            db = new Database(":memory:");
+        }
+        else {
+            const newDir = path.join(basePath, STORE_DIR);
+            const legacyDir = path.join(basePath, LEGACY_STORE_DIR);
+            const legacyExists = existsSync(legacyDir);
+            const newExists = existsSync(newDir);
+            if (legacyExists && !newExists) {
+                renameSync(legacyDir, newDir);
+                logger.info("Migrated store directory", { from: LEGACY_STORE_DIR, to: STORE_DIR });
+            }
+            else if (legacyExists && newExists) {
+                logger.warn("Both legacy and new store directories exist, using new", {
+                    legacy: LEGACY_STORE_DIR,
+                    active: STORE_DIR,
+                });
+            }
+            mkdirSync(newDir, { recursive: true });
+            db = new Database(path.join(newDir, DB_FILE));
+        }
+        configureDb(db);
+        runMigrations(db);
+        const store = new SqliteStore(db);
+        // Auto-load project if one exists
+        const row = db
+            .prepare("SELECT id FROM projects LIMIT 1")
+            .get();
+        if (row)
+            store.projectId = row.id;
+        logger.info(`Store opened${basePath === ":memory:" ? " (in-memory)" : ` at ${basePath}`}`);
+        return store;
+    }
+    /** Expose the raw database instance for extension modules (e.g. DocsCacheStore). */
+    getDb() {
+        return this.db;
+    }
+    close() {
+        this.db.close();
+    }
+    // ── Project ──────────────────────────────────────
+    initProject(name) {
+        // If no name provided and project already active, return current
+        if (this.projectId && !name) {
+            return this.getProject();
+        }
+        // If name provided, check if same as current project
+        if (this.projectId && name) {
+            const current = this.getProject();
+            if (current.name === name) {
+                return current;
+            }
+            // Check if a project with this name already exists
+            const existing = this.db
+                .prepare("SELECT * FROM projects WHERE name = ?")
+                .get(name);
+            if (existing) {
+                this.projectId = existing.id;
+                logger.info("Project activated by name", { name, projectId: existing.id });
+                return {
+                    id: existing.id,
+                    name: existing.name,
+                    createdAt: existing.created_at,
+                    updatedAt: existing.updated_at,
+                };
+            }
+        }
+        // No active project, or different name — create new
+        const projectName = name || "Local MCP Graph";
+        const id = generateId("proj");
+        const timestamp = now();
+        this.db
+            .prepare("INSERT INTO projects (id, name, created_at, updated_at) VALUES (?, ?, ?, ?)")
+            .run(id, projectName, timestamp, timestamp);
+        this.projectId = id;
+        logger.info(`Project initialized: ${projectName} (${id})`);
+        return { id, name: projectName, createdAt: timestamp, updatedAt: timestamp };
+    }
+    getProject() {
+        if (!this.projectId)
+            return null;
+        const row = this.db
+            .prepare("SELECT * FROM projects WHERE id = ?")
+            .get(this.projectId);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            name: row.name,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+    /** Alias for getProject — returns the currently active project. */
+    getActiveProject() {
+        return this.getProject();
+    }
+    /** List all projects in the database. */
+    listProjects() {
+        const rows = this.db
+            .prepare("SELECT * FROM projects ORDER BY created_at")
+            .all();
+        return rows.map((row) => ({
+            id: row.id,
+            name: row.name,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        }));
+    }
+    /** Switch the active project. Throws if project ID does not exist. */
+    activateProject(projectId) {
+        const row = this.db
+            .prepare("SELECT id FROM projects WHERE id = ?")
+            .get(projectId);
+        if (!row) {
+            throw new ValidationError(`Project not found: ${projectId}`, []);
+        }
+        this.projectId = projectId;
+        logger.info("Project activated", { projectId });
+    }
+    ensureProject() {
+        if (!this.projectId) {
+            throw new GraphNotInitializedError();
+        }
+        return this.projectId;
+    }
+    // ── Nodes ────────────────────────────────────────
+    insertNode(node) {
+        try {
+            GraphNodeSchema.parse(node);
+        }
+        catch (err) {
+            if (err instanceof z.ZodError) {
+                throw new ValidationError("Invalid node", err.issues);
+            }
+            throw err;
+        }
+        const pid = this.ensureProject();
+        const row = nodeToRow(node, pid);
+        this.db
+            .prepare(`INSERT INTO nodes
+          (id, project_id, type, title, description, status, priority,
+           xp_size, estimate_minutes, tags, parent_id, sprint,
+           source_file, source_start_line, source_end_line, source_confidence,
+           acceptance_criteria, blocked, metadata, created_at, updated_at)
+         VALUES
+          (@id, @project_id, @type, @title, @description, @status, @priority,
+           @xp_size, @estimate_minutes, @tags, @parent_id, @sprint,
+           @source_file, @source_start_line, @source_end_line, @source_confidence,
+           @acceptance_criteria, @blocked, @metadata, @created_at, @updated_at)`)
+            .run(row);
+        this._eventBus?.emitTyped("node:created", { nodeId: node.id, title: node.title, nodeType: node.type });
+    }
+    getNodeById(id) {
+        this.ensureProject();
+        const row = this.db
+            .prepare("SELECT * FROM nodes WHERE id = ? AND project_id = ?")
+            .get(id, this.projectId);
+        return row ? rowToNode(row) : null;
+    }
+    getAllNodes() {
+        const pid = this.ensureProject();
+        const rows = this.db
+            .prepare("SELECT * FROM nodes WHERE project_id = ? ORDER BY created_at")
+            .all(pid);
+        return rows.map(rowToNode);
+    }
+    getNodesByType(type) {
+        const pid = this.ensureProject();
+        const rows = this.db
+            .prepare("SELECT * FROM nodes WHERE project_id = ? AND type = ? ORDER BY created_at")
+            .all(pid, type);
+        return rows.map(rowToNode);
+    }
+    getNodesByStatus(status) {
+        const pid = this.ensureProject();
+        const rows = this.db
+            .prepare("SELECT * FROM nodes WHERE project_id = ? AND status = ? ORDER BY created_at")
+            .all(pid, status);
+        return rows.map(rowToNode);
+    }
+    getChildNodes(parentId) {
+        const pid = this.ensureProject();
+        const rows = this.db
+            .prepare("SELECT * FROM nodes WHERE project_id = ? AND parent_id = ? ORDER BY created_at")
+            .all(pid, parentId);
+        return rows.map(rowToNode);
+    }
+    updateNodeStatus(id, status) {
+        const pid = this.ensureProject();
+        const timestamp = now();
+        const result = this.db
+            .prepare("UPDATE nodes SET status = ?, updated_at = ? WHERE id = ? AND project_id = ?")
+            .run(status, timestamp, id, pid);
+        if (result.changes === 0)
+            return null;
+        this._eventBus?.emitTyped("node:updated", { nodeId: id, fields: ["status"] });
+        return this.getNodeById(id);
+    }
+    updateNode(id, fields) {
+        const pid = this.ensureProject();
+        const existing = this.getNodeById(id);
+        if (!existing)
+            return null;
+        const setClauses = [];
+        const params = [];
+        if (fields.title !== undefined) {
+            setClauses.push("title = ?");
+            params.push(fields.title);
+        }
+        if (fields.description !== undefined) {
+            setClauses.push("description = ?");
+            params.push(fields.description ?? null);
+        }
+        if (fields.type !== undefined) {
+            setClauses.push("type = ?");
+            params.push(fields.type);
+        }
+        if (fields.priority !== undefined) {
+            setClauses.push("priority = ?");
+            params.push(fields.priority);
+        }
+        if (fields.xpSize !== undefined) {
+            setClauses.push("xp_size = ?");
+            params.push(fields.xpSize ?? null);
+        }
+        if (fields.estimateMinutes !== undefined) {
+            setClauses.push("estimate_minutes = ?");
+            params.push(fields.estimateMinutes ?? null);
+        }
+        if (fields.tags !== undefined) {
+            setClauses.push("tags = ?");
+            params.push(fields.tags ? JSON.stringify(fields.tags) : null);
+        }
+        if (fields.parentId !== undefined) {
+            setClauses.push("parent_id = ?");
+            params.push(fields.parentId ?? null);
+        }
+        if (fields.sprint !== undefined) {
+            setClauses.push("sprint = ?");
+            params.push(fields.sprint ?? null);
+        }
+        if (fields.blocked !== undefined) {
+            setClauses.push("blocked = ?");
+            params.push(fields.blocked ? 1 : 0);
+        }
+        if (fields.acceptanceCriteria !== undefined) {
+            setClauses.push("acceptance_criteria = ?");
+            params.push(fields.acceptanceCriteria
+                ? JSON.stringify(fields.acceptanceCriteria)
+                : null);
+        }
+        if (fields.metadata !== undefined) {
+            setClauses.push("metadata = ?");
+            params.push(fields.metadata ? JSON.stringify(fields.metadata) : null);
+        }
+        if (setClauses.length === 0)
+            return existing;
+        const timestamp = now();
+        setClauses.push("updated_at = ?");
+        params.push(timestamp);
+        params.push(id, pid);
+        this.db
+            .prepare(`UPDATE nodes SET ${setClauses.join(", ")} WHERE id = ? AND project_id = ?`)
+            .run(...params);
+        this._eventBus?.emitTyped("node:updated", { nodeId: id, fields: Object.keys(fields) });
+        return this.getNodeById(id);
+    }
+    deleteNode(id) {
+        const pid = this.ensureProject();
+        logger.debug("tx:delete-node", { id });
+        return this.db.transaction(() => {
+            // Delete edges referencing this node
+            this.db
+                .prepare("DELETE FROM edges WHERE project_id = ? AND (from_node = ? OR to_node = ?)")
+                .run(pid, id, id);
+            const result = this.db
+                .prepare("DELETE FROM nodes WHERE id = ? AND project_id = ?")
+                .run(id, pid);
+            const deleted = result.changes > 0;
+            if (deleted)
+                this._eventBus?.emitTyped("node:deleted", { nodeId: id });
+            return deleted;
+        })();
+    }
+    deleteEdge(id) {
+        const pid = this.ensureProject();
+        const result = this.db
+            .prepare("DELETE FROM edges WHERE id = ? AND project_id = ?")
+            .run(id, pid);
+        const deleted = result.changes > 0;
+        if (deleted)
+            this._eventBus?.emitTyped("edge:deleted", { edgeId: id });
+        return deleted;
+    }
+    // ── Edges ────────────────────────────────────────
+    insertEdge(edge) {
+        try {
+            GraphEdgeSchema.parse(edge);
+        }
+        catch (err) {
+            if (err instanceof z.ZodError) {
+                throw new ValidationError("Invalid edge", err.issues);
+            }
+            throw err;
+        }
+        const pid = this.ensureProject();
+        const row = edgeToRow(edge, pid);
+        this.db
+            .prepare(`INSERT INTO edges
+          (id, project_id, from_node, to_node, relation_type, weight, reason, metadata, created_at)
+         VALUES
+          (@id, @project_id, @from_node, @to_node, @relation_type, @weight, @reason, @metadata, @created_at)`)
+            .run(row);
+        this._eventBus?.emitTyped("edge:created", { edgeId: edge.id, from: edge.from, to: edge.to, relationType: edge.relationType });
+    }
+    getEdgesFrom(nodeId) {
+        const pid = this.ensureProject();
+        const rows = this.db
+            .prepare("SELECT * FROM edges WHERE project_id = ? AND from_node = ?")
+            .all(pid, nodeId);
+        return rows.map(rowToEdge);
+    }
+    getEdgesTo(nodeId) {
+        const pid = this.ensureProject();
+        const rows = this.db
+            .prepare("SELECT * FROM edges WHERE project_id = ? AND to_node = ?")
+            .all(pid, nodeId);
+        return rows.map(rowToEdge);
+    }
+    getAllEdges() {
+        const pid = this.ensureProject();
+        const rows = this.db
+            .prepare("SELECT * FROM edges WHERE project_id = ? ORDER BY created_at")
+            .all(pid);
+        return rows.map(rowToEdge);
+    }
+    // ── Import cleanup ─────────────────────────────────
+    /**
+     * Check if a source file has been previously imported.
+     */
+    hasImport(sourceFile) {
+        const pid = this.ensureProject();
+        const row = this.db
+            .prepare("SELECT 1 FROM import_history WHERE project_id = ? AND source_file = ? LIMIT 1")
+            .get(pid, sourceFile);
+        return row !== undefined;
+    }
+    /**
+     * Delete all nodes (and their edges) that were imported from a specific source file.
+     * Also removes the import history entry so re-import is clean.
+     */
+    clearImportedNodes(sourceFile) {
+        const pid = this.ensureProject();
+        logger.debug("tx:clear-imported", { sourceFile });
+        return this.db.transaction(() => {
+            // Find node IDs from this source file
+            const nodeIds = this.db
+                .prepare("SELECT id FROM nodes WHERE project_id = ? AND source_file = ?")
+                .all(pid, sourceFile);
+            let edgesDeleted = 0;
+            for (const { id } of nodeIds) {
+                const result = this.db
+                    .prepare("DELETE FROM edges WHERE project_id = ? AND (from_node = ? OR to_node = ?)")
+                    .run(pid, id, id);
+                edgesDeleted += result.changes;
+            }
+            const nodesResult = this.db
+                .prepare("DELETE FROM nodes WHERE project_id = ? AND source_file = ?")
+                .run(pid, sourceFile);
+            // Clear import history for this source file
+            this.db
+                .prepare("DELETE FROM import_history WHERE project_id = ? AND source_file = ?")
+                .run(pid, sourceFile);
+            const result = { nodesDeleted: nodesResult.changes, edgesDeleted };
+            this._eventBus?.emitTyped("bulk:updated", { count: result.nodesDeleted + result.edgesDeleted, operation: "clearImportedNodes" });
+            return result;
+        })();
+    }
+    // ── Bulk ─────────────────────────────────────────
+    bulkInsert(nodes, edges) {
+        const pid = this.ensureProject();
+        logger.info(`Bulk insert: ${nodes.length} nodes, ${edges.length} edges`);
+        logger.debug("tx:bulk-insert:start");
+        this.db.transaction(() => {
+            for (const node of nodes) {
+                const row = nodeToRow(node, pid);
+                this.db
+                    .prepare(`INSERT INTO nodes
+              (id, project_id, type, title, description, status, priority,
+               xp_size, estimate_minutes, tags, parent_id, sprint,
+               source_file, source_start_line, source_end_line, source_confidence,
+               acceptance_criteria, blocked, metadata, created_at, updated_at)
+             VALUES
+              (@id, @project_id, @type, @title, @description, @status, @priority,
+               @xp_size, @estimate_minutes, @tags, @parent_id, @sprint,
+               @source_file, @source_start_line, @source_end_line, @source_confidence,
+               @acceptance_criteria, @blocked, @metadata, @created_at, @updated_at)`)
+                    .run(row);
+            }
+            for (const edge of edges) {
+                const row = edgeToRow(edge, pid);
+                this.db
+                    .prepare(`INSERT INTO edges
+              (id, project_id, from_node, to_node, relation_type, weight, reason, metadata, created_at)
+             VALUES
+              (@id, @project_id, @from_node, @to_node, @relation_type, @weight, @reason, @metadata, @created_at)`)
+                    .run(row);
+            }
+        })();
+        logger.debug("tx:bulk-insert:done");
+        this._eventBus?.emitTyped("import:completed", { nodesCreated: nodes.length, edgesCreated: edges.length });
+    }
+    // ── Snapshots ────────────────────────────────────
+    createSnapshot() {
+        const pid = this.ensureProject();
+        const doc = this.toGraphDocument();
+        const result = this.db
+            .prepare("INSERT INTO snapshots (project_id, data, created_at) VALUES (?, ?, ?)")
+            .run(pid, JSON.stringify(doc), now());
+        return result.lastInsertRowid;
+    }
+    // ── Import history ───────────────────────────────
+    recordImport(sourceFile, nodesCreated, edgesCreated) {
+        const pid = this.ensureProject();
+        this.db
+            .prepare(`INSERT INTO import_history (project_id, source_file, nodes_created, edges_created, imported_at)
+         VALUES (?, ?, ?, ?, ?)`)
+            .run(pid, sourceFile, nodesCreated, edgesCreated, now());
+    }
+    // ── Stats ────────────────────────────────────────
+    getStats() {
+        const pid = this.ensureProject();
+        const totalNodes = this.db
+            .prepare("SELECT COUNT(*) as c FROM nodes WHERE project_id = ?")
+            .get(pid).c;
+        const totalEdges = this.db
+            .prepare("SELECT COUNT(*) as c FROM edges WHERE project_id = ?")
+            .get(pid).c;
+        const byType = {};
+        const typeRows = this.db
+            .prepare("SELECT type, COUNT(*) as c FROM nodes WHERE project_id = ? GROUP BY type")
+            .all(pid);
+        for (const r of typeRows)
+            byType[r.type] = r.c;
+        const byStatus = {};
+        const statusRows = this.db
+            .prepare("SELECT status, COUNT(*) as c FROM nodes WHERE project_id = ? GROUP BY status")
+            .all(pid);
+        for (const r of statusRows)
+            byStatus[r.status] = r.c;
+        return { totalNodes, totalEdges, byType, byStatus };
+    }
+    // ── Full-text search ─────────────────────────────
+    /**
+     * Search nodes using FTS5 with BM25 ranking.
+     * Returns nodes ordered by relevance score.
+     */
+    searchNodes(query, limit = 20) {
+        const pid = this.ensureProject();
+        // FTS5 match query — escape user input for safety
+        const rows = this.db
+            .prepare(`SELECT n.*, bm25(nodes_fts) AS score
+         FROM nodes_fts fts
+         JOIN nodes n ON n.rowid = fts.rowid
+         WHERE nodes_fts MATCH ?
+           AND n.project_id = ?
+         ORDER BY score
+         LIMIT ?`)
+            .all(query, pid, limit);
+        return rows.map((row) => ({
+            ...rowToNode(row),
+            score: row.score,
+        }));
+    }
+    // ── Bulk status update ─────────────────────────
+    bulkUpdateStatus(ids, status) {
+        this.ensureProject();
+        logger.debug("tx:bulk-update-status", { count: ids.length, status });
+        const updated = [];
+        const notFound = [];
+        this.db.transaction(() => {
+            for (const id of ids) {
+                const result = this.updateNodeStatus(id, status);
+                if (result) {
+                    updated.push(id);
+                }
+                else {
+                    notFound.push(id);
+                }
+            }
+        })();
+        return { updated, notFound };
+    }
+    // ── Restore snapshot ──────────────────────────
+    restoreSnapshot(snapshotId) {
+        const pid = this.ensureProject();
+        logger.debug("tx:restore-snapshot", { snapshotId });
+        const row = this.db
+            .prepare("SELECT data FROM snapshots WHERE rowid = ? AND project_id = ?")
+            .get(snapshotId, pid);
+        if (!row) {
+            throw new SnapshotNotFoundError(snapshotId);
+        }
+        const doc = JSON.parse(row.data);
+        this.db.transaction(() => {
+            this.db.prepare("DELETE FROM edges WHERE project_id = ?").run(pid);
+            this.db.prepare("DELETE FROM nodes WHERE project_id = ?").run(pid);
+            for (const node of doc.nodes) {
+                const r = nodeToRow(node, pid);
+                this.db
+                    .prepare(`INSERT INTO nodes
+              (id, project_id, type, title, description, status, priority,
+               xp_size, estimate_minutes, tags, parent_id, sprint,
+               source_file, source_start_line, source_end_line, source_confidence,
+               acceptance_criteria, blocked, metadata, created_at, updated_at)
+             VALUES
+              (@id, @project_id, @type, @title, @description, @status, @priority,
+               @xp_size, @estimate_minutes, @tags, @parent_id, @sprint,
+               @source_file, @source_start_line, @source_end_line, @source_confidence,
+               @acceptance_criteria, @blocked, @metadata, @created_at, @updated_at)`)
+                    .run(r);
+            }
+            for (const edge of doc.edges) {
+                const r = edgeToRow(edge, pid);
+                this.db
+                    .prepare(`INSERT INTO edges
+              (id, project_id, from_node, to_node, relation_type, weight, reason, metadata, created_at)
+             VALUES
+              (@id, @project_id, @from_node, @to_node, @relation_type, @weight, @reason, @metadata, @created_at)`)
+                    .run(r);
+            }
+        })();
+    }
+    listSnapshots() {
+        const pid = this.ensureProject();
+        const rows = this.db
+            .prepare("SELECT id, created_at FROM snapshots WHERE project_id = ? ORDER BY id DESC")
+            .all(pid);
+        return rows.map((r) => ({ snapshotId: r.id, createdAt: r.created_at }));
+    }
+    // ── Bridge: materialize full GraphDocument ───────
+    toGraphDocument() {
+        const project = this.getProject();
+        if (!project) {
+            throw new GraphNotInitializedError();
+        }
+        const nodes = this.getAllNodes();
+        const edges = this.getAllEdges();
+        const indexes = buildIndexes(nodes, edges);
+        // Collect source files from import history
+        const pid = this.ensureProject();
+        const imports = this.db
+            .prepare("SELECT DISTINCT source_file FROM import_history WHERE project_id = ?")
+            .all(pid);
+        const lastImportRow = this.db
+            .prepare("SELECT imported_at FROM import_history WHERE project_id = ? ORDER BY imported_at DESC LIMIT 1")
+            .get(pid);
+        return {
+            version: "1.0.0",
+            project,
+            nodes,
+            edges,
+            indexes,
+            meta: {
+                sourceFiles: imports.map((r) => r.source_file),
+                lastImport: lastImportRow?.imported_at ?? null,
+            },
+        };
+    }
+}
+//# sourceMappingURL=sqlite-store.js.map