@psnext/lscg 0.1.2 → 0.1.4

package/dist/src/storage/graph-writes.js

@@ -0,0 +1,126 @@
+import { DatabaseSync } from 'node:sqlite';
+import { hashParts } from '../graph/extract.js';
+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 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 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() ?? '';
+}
+//# sourceMappingURL=graph-writes.js.map

package/dist/src/storage/plugin-contributions.d.ts

@@ -0,0 +1,15 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { GraphEdge, GraphNode, RepositoryRecord } from '../types.js';
+export interface StoredPluginContribution {
+    pluginName: string;
+    generation: number;
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+}
+export declare function loadPluginContributions(db: DatabaseSync, repository: RepositoryRecord, pluginNames: readonly string[]): Map<string, StoredPluginContribution>;
+export declare function persistPluginContributions(db: DatabaseSync, repository: RepositoryRecord, contributions: ReadonlyMap<string, {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+}>, generation: number): void;
+export declare function nextPluginGeneration(db: DatabaseSync, repository: RepositoryRecord): number;
+//# sourceMappingURL=plugin-contributions.d.ts.map

package/dist/src/storage/plugin-contributions.js

@@ -0,0 +1,28 @@
+import { DatabaseSync } from 'node:sqlite';
+export function loadPluginContributions(db, repository, pluginNames) {
+    if (pluginNames.length === 0)
+        return new Map();
+    const placeholders = pluginNames.map(() => '?').join(', ');
+    const rows = db.prepare(`SELECT plugin_name AS pluginName, generation, nodes_json AS nodesJson, edges_json AS edgesJson FROM plugin_contributions WHERE repository_id = ? AND plugin_name IN (${placeholders})`).all(repository.id, ...pluginNames);
+    return new Map(rows.map((row) => [row.pluginName, { pluginName: row.pluginName, generation: row.generation, nodes: JSON.parse(row.nodesJson), edges: JSON.parse(row.edgesJson) }]));
+}
+export function persistPluginContributions(db, repository, contributions, generation) {
+    if (contributions.size === 0)
+        return;
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        const upsert = db.prepare(`INSERT INTO plugin_contributions(repository_id, plugin_name, generation, nodes_json, edges_json) VALUES (?, ?, ?, ?, ?) ON CONFLICT(repository_id, plugin_name) DO UPDATE SET generation = excluded.generation, nodes_json = excluded.nodes_json, edges_json = excluded.edges_json, updated_at = datetime('now')`);
+        for (const [pluginName, contribution] of contributions)
+            upsert.run(repository.id, pluginName, generation, JSON.stringify(contribution.nodes), JSON.stringify(contribution.edges));
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+}
+export function nextPluginGeneration(db, repository) {
+    const row = db.prepare('SELECT COALESCE(MAX(generation), 0) AS generation FROM plugin_contributions WHERE repository_id = ?').get(repository.id);
+    return row.generation + 1;
+}
+//# sourceMappingURL=plugin-contributions.js.map

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

@@ -0,0 +1,6 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { GraphEdge, GraphNode, RepositoryRecord } from '../types.js';
+export declare function reconcilePluginEdges(db: DatabaseSync, repository: RepositoryRecord, edges: GraphEdge[], fileIdByPath: Map<string, string>, activePlugins: readonly string[]): number;
+export declare function reconcileRepositoryPluginNodes(db: DatabaseSync, repository: RepositoryRecord, activePlugins: readonly string[]): void;
+export declare function insertRepositoryPluginNodes(db: DatabaseSync, repository: RepositoryRecord, nodes: GraphNode[]): void;
+//# sourceMappingURL=plugin-graph.d.ts.map

package/dist/src/storage/plugin-graph.js

@@ -0,0 +1,81 @@
+import path from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+export function reconcilePluginEdges(db, repository, edges, fileIdByPath, activePlugins) {
+    if (activePlugins.length === 0)
+        return 0;
+    let inserted = 0;
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        for (const plugin of activePlugins) {
+            db.prepare(`
+        DELETE FROM edges
+        WHERE repository_id = ? AND json_extract(metadata_json, '$.plugin') = ?
+      `).run(repository.id, plugin);
+        }
+        const insert = db.prepare(`
+      INSERT OR REPLACE INTO edges(id, repository_id, file_id, source_id, target_id, kind, confidence, metadata_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        for (const edge of edges) {
+            const plugin = typeof edge.metadata.plugin === 'string' ? edge.metadata.plugin : undefined;
+            if (!plugin || !activePlugins.includes(plugin))
+                continue;
+            const filePath = typeof edge.metadata.filePath === 'string' ? edge.metadata.filePath : undefined;
+            const normalizedPath = filePath ? normalizePluginFilePath(filePath) : undefined;
+            const fileId = normalizedPath ? fileIdByPath.get(normalizedPath) : null;
+            if (filePath && !fileId)
+                continue;
+            const endpoints = db.prepare('SELECT count(*) AS count FROM nodes WHERE repository_id = ? AND id IN (?, ?)').get(repository.id, edge.sourceId, edge.targetId);
+            const requiredEndpoints = edge.sourceId === edge.targetId ? 1 : 2;
+            if (endpoints.count !== requiredEndpoints)
+                continue;
+            insert.run(edge.id, repository.id, fileId, edge.sourceId, edge.targetId, edge.kind, edge.confidence ?? 1, JSON.stringify(edge.metadata ?? {}));
+            inserted += 1;
+        }
+        db.exec('COMMIT');
+        return inserted;
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+}
+export function reconcileRepositoryPluginNodes(db, repository, activePlugins) {
+    if (activePlugins.length === 0)
+        return;
+    const placeholders = activePlugins.map(() => '?').join(', ');
+    db.prepare(`
+    DELETE FROM nodes
+    WHERE repository_id = ? AND file_id IS NULL
+      AND json_extract(metadata_json, '$.plugin') IN (${placeholders})
+  `).run(repository.id, ...activePlugins);
+}
+export function insertRepositoryPluginNodes(db, repository, nodes) {
+    const repositoryNodes = nodes.filter((node) => typeof node.metadata.filePath !== 'string');
+    if (repositoryNodes.length === 0)
+        return;
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        const insert = db.prepare(`
+      INSERT OR REPLACE 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 (?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        for (const node of repositoryNodes) {
+            insert.run(node.id, repository.id, node.kind, node.type, node.name, node.startByte, node.endByte, JSON.stringify(node.startPoint), JSON.stringify(node.endPoint), node.sourceHash, node.parser, node.parserVersion, JSON.stringify(node.metadata ?? {}), node.lastModifiedUserId);
+        }
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+}
+function normalizePluginFilePath(value) {
+    const normalized = path.posix.normalize(value.replaceAll('\\', '/'));
+    if (path.posix.isAbsolute(normalized) || normalized === '..' || normalized.startsWith('../'))
+        return undefined;
+    return normalized.replace(/^\.\//, '');
+}
+//# sourceMappingURL=plugin-graph.js.map

package/dist/src/storage/queries.d.ts

@@ -0,0 +1,25 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { GraphEdgeRow, GraphNodeRow, GraphNodeTextRow, StatusResult } from '../types.js';
+export declare function getStatus(db: DatabaseSync, repositoryId: string): StatusResult;
+export declare function selectNodes(db: DatabaseSync, repositoryId: string, { kind, limit }?: {
+    kind?: string | undefined;
+    limit?: number | undefined;
+}): GraphNodeRow[];
+export declare function selectNodeTextRows(db: DatabaseSync, repositoryId: string, { kind, term, limit }?: {
+    kind?: string | undefined;
+    term?: string | undefined;
+    limit?: number | undefined;
+}): GraphNodeTextRow[];
+export declare function selectAllNodeTextRows(db: DatabaseSync, repositoryId: string): GraphNodeTextRow[];
+export declare function selectAllNodes(db: DatabaseSync, repositoryId: string, { kind }?: {
+    kind?: string | undefined;
+}): GraphNodeRow[];
+export declare function selectEdges(db: DatabaseSync, repositoryId: string, { kind, limit }?: {
+    kind?: string | undefined;
+    limit?: number | undefined;
+}): GraphEdgeRow[];
+export declare function selectAllEdges(db: DatabaseSync, repositoryId: string, { kind }?: {
+    kind?: string | undefined;
+}): GraphEdgeRow[];
+export declare function clampLimit(limit: number | undefined, max?: number): number;
+//# sourceMappingURL=queries.d.ts.map

package/dist/src/storage/queries.js

@@ -0,0 +1,129 @@
+import { DatabaseSync } from 'node:sqlite';
+import { parsePoint } from './row-decoders.js';
+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 selectAllNodeTextRows(db, repositoryId) {
+    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 n.repository_id = ?
+    ORDER BY n.kind, n.name IS NULL, n.name, n.id
+  `).all(repositoryId);
+    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);
+}
+export function clampLimit(limit, max = 500) {
+    const value = Number(limit) || 50;
+    return Math.max(1, Math.min(value, max));
+}
+//# sourceMappingURL=queries.js.map

package/dist/src/storage/row-decoders.d.ts

@@ -0,0 +1,8 @@
+import type { ContextNodeRow } from './context-queries.js';
+export declare function contextReferenceFromRow(row: Record<string, unknown>): ContextNodeRow;
+export declare function parsePoint(value: unknown): {
+    row: number;
+    column: number;
+};
+export declare function parseMetadata(value: unknown): Record<string, unknown>;
+//# sourceMappingURL=row-decoders.d.ts.map

package/dist/src/storage/row-decoders.js

@@ -0,0 +1,37 @@
+export 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)
+    };
+}
+export 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 };
+}
+export 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 {};
+    }
+}
+//# sourceMappingURL=row-decoders.js.map

package/dist/src/storage/schema.d.ts

@@ -1,4 +1,4 @@
-export declare const SCHEMA_VERSION = 2;
-export declare const CREATE_SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS schema_migrations (\n  version INTEGER PRIMARY KEY,\n  applied_at TEXT NOT NULL DEFAULT (datetime('now'))\n);\n\nCREATE TABLE IF NOT EXISTS repositories (\n  id TEXT PRIMARY KEY,\n  root TEXT NOT NULL,\n  name TEXT NOT NULL,\n  created_at TEXT NOT NULL DEFAULT (datetime('now')),\n  updated_at TEXT NOT NULL DEFAULT (datetime('now'))\n);\n\nCREATE TABLE IF NOT EXISTS files (\n  id TEXT PRIMARY KEY,\n  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,\n  path TEXT NOT NULL,\n  language TEXT NOT NULL,\n  hash TEXT NOT NULL,\n  size INTEGER NOT NULL,\n  mtime_ms INTEGER NOT NULL,\n  scanned_at TEXT NOT NULL DEFAULT (datetime('now')),\n  UNIQUE(repository_id, path)\n);\n\nCREATE TABLE IF NOT EXISTS nodes (\n  id TEXT PRIMARY KEY,\n  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,\n  file_id TEXT REFERENCES files(id) ON DELETE CASCADE,\n  kind TEXT NOT NULL,\n  type TEXT NOT NULL,\n  name TEXT,\n  start_byte INTEGER NOT NULL,\n  end_byte INTEGER NOT NULL,\n  start_point TEXT NOT NULL,\n  end_point TEXT NOT NULL,\n  source_hash TEXT NOT NULL,\n  parser TEXT NOT NULL,\n  parser_version TEXT NOT NULL,\n  metadata_json TEXT NOT NULL DEFAULT '{}',\n  last_modified_user_id TEXT\n);\n\nCREATE TABLE IF NOT EXISTS edges (\n  id TEXT PRIMARY KEY,\n  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,\n  file_id TEXT NOT NULL REFERENCES files(id) ON DELETE CASCADE,\n  source_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,\n  target_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,\n  kind TEXT NOT NULL,\n  confidence REAL NOT NULL DEFAULT 1.0,\n  metadata_json TEXT NOT NULL DEFAULT '{}'\n);\n\nCREATE TABLE IF NOT EXISTS overlays (\n  id TEXT PRIMARY KEY,\n  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,\n  subject_id TEXT NOT NULL,\n  subject_kind TEXT NOT NULL,\n  operation TEXT NOT NULL,\n  metadata_json TEXT NOT NULL DEFAULT '{}',\n  created_at TEXT NOT NULL DEFAULT (datetime('now'))\n);\n\nCREATE INDEX IF NOT EXISTS idx_files_repo_path ON files(repository_id, path);\nCREATE INDEX IF NOT EXISTS idx_nodes_repo_kind ON nodes(repository_id, kind);\nCREATE INDEX IF NOT EXISTS idx_nodes_repo_name ON nodes(repository_id, name);\nCREATE INDEX IF NOT EXISTS idx_edges_repo_kind ON edges(repository_id, kind);\nCREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);\nCREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);\n";
+export declare const SCHEMA_VERSION = 4;
+export declare const CREATE_SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS schema_migrations (\n  version INTEGER PRIMARY KEY,\n  applied_at TEXT NOT NULL DEFAULT (datetime('now'))\n);\n\nCREATE TABLE IF NOT EXISTS repositories (\n  id TEXT PRIMARY KEY,\n  root TEXT NOT NULL,\n  name TEXT NOT NULL,\n  created_at TEXT NOT NULL DEFAULT (datetime('now')),\n  updated_at TEXT NOT NULL DEFAULT (datetime('now'))\n);\n\nCREATE TABLE IF NOT EXISTS files (\n  id TEXT PRIMARY KEY,\n  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,\n  path TEXT NOT NULL,\n  language TEXT NOT NULL,\n  hash TEXT NOT NULL,\n  size INTEGER NOT NULL,\n  mtime_ms INTEGER NOT NULL,\n  scanned_at TEXT NOT NULL DEFAULT (datetime('now')),\n  UNIQUE(repository_id, path)\n);\n\nCREATE TABLE IF NOT EXISTS nodes (\n  id TEXT PRIMARY KEY,\n  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,\n  file_id TEXT REFERENCES files(id) ON DELETE CASCADE,\n  kind TEXT NOT NULL,\n  type TEXT NOT NULL,\n  name TEXT,\n  start_byte INTEGER NOT NULL,\n  end_byte INTEGER NOT NULL,\n  start_point TEXT NOT NULL,\n  end_point TEXT NOT NULL,\n  source_hash TEXT NOT NULL,\n  parser TEXT NOT NULL,\n  parser_version TEXT NOT NULL,\n  metadata_json TEXT NOT NULL DEFAULT '{}',\n  last_modified_user_id TEXT\n);\n\nCREATE TABLE IF NOT EXISTS edges (\n  id TEXT PRIMARY KEY,\n  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,\n  file_id TEXT REFERENCES files(id) ON DELETE CASCADE,\n  source_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,\n  target_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,\n  kind TEXT NOT NULL,\n  confidence REAL NOT NULL DEFAULT 1.0,\n  metadata_json TEXT NOT NULL DEFAULT '{}'\n);\n\nCREATE TABLE IF NOT EXISTS overlays (\n  id TEXT PRIMARY KEY,\n  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,\n  subject_id TEXT NOT NULL,\n  subject_kind TEXT NOT NULL,\n  operation TEXT NOT NULL,\n  metadata_json TEXT NOT NULL DEFAULT '{}',\n  created_at TEXT NOT NULL DEFAULT (datetime('now'))\n);\n\nCREATE INDEX IF NOT EXISTS idx_files_repo_path ON files(repository_id, path);\nCREATE INDEX IF NOT EXISTS idx_nodes_repo_kind ON nodes(repository_id, kind);\nCREATE INDEX IF NOT EXISTS idx_nodes_repo_name ON nodes(repository_id, name);\nCREATE INDEX IF NOT EXISTS idx_edges_repo_kind ON edges(repository_id, kind);\nCREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);\nCREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);\n\nCREATE TABLE IF NOT EXISTS plugin_contributions (\n  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,\n  plugin_name TEXT NOT NULL,\n  generation INTEGER NOT NULL,\n  nodes_json TEXT NOT NULL,\n  edges_json TEXT NOT NULL,\n  updated_at TEXT NOT NULL DEFAULT (datetime('now')),\n  PRIMARY KEY(repository_id, plugin_name)\n);\nCREATE INDEX IF NOT EXISTS idx_plugin_contributions_repo ON plugin_contributions(repository_id);\n";
 export declare const CREATE_NODES_TABLE_SQL = "\nCREATE TABLE nodes_new (\n  id TEXT PRIMARY KEY,\n  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,\n  file_id TEXT REFERENCES files(id) ON DELETE CASCADE,\n  kind TEXT NOT NULL,\n  type TEXT NOT NULL,\n  name TEXT,\n  start_byte INTEGER NOT NULL,\n  end_byte INTEGER NOT NULL,\n  start_point TEXT NOT NULL,\n  end_point TEXT NOT NULL,\n  source_hash TEXT NOT NULL,\n  parser TEXT NOT NULL,\n  parser_version TEXT NOT NULL,\n  metadata_json TEXT NOT NULL DEFAULT '{}',\n  last_modified_user_id TEXT\n);\n";
 //# sourceMappingURL=schema.d.ts.map

package/dist/src/storage/schema.js

@@ -1,4 +1,4 @@
-export const SCHEMA_VERSION = 2;
+export const SCHEMA_VERSION = 4;
 export const CREATE_SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS schema_migrations (
   version INTEGER PRIMARY KEY,
@@ -46,7 +46,7 @@ CREATE TABLE IF NOT EXISTS nodes (
 CREATE TABLE IF NOT EXISTS edges (
   id TEXT PRIMARY KEY,
   repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
-  file_id TEXT NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+  file_id TEXT REFERENCES files(id) ON DELETE CASCADE,
   source_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
   target_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
   kind TEXT NOT NULL,
@@ -70,6 +70,17 @@ CREATE INDEX IF NOT EXISTS idx_nodes_repo_name ON nodes(repository_id, name);
 CREATE INDEX IF NOT EXISTS idx_edges_repo_kind ON edges(repository_id, kind);
 CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);
 CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);
+
+CREATE TABLE IF NOT EXISTS plugin_contributions (
+  repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
+  plugin_name TEXT NOT NULL,
+  generation INTEGER NOT NULL,
+  nodes_json TEXT NOT NULL,
+  edges_json TEXT NOT NULL,
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  PRIMARY KEY(repository_id, plugin_name)
+);
+CREATE INDEX IF NOT EXISTS idx_plugin_contributions_repo ON plugin_contributions(repository_id);
 `;
 export const CREATE_NODES_TABLE_SQL = `
 CREATE TABLE nodes_new (

package/dist/src/storage/traversal-queries.d.ts

@@ -0,0 +1,15 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { CallGraphMatch, NeighborRow } from '../types.js';
+export declare function selectCallGraph(db: DatabaseSync, repositoryId: string, term: string, { kind, depth, limit }?: {
+    kind?: string | undefined;
+    depth?: number | undefined;
+    limit?: number | undefined;
+}): CallGraphMatch[];
+export declare function selectNeighbors(db: DatabaseSync, repositoryId: string, nodeId: string, { depth, limit }?: {
+    depth?: number | undefined;
+    limit?: number | undefined;
+}): NeighborRow[];
+export declare function runSelect(db: DatabaseSync, sql: string, { limit }?: {
+    limit?: number | undefined;
+}): Array<Record<string, unknown>>;
+//# sourceMappingURL=traversal-queries.d.ts.map

package/dist/src/storage/traversal-queries.js

@@ -0,0 +1,87 @@
+import { DatabaseSync } from 'node:sqlite';
+import { selectAllEdges, selectAllNodeTextRows, clampLimit } from './queries.js';
+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 = selectAllNodeTextRows(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,
+                        path: adjacent.path,
+                        startPoint: adjacent.startPoint,
+                        parentId: nodeId,
+                        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));
+}
+//# sourceMappingURL=traversal-queries.js.map

package/dist/src/types.d.ts

@@ -1,8 +1,8 @@
 import type Parser from 'tree-sitter';
 export type GraphScope = 'repo' | 'home' | 'both';
 export type StorageScope = Exclude<GraphScope, 'both'>;
-export type GraphNodeKind = 'file' | 'symbol' | 'import' | 'export' | 'call' | 'user';
-export type GraphEdgeKind = 'contains' | 'defines' | 'imports' | 'exports' | 'calls' | 'attributed_to';
+export type GraphNodeKind = 'file' | 'symbol' | 'import' | 'export' | 'call' | 'user' | 'package';
+export type GraphEdgeKind = 'contains' | 'defines' | 'imports' | 'exports' | 'calls' | 'attributed_to' | 'provides';
 export interface Point {
     row: number;
     column: number;
@@ -84,6 +84,9 @@ export interface ScanSummary {
     nodesWritten: number;
     edgesWritten: number;
     skipped: string[];
+    pluginDiagnostics?: string[];
+    failedPlugins?: string[];
+    stalePlugins?: string[];
 }
 export interface RepositoryInfo {
     id: string;
@@ -111,7 +114,7 @@ export interface GraphEdgeRow {
     kind: GraphEdgeKind;
     sourceId: string;
     targetId: string;
-    fileId: string;
+    fileId: string | null;
     confidence: number;
     metadataJson: string;
 }
@@ -128,11 +131,14 @@ export interface CallGraphRelation {
     kind: GraphNodeKind;
     type: string;
     name: string | null;
+    path: string | null;
+    startPoint: Point;
+    parentId: string;
     viaEdgeId: string;
     edgeKind: GraphEdgeKind;
     depth: number;
 }
-export interface CallGraphMatch extends GraphNodeRow {
+export interface CallGraphMatch extends GraphNodeTextRow {
     upstream: CallGraphRelation[];
     downstream: CallGraphRelation[];
 }