@psnext/lscg 0.1.1 → 0.1.3

package/dist/src/storage/connection.js

@@ -0,0 +1,133 @@
+import { mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+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 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(2);
+    }
+    if (currentVersion <= 2) {
+        migrateSchemaV2ToV3(db);
+        db.prepare('INSERT OR IGNORE INTO schema_migrations(version) VALUES (?)').run(3);
+    }
+    if (currentVersion <= 3) {
+        migrateSchemaV3ToV4(db);
+        db.prepare('INSERT OR IGNORE INTO schema_migrations(version) VALUES (?)').run(SCHEMA_VERSION);
+        return;
+    }
+    throw new Error(`Unsupported schema version: ${currentVersion}`);
+}
+function migrateSchemaV3ToV4(db) {
+    db.exec(`
+    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);
+  `);
+}
+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 migrateSchemaV2ToV3(db) {
+    db.exec('PRAGMA foreign_keys = OFF;');
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        db.exec(`
+      CREATE TABLE edges_new (
+        id TEXT PRIMARY KEY,
+        repository_id TEXT NOT NULL REFERENCES repositories(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,
+        confidence REAL NOT NULL DEFAULT 1.0,
+        metadata_json TEXT NOT NULL DEFAULT '{}'
+      );
+      INSERT INTO edges_new(id, repository_id, file_id, source_id, target_id, kind, confidence, metadata_json)
+        SELECT id, repository_id, file_id, source_id, target_id, kind, confidence, metadata_json FROM edges;
+      DROP TABLE edges;
+      ALTER TABLE edges_new RENAME TO edges;
+      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);
+    `);
+        db.exec('COMMIT');
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+    finally {
+        db.exec('PRAGMA foreign_keys = ON;');
+    }
+}
+//# sourceMappingURL=connection.js.map

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

@@ -0,0 +1,20 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { ContextCandidate, ContextSourceReference } from '../types.js';
+export interface ContextNodeRow extends ContextSourceReference {
+    fileId: string | null;
+}
+export declare function selectContextCandidates(db: DatabaseSync, repositoryId: string, term: string, { kind, file, limit }?: {
+    kind?: string | undefined;
+    file?: string | undefined;
+    limit?: number | undefined;
+}): ContextCandidate[];
+export declare function selectContextRelationships(db: DatabaseSync, repositoryId: string, anchorId: string, limit?: number, maxDepth?: number): Array<{
+    edgeId: string;
+    edgeKind: 'imports' | 'exports' | 'calls';
+    source: ContextNodeRow;
+    target: ContextNodeRow;
+    confidence: number;
+    metadata: Record<string, unknown>;
+    depth: number;
+}>;
+//# sourceMappingURL=context-queries.d.ts.map

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

@@ -0,0 +1,137 @@
+import { DatabaseSync } from 'node:sqlite';
+import { parseMetadata, parsePoint, contextReferenceFromRow } from './row-decoders.js';
+import { clampLimit } from './queries.js';
+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
+    }));
+}
+//# sourceMappingURL=context-queries.js.map

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

@@ -1,72 +1,13 @@
-import { DatabaseSync } from 'node:sqlite';
-import type { FileAttribution, FileRecord, GraphEdge, GraphEdgeRow, GraphNode, GraphNodeRow, GraphNodeTextRow, NeighborRow, CallGraphMatch, RepositoryRecord, StatusResult, ContextCandidate, ContextSourceReference } from '../types.js';
-export declare function openGraphDatabase(databasePath: string): DatabaseSync;
-export declare function openReadOnlyGraphDatabase(databasePath: string): DatabaseSync;
-export declare function closeDatabase(db: DatabaseSync): void;
-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 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 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 interface ContextNodeRow extends ContextSourceReference {
-    fileId: string | null;
-}
-/** Candidate lookup used by context. Stages are queried independently so a unique
- * higher-priority match never gets merged with lower-priority fuzzy matches. */
-export declare function selectContextCandidates(db: DatabaseSync, repositoryId: string, term: string, { kind, file, limit }?: {
-    kind?: string | undefined;
-    file?: string | undefined;
-    limit?: number | undefined;
-}): ContextCandidate[];
-export declare function selectContextRelationships(db: DatabaseSync, repositoryId: string, anchorId: string, limit?: number, maxDepth?: number): Array<{
-    edgeId: string;
-    edgeKind: 'imports' | 'exports' | 'calls';
-    source: ContextNodeRow;
-    target: ContextNodeRow;
-    confidence: number;
-    metadata: Record<string, unknown>;
-    depth: number;
-}>;
-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;
-}>;
-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>>;
-export declare function attachDatabase(db: DatabaseSync, alias: string, databasePath: string): void;
+/**
+ * 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.d.ts.map