@psnext/lscg 0.1.2 → 0.1.4

package/dist/src/storage/database.js

@@ -1,563 +1,13 @@
-import { mkdirSync } from 'node:fs';
-import path from 'node:path';
-import { DatabaseSync } from 'node:sqlite';
-import { hashParts } from '../graph/extract.js';
-import { CREATE_NODES_TABLE_SQL, CREATE_SCHEMA_SQL, SCHEMA_VERSION } from './schema.js';
-export function openGraphDatabase(databasePath) {
-    mkdirSync(path.dirname(databasePath), { recursive: true });
-    const db = new DatabaseSync(databasePath);
-    db.exec('PRAGMA foreign_keys = ON;');
-    db.exec('PRAGMA journal_mode = WAL;');
-    db.exec(CREATE_SCHEMA_SQL);
-    ensureSchemaVersion(db);
-    return db;
-}
-export function openReadOnlyGraphDatabase(databasePath) {
-    const db = new DatabaseSync(databasePath, { readOnly: true });
-    db.exec('PRAGMA foreign_keys = ON;');
-    return db;
-}
-export function closeDatabase(db) {
-    db.close();
-}
-export function upsertRepository(db, repository) {
-    db.prepare(`
-    INSERT INTO repositories(id, root, name, updated_at)
-    VALUES (?, ?, ?, datetime('now'))
-    ON CONFLICT(id) DO UPDATE SET
-      root = excluded.root,
-      name = excluded.name,
-      updated_at = datetime('now')
-  `).run(repository.id, repository.root, repository.name);
-}
-export function replaceFileGraph(db, { repository, file, nodes, edges, attribution }) {
-    upsertRepository(db, repository);
-    db.exec('BEGIN IMMEDIATE');
-    try {
-        if (attribution) {
-            upsertContributorNodes(db, repository, attribution.contributorEmails);
-        }
-        db.prepare('DELETE FROM edges WHERE file_id = ?').run(file.id);
-        db.prepare('DELETE FROM nodes WHERE file_id = ?').run(file.id);
-        db.prepare(`
-      INSERT INTO files(id, repository_id, path, language, hash, size, mtime_ms, scanned_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))
-      ON CONFLICT(repository_id, path) DO UPDATE SET
-        id = excluded.id,
-        language = excluded.language,
-        hash = excluded.hash,
-        size = excluded.size,
-        mtime_ms = excluded.mtime_ms,
-        scanned_at = datetime('now')
-    `).run(file.id, repository.id, file.path, file.language, file.hash, file.size, file.mtimeMs);
-        const insertNode = db.prepare(`
-      INSERT INTO nodes(
-        id, repository_id, file_id, kind, type, name, start_byte, end_byte,
-        start_point, end_point, source_hash, parser, parser_version, metadata_json, last_modified_user_id
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        const attributionByNodeId = new Map(attribution?.nodeAttributions.map((entry) => [entry.nodeId, entry]) ?? []);
-        for (const node of nodes) {
-            const nodeAttribution = attributionByNodeId.get(node.id);
-            insertNode.run(node.id, repository.id, file.id, node.kind, node.type, node.name ?? null, node.startByte, node.endByte, JSON.stringify(node.startPoint), JSON.stringify(node.endPoint), node.sourceHash, node.parser, node.parserVersion, JSON.stringify(node.metadata ?? {}), node.lastModifiedUserId ?? resolveUserId(repository, nodeAttribution?.lastModifiedEmail ?? null));
-        }
-        const insertEdge = db.prepare(`
-      INSERT INTO edges(
-        id, repository_id, file_id, source_id, target_id, kind, confidence, metadata_json
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        for (const edge of edges) {
-            insertEdge.run(edge.id, repository.id, file.id, edge.sourceId, edge.targetId, edge.kind, edge.confidence ?? 1, JSON.stringify(edge.metadata ?? {}));
-        }
-        if (attribution) {
-            for (const entry of attribution.nodeAttributions) {
-                for (const email of entry.contributorEmails) {
-                    const contributorId = resolveUserId(repository, email);
-                    if (!contributorId)
-                        continue;
-                    insertEdge.run(hashParts([repository.id, file.id, entry.nodeId, contributorId, 'attributed_to']), repository.id, file.id, entry.nodeId, contributorId, 'attributed_to', 1, JSON.stringify({ email }));
-                }
-            }
-        }
-        db.exec('COMMIT');
-    }
-    catch (error) {
-        db.exec('ROLLBACK');
-        throw error;
-    }
-}
-export function getStatus(db, repositoryId) {
-    const repository = db.prepare('SELECT * FROM repositories WHERE id = ?').get(repositoryId);
-    const files = db.prepare('SELECT count(*) AS count FROM files WHERE repository_id = ?').get(repositoryId).count;
-    const nodes = db.prepare('SELECT count(*) AS count FROM nodes WHERE repository_id = ?').get(repositoryId).count;
-    const edges = db.prepare('SELECT count(*) AS count FROM edges WHERE repository_id = ?').get(repositoryId).count;
-    return { repository: repository ?? null, files, nodes, edges };
-}
-export function selectNodes(db, repositoryId, { kind, limit = 50 } = {}) {
-    const safeLimit = clampLimit(limit);
-    if (kind) {
-        return db.prepare(`
-      SELECT id, kind, type, name, file_id AS fileId, start_byte AS startByte, end_byte AS endByte, metadata_json AS metadataJson, last_modified_user_id AS lastModifiedUserId
-      FROM nodes
-      WHERE repository_id = ? AND kind = ?
-      ORDER BY name IS NULL, name, id
-      LIMIT ?
-    `).all(repositoryId, kind, safeLimit);
-    }
-    return db.prepare(`
-    SELECT id, kind, type, name, file_id AS fileId, start_byte AS startByte, end_byte AS endByte, metadata_json AS metadataJson, last_modified_user_id AS lastModifiedUserId
-    FROM nodes
-    WHERE repository_id = ?
-    ORDER BY kind, name IS NULL, name, id
-    LIMIT ?
-  `).all(repositoryId, safeLimit);
-}
-export function selectNodeTextRows(db, repositoryId, { kind, term, limit = 50 } = {}) {
-    const predicates = ['n.repository_id = ?'];
-    const params = [repositoryId];
-    if (kind) {
-        predicates.push('n.kind = ?');
-        params.push(kind);
-    }
-    if (term) {
-        predicates.push('lower(COALESCE(n.name, \'\')) LIKE ?');
-        params.push(`%${term.toLocaleLowerCase()}%`);
-    }
-    const rows = db.prepare(`
-    SELECT n.id, n.kind, n.type, n.name, n.file_id AS fileId,
-      n.start_byte AS startByte, n.end_byte AS endByte,
-      n.start_point AS startPoint, n.end_point AS endPoint,
-      n.metadata_json AS metadataJson, n.last_modified_user_id AS lastModifiedUserId,
-      f.path AS path
-    FROM nodes n LEFT JOIN files f ON f.id = n.file_id
-    WHERE ${predicates.join(' AND ')}
-    ORDER BY n.kind, n.name IS NULL, n.name, n.id
-    LIMIT ?
-  `).all(...params, clampLimit(limit));
-    return rows.map((row) => ({
-        ...row,
-        startPoint: parsePoint(row.startPoint),
-        endPoint: parsePoint(row.endPoint)
-    }));
-}
-export function selectAllNodes(db, repositoryId, { kind } = {}) {
-    if (kind) {
-        return db.prepare(`
-      SELECT id, kind, type, name, file_id AS fileId, start_byte AS startByte, end_byte AS endByte, metadata_json AS metadataJson, last_modified_user_id AS lastModifiedUserId
-      FROM nodes
-      WHERE repository_id = ? AND kind = ?
-      ORDER BY name IS NULL, name, id
-    `).all(repositoryId, kind);
-    }
-    return db.prepare(`
-    SELECT id, kind, type, name, file_id AS fileId, start_byte AS startByte, end_byte AS endByte, metadata_json AS metadataJson, last_modified_user_id AS lastModifiedUserId
-    FROM nodes
-    WHERE repository_id = ?
-    ORDER BY kind, name IS NULL, name, id
-  `).all(repositoryId);
-}
-export function selectEdges(db, repositoryId, { kind, limit = 50 } = {}) {
-    const safeLimit = clampLimit(limit);
-    if (kind) {
-        return db.prepare(`
-      SELECT id, kind, source_id AS sourceId, target_id AS targetId, file_id AS fileId, confidence, metadata_json AS metadataJson
-      FROM edges
-      WHERE repository_id = ? AND kind = ?
-      ORDER BY kind, id
-      LIMIT ?
-    `).all(repositoryId, kind, safeLimit);
-    }
-    return db.prepare(`
-    SELECT id, kind, source_id AS sourceId, target_id AS targetId, file_id AS fileId, confidence, metadata_json AS metadataJson
-    FROM edges
-    WHERE repository_id = ?
-    ORDER BY kind, id
-    LIMIT ?
-  `).all(repositoryId, safeLimit);
-}
-export function selectAllEdges(db, repositoryId, { kind } = {}) {
-    if (kind) {
-        return db.prepare(`
-      SELECT id, kind, source_id AS sourceId, target_id AS targetId, file_id AS fileId, confidence, metadata_json AS metadataJson
-      FROM edges
-      WHERE repository_id = ? AND kind = ?
-      ORDER BY kind, id
-    `).all(repositoryId, kind);
-    }
-    return db.prepare(`
-    SELECT id, kind, source_id AS sourceId, target_id AS targetId, file_id AS fileId, confidence, metadata_json AS metadataJson
-    FROM edges
-    WHERE repository_id = ?
-    ORDER BY kind, id
-  `).all(repositoryId);
-}
-/** Candidate lookup used by context. Stages are queried independently so a unique
- * higher-priority match never gets merged with lower-priority fuzzy matches. */
-export function selectContextCandidates(db, repositoryId, term, { kind, file, limit = 20 } = {}) {
-    const safeLimit = clampLimit(limit, 100);
-    const normalized = term.trim().toLocaleLowerCase();
-    if (!normalized)
-        return [];
-    const rows = [];
-    const seen = new Set();
-    const stages = [
-        { match: 'qualified', condition: "(lower(f.path || ':' || COALESCE(n.name, '')) = ? OR lower(f.path || '::' || COALESCE(n.name, '')) = ?)", value: normalized },
-        { match: 'exact', condition: 'lower(n.name) = ?', value: normalized },
-        { match: 'prefix', condition: 'lower(n.name) LIKE ?', value: `${normalized}%` },
-        { match: 'substring', condition: 'lower(n.name) LIKE ?', value: `%${normalized}%` }
-    ];
-    for (let stage = 0; stage < stages.length; stage += 1) {
-        const entry = stages[stage];
-        if (!entry)
-            continue;
-        const predicates = [`n.repository_id = ?`, entry.condition];
-        const params = [repositoryId, entry.value, entry.value];
-        if (!kind)
-            predicates.push("n.kind IN ('symbol', 'file')");
-        if (entry.match !== 'qualified')
-            params.pop();
-        if (kind) {
-            predicates.push('n.kind = ?');
-            params.push(kind);
-        }
-        if (file) {
-            predicates.push('f.path = ?');
-            params.push(file);
-        }
-        const selected = db.prepare(`
-      SELECT n.id, n.kind, n.type, n.name, n.file_id AS fileId,
-        n.start_point AS startPoint, n.end_point AS endPoint, n.source_hash AS sourceHash,
-        n.parser, n.parser_version AS parserVersion, n.metadata_json AS metadataJson,
-        f.path AS path
-      FROM nodes n LEFT JOIN files f ON f.id = n.file_id
-      WHERE ${predicates.join(' AND ')}
-      ORDER BY lower(COALESCE(f.path, '')), n.kind, lower(COALESCE(n.name, '')), n.id
-      LIMIT ?
-    `).all(...params, safeLimit);
-        for (const row of selected) {
-            const id = String(row.id);
-            if (seen.has(id))
-                continue;
-            seen.add(id);
-            rows.push({
-                ...contextReferenceFromRow(row),
-                rank: stage,
-                match: entry.match,
-                stage
-            });
-        }
-        // A unique exact/qualified match is authoritative. Prefix and substring are
-        // only consulted when no higher-priority stage produced a result.
-        if (rows.length > 0)
-            break;
-    }
-    return rows.map(({ stage: _stage, ...candidate }) => candidate);
-}
-export function selectContextRelationships(db, repositoryId, anchorId, limit = 50, maxDepth = 1) {
-    const safeLimit = clampLimit(limit, 500);
-    const safeDepth = Math.max(1, Math.min(Number(maxDepth) || 1, 5));
-    const rows = [];
-    const seenNodes = new Set([anchorId]);
-    const seenEdges = new Set();
-    let frontier = [anchorId];
-    const kinds = ['calls', 'imports', 'exports'];
-    for (let depth = 1; depth <= safeDepth && frontier.length > 0; depth += 1) {
-        const next = new Set();
-        for (const kind of kinds) {
-            const remaining = safeLimit - rows.filter((row) => row.edgeKind === kind).length;
-            if (remaining <= 0)
-                continue;
-            const placeholders = frontier.map(() => '?').join(', ');
-            const selected = db.prepare(`
-        SELECT e.id AS edgeId, e.kind AS edgeKind, e.confidence, e.metadata_json AS edgeMetadata,
-          s.id AS sourceId, s.kind AS sourceKind, s.type AS sourceType, s.name AS sourceName,
-          s.start_point AS sourceStartPoint, s.end_point AS sourceEndPoint, s.source_hash AS sourceHash,
-          s.parser AS sourceParser, s.parser_version AS sourceParserVersion, s.metadata_json AS sourceMetadata,
-          sf.path AS sourcePath,
-          t.id AS targetId, t.kind AS targetKind, t.type AS targetType, t.name AS targetName,
-          t.start_point AS targetStartPoint, t.end_point AS targetEndPoint, t.source_hash AS targetHash,
-          t.parser AS targetParser, t.parser_version AS targetParserVersion, t.metadata_json AS targetMetadata,
-          tf.path AS targetPath
-        FROM edges e
-        JOIN nodes s ON s.id = e.source_id AND s.repository_id = e.repository_id
-        JOIN nodes t ON t.id = e.target_id AND t.repository_id = e.repository_id
-        LEFT JOIN files sf ON sf.id = s.file_id
-        LEFT JOIN files tf ON tf.id = t.file_id
-        WHERE e.repository_id = ? AND e.kind = ?
-          AND (e.source_id IN (${placeholders}) OR e.target_id IN (${placeholders}))
-        ORDER BY COALESCE(sf.path, tf.path), e.id
-        LIMIT ?
-      `).all(repositoryId, kind, ...frontier, ...frontier, remaining);
-            for (const row of selected) {
-                const edgeId = String(row.edgeId);
-                if (seenEdges.has(edgeId))
-                    continue;
-                seenEdges.add(edgeId);
-                rows.push({ ...row, depth });
-                const sourceId = String(row.sourceId);
-                const targetId = String(row.targetId);
-                if (seenNodes.has(sourceId))
-                    next.add(targetId);
-                if (seenNodes.has(targetId))
-                    next.add(sourceId);
-            }
-        }
-        for (const nodeId of next)
-            seenNodes.add(nodeId);
-        frontier = [...next].filter((nodeId) => nodeId !== anchorId);
-    }
-    return rows.map((row) => ({
-        edgeId: String(row.edgeId),
-        edgeKind: row.edgeKind,
-        source: contextReferenceFromRow({
-            id: row.sourceId, kind: row.sourceKind, type: row.sourceType, name: row.sourceName,
-            startPoint: row.sourceStartPoint, endPoint: row.sourceEndPoint, sourceHash: row.sourceHash,
-            parser: row.sourceParser, parserVersion: row.sourceParserVersion, metadataJson: row.sourceMetadata,
-            path: row.sourcePath
-        }),
-        target: contextReferenceFromRow({
-            id: row.targetId, kind: row.targetKind, type: row.targetType, name: row.targetName,
-            startPoint: row.targetStartPoint, endPoint: row.targetEndPoint, sourceHash: row.targetHash,
-            parser: row.targetParser, parserVersion: row.targetParserVersion, metadataJson: row.targetMetadata,
-            path: row.targetPath
-        }),
-        confidence: Number(row.confidence ?? 0),
-        metadata: parseMetadata(row.edgeMetadata),
-        depth: row.depth
-    }));
-}
-export function reconcileDeletedFiles(db, repositoryId, discoveredPaths) {
-    const existing = db.prepare('SELECT path FROM files WHERE repository_id = ?').all(repositoryId);
-    const keep = new Set(discoveredPaths);
-    db.exec('BEGIN IMMEDIATE');
-    try {
-        for (const row of existing) {
-            if (!keep.has(row.path))
-                db.prepare('DELETE FROM files WHERE repository_id = ? AND path = ?').run(repositoryId, row.path);
-        }
-        db.exec('COMMIT');
-    }
-    catch (error) {
-        db.exec('ROLLBACK');
-        throw error;
-    }
-}
-export function selectFileInventory(db, repositoryId) {
-    return db.prepare('SELECT path, size, mtime_ms AS mtimeMs FROM files WHERE repository_id = ? ORDER BY path').all(repositoryId);
-}
-function contextReferenceFromRow(row) {
-    return {
-        id: String(row.id),
-        path: row.path == null ? null : String(row.path),
-        kind: row.kind,
-        type: String(row.type),
-        name: row.name == null ? null : String(row.name),
-        span: { start: parsePoint(row.startPoint), end: parsePoint(row.endPoint) },
-        sourceHash: row.sourceHash == null ? null : String(row.sourceHash),
-        parser: row.parser == null ? null : String(row.parser),
-        parserVersion: row.parserVersion == null ? null : String(row.parserVersion),
-        metadata: parseMetadata(row.metadataJson),
-        fileId: row.fileId == null ? null : String(row.fileId)
-    };
-}
-function parsePoint(value) {
-    if (typeof value === 'string') {
-        try {
-            const point = JSON.parse(value);
-            return { row: Number(point.row ?? 0), column: Number(point.column ?? 0) };
-        }
-        catch { /* fall through */ }
-    }
-    return { row: 0, column: 0 };
-}
-function parseMetadata(value) {
-    if (typeof value !== 'string')
-        return {};
-    try {
-        const parsed = JSON.parse(value);
-        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
-    }
-    catch {
-        return {};
-    }
-}
-export function selectCallGraph(db, repositoryId, term, { kind, depth = 5, limit = 100 } = {}) {
-    const safeDepth = Math.max(1, Math.min(Number(depth) || 1, 5));
-    const safeLimit = clampLimit(limit, 500);
-    const nodes = selectAllNodes(db, repositoryId);
-    const edges = selectAllEdges(db, repositoryId);
-    const nodeById = new Map(nodes.map((node) => [node.id, node]));
-    const needle = term.toLocaleLowerCase();
-    const matches = nodes.filter((node) => (!kind || node.kind === kind) && node.name?.toLocaleLowerCase().includes(needle));
-    const walk = (startId, direction) => {
-        const relations = [];
-        const seen = new Set([startId]);
-        let frontier = [startId];
-        for (let currentDepth = 1; currentDepth <= safeDepth && frontier.length > 0; currentDepth += 1) {
-            const next = [];
-            for (const nodeId of frontier) {
-                for (const edge of edges) {
-                    const adjacentId = direction === 'upstream'
-                        ? edge.targetId === nodeId ? edge.sourceId : null
-                        : edge.sourceId === nodeId ? edge.targetId : null;
-                    if (!adjacentId || seen.has(adjacentId))
-                        continue;
-                    const adjacent = nodeById.get(adjacentId);
-                    if (!adjacent)
-                        continue;
-                    seen.add(adjacentId);
-                    next.push(adjacentId);
-                    relations.push({
-                        id: adjacent.id,
-                        kind: adjacent.kind,
-                        type: adjacent.type,
-                        name: adjacent.name,
-                        viaEdgeId: edge.id,
-                        edgeKind: edge.kind,
-                        depth: currentDepth
-                    });
-                    if (relations.length >= safeLimit)
-                        return relations;
-                }
-            }
-            frontier = next;
-        }
-        return relations;
-    };
-    return matches.slice(0, safeLimit).map((node) => ({
-        ...node,
-        upstream: walk(node.id, 'upstream'),
-        downstream: walk(node.id, 'downstream')
-    }));
-}
-export function selectNeighbors(db, repositoryId, nodeId, { depth = 1, limit = 100 } = {}) {
-    const safeDepth = Math.max(1, Math.min(Number(depth) || 1, 5));
-    const safeLimit = clampLimit(limit, 500);
-    return db.prepare(`
-    WITH RECURSIVE walk(node_id, via_edge_id, depth) AS (
-      SELECT ?, NULL, 0
-      UNION ALL
-      SELECT
-        CASE WHEN e.source_id = walk.node_id THEN e.target_id ELSE e.source_id END,
-        e.id,
-        walk.depth + 1
-      FROM walk
-      JOIN edges e ON e.repository_id = ? AND (e.source_id = walk.node_id OR e.target_id = walk.node_id)
-      WHERE walk.depth < ?
-    )
-    SELECT DISTINCT
-      n.id, n.kind, n.type, n.name, w.via_edge_id AS viaEdgeId, w.depth
-    FROM walk w
-    JOIN nodes n ON n.id = w.node_id
-    WHERE n.repository_id = ?
-    ORDER BY w.depth, n.kind, n.name
-    LIMIT ?
-  `).all(nodeId, repositoryId, safeDepth, repositoryId, safeLimit);
-}
-export function runSelect(db, sql, { limit = 200 } = {}) {
-    const trimmed = sql.trim();
-    if (!/^(select|with|pragma)\b/i.test(trimmed)) {
-        throw new Error('Only read-only SELECT, WITH, and PRAGMA queries are allowed');
-    }
-    const rows = db.prepare(trimmed).all();
-    return rows.slice(0, clampLimit(limit, 1000));
-}
-export function attachDatabase(db, alias, databasePath) {
-    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(alias)) {
-        throw new Error(`Unsafe SQLite attachment alias: ${alias}`);
-    }
-    const escapedPath = databasePath.replaceAll("'", "''");
-    db.exec(`ATTACH DATABASE '${escapedPath}' AS ${alias}`);
-}
-function ensureSchemaVersion(db) {
-    const currentVersion = getCurrentSchemaVersion(db);
-    if (currentVersion === 0) {
-        db.prepare('INSERT OR IGNORE INTO schema_migrations(version) VALUES (?)').run(SCHEMA_VERSION);
-        return;
-    }
-    if (currentVersion >= SCHEMA_VERSION)
-        return;
-    if (currentVersion === 1) {
-        migrateSchemaV1ToV2(db);
-        db.prepare('INSERT OR IGNORE INTO schema_migrations(version) VALUES (?)').run(SCHEMA_VERSION);
-        return;
-    }
-    throw new Error(`Unsupported schema version: ${currentVersion}`);
-}
-function getCurrentSchemaVersion(db) {
-    const row = db.prepare('SELECT COALESCE(MAX(version), 0) AS version FROM schema_migrations').get();
-    return Number(row?.version ?? 0);
-}
-function migrateSchemaV1ToV2(db) {
-    db.exec('PRAGMA foreign_keys = OFF;');
-    db.exec('BEGIN IMMEDIATE');
-    try {
-        db.exec(`DROP TABLE IF EXISTS nodes_new;`);
-        db.exec(CREATE_NODES_TABLE_SQL);
-        db.exec(`
-      INSERT INTO nodes_new(
-        id, repository_id, file_id, kind, type, name, start_byte, end_byte,
-        start_point, end_point, source_hash, parser, parser_version, metadata_json, last_modified_user_id
-      )
-      SELECT
-        id, repository_id, file_id, kind, type, name, start_byte, end_byte,
-        start_point, end_point, source_hash, parser, parser_version, metadata_json, NULL
-      FROM nodes;
-    `);
-        db.exec('DROP TABLE nodes;');
-        db.exec('ALTER TABLE nodes_new RENAME TO nodes;');
-        db.exec('CREATE INDEX IF NOT EXISTS idx_nodes_repo_kind ON nodes(repository_id, kind);');
-        db.exec('CREATE INDEX IF NOT EXISTS idx_nodes_repo_name ON nodes(repository_id, name);');
-        db.exec('COMMIT');
-    }
-    catch (error) {
-        db.exec('ROLLBACK');
-        throw error;
-    }
-    finally {
-        db.exec('PRAGMA foreign_keys = ON;');
-    }
-}
-function upsertContributorNodes(db, repository, contributorEmails) {
-    const insertNode = db.prepare(`
-    INSERT INTO nodes(
-      id, repository_id, file_id, kind, type, name, start_byte, end_byte,
-      start_point, end_point, source_hash, parser, parser_version, metadata_json, last_modified_user_id
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(id) DO UPDATE SET
-      repository_id = excluded.repository_id,
-      file_id = excluded.file_id,
-      kind = excluded.kind,
-      type = excluded.type,
-      name = excluded.name,
-      start_byte = excluded.start_byte,
-      end_byte = excluded.end_byte,
-      start_point = excluded.start_point,
-      end_point = excluded.end_point,
-      source_hash = excluded.source_hash,
-      parser = excluded.parser,
-      parser_version = excluded.parser_version,
-      metadata_json = excluded.metadata_json,
-      last_modified_user_id = excluded.last_modified_user_id
-  `);
-    for (const contributor of contributorEmails) {
-        const normalizedEmail = normalizeEmail(contributor.email);
-        if (!normalizedEmail)
-            continue;
-        insertNode.run(resolveUserId(repository, normalizedEmail), repository.id, null, 'user', 'git_user', normalizedEmail, 0, 0, JSON.stringify({ row: 0, column: 0 }), JSON.stringify({ row: 0, column: 0 }), hashParts([repository.id, 'user', normalizedEmail, 'source']), 'git', 'blame-v1', JSON.stringify({ email: normalizedEmail }), null);
-    }
-}
-function resolveUserId(repository, email) {
-    const normalizedEmail = normalizeEmail(email);
-    if (!normalizedEmail)
-        return null;
-    return hashParts([repository.id, 'user', normalizedEmail]);
-}
-function normalizeEmail(value) {
-    return value?.trim().replace(/^<|>$/g, '').toLowerCase() ?? '';
-}
-function clampLimit(limit, max = 500) {
-    const value = Number(limit) || 50;
-    return Math.max(1, Math.min(value, max));
-}
+/**
+ * Compatibility facade for the storage API. Keep consumers importing this module
+ * while the implementation stays split into focused modules small enough for
+ * Tree-sitter and easier to maintain.
+ */
+export * from './connection.js';
+export * from './plugin-contributions.js';
+export * from './graph-writes.js';
+export * from './plugin-graph.js';
+export * from './queries.js';
+export * from './context-queries.js';
+export * from './traversal-queries.js';
 //# sourceMappingURL=database.js.map

package/dist/src/storage/graph-writes.d.ts

@@ -0,0 +1,17 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { FileAttribution, FileRecord, GraphEdge, GraphNode, RepositoryRecord } from '../types.js';
+export declare function upsertRepository(db: DatabaseSync, repository: RepositoryRecord): void;
+export declare function replaceFileGraph(db: DatabaseSync, { repository, file, nodes, edges, attribution }: {
+    repository: RepositoryRecord;
+    file: FileRecord;
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    attribution?: FileAttribution | null;
+}): void;
+export declare function reconcileDeletedFiles(db: DatabaseSync, repositoryId: string, discoveredPaths: string[]): void;
+export declare function selectFileInventory(db: DatabaseSync, repositoryId: string): Array<{
+    path: string;
+    size: number;
+    mtimeMs: number;
+}>;
+//# sourceMappingURL=graph-writes.d.ts.map