@psnext/lscg 0.1.2 → 0.1.4

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