@psnext/lscg 0.1.4 → 0.1.6

package/dist/src/scanner/plugins.js

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { discoverSourceFiles } from './discover.js';
+import { inventoryRepositoryManifests } from './artifactInventory.js';
 export const SCANNER_PLUGIN_API_VERSION = 1;
 export const DEFAULT_PLUGIN_RESOURCE_LIMITS = {
     maxNodes: 100_000,
@@ -16,8 +17,9 @@ const GRAPH_NODE_KINDS = new Set(['file', 'symbol', 'import', 'export', 'call',
 const GRAPH_EDGE_KINDS = new Set(['contains', 'defines', 'imports', 'exports', 'calls', 'attributed_to', 'provides']);
 /** Namespace used by plugins to target nodes produced by the built-in scanner. */
 export const BUILTIN_GRAPH_PLUGIN = '__lscg_builtin__';
-export function createRepositoryScanContext(repoPath) {
+export function createRepositoryScanContext(repoPath, suppliedManifests) {
     const discoveredPaths = discoverSourceFiles(repoPath);
+    const manifests = suppliedManifests ? [...suppliedManifests] : inventoryRepositoryManifests(repoPath);
     const files = discoveredPaths.flatMap((relativePath) => {
         try {
             const absolutePath = path.join(repoPath, relativePath);
@@ -38,23 +40,32 @@ export function createRepositoryScanContext(repoPath) {
             return [];
         }
     });
-    return { repoPath, files, discoveredPaths, readFile: (relativePath) => readFileSync(path.join(repoPath, relativePath), 'utf8') };
+    return { repoPath, files, discoveredPaths, manifests, readFile: (relativePath) => readFileSync(path.join(repoPath, relativePath), 'utf8') };
 }
-export async function runScannerPlugins(context, plugins, resourceLimits = {}) {
+export async function runScannerPlugins(context, plugins, resourceLimits = {}, delta, previousContributions = new Map()) {
     const limits = normalizePluginResourceLimits(resourceLimits);
     const nodes = [];
     const edges = [];
     const diagnostics = [];
     const failedPlugins = [];
+    const failedPaths = new Set();
     const successfulPlugins = [];
+    const enrichmentPlugins = new Map();
+    const incrementalRetractions = new Map();
     const owners = new Map();
     for (const plugin of plugins) {
         try {
             validatePlugin(plugin);
             await plugin.initialize?.(context);
-            const result = await plugin.scan(context);
+            const result = plugin.scanIncremental && delta
+                ? await plugin.scanIncremental(context, delta, previousContributions.get(plugin.name))
+                : await plugin.scan(context);
             const finalized = await plugin.finalize?.(context);
+            if (plugin.scanIncremental && delta && 'retractions' in result && result.retractions)
+                incrementalRetractions.set(plugin.name, result.retractions);
             validatePluginResult(plugin.name, result, 'scan');
+            for (const failedPath of result.failedPaths ?? [])
+                failedPaths.add(failedPath);
             if (finalized !== undefined)
                 validatePluginResult(plugin.name, finalized, 'finalize');
             enforceResourceLimits(plugin, result, finalized, limits);
@@ -62,6 +73,11 @@ export async function runScannerPlugins(context, plugins, resourceLimits = {}) {
             if (finalized)
                 collect(plugin, finalized, nodes, edges, owners, diagnostics, limits);
             successfulPlugins.push(plugin.name);
+            if (plugin.capabilities.includes('enrichment')) {
+                if (typeof plugin.enrich !== 'function')
+                    throw new Error(`invalid enrichment plugin: ${plugin.name} must define enrich()`);
+                enrichmentPlugins.set(plugin.name, plugin);
+            }
         }
         catch (error) {
             failedPlugins.push(plugin.name);
@@ -86,6 +102,15 @@ export async function runScannerPlugins(context, plugins, resourceLimits = {}) {
         return [canonicalNodeIdentity(node.pluginName ?? '', node.factKey), materialized];
     }));
     const materializedNodes = [...nodeByIdentity.values()];
+    for (const [plugin, retractions] of incrementalRetractions) {
+        const previous = previousContributions.get(plugin);
+        const retractedNodeKeys = new Set(retractions.nodes ?? []);
+        for (const node of previous?.nodes ?? []) {
+            const factKey = String(node.metadata.factKey ?? '');
+            if (factKey && !retractedNodeKeys.has(factKey))
+                nodeByIdentity.set(canonicalNodeIdentity(plugin, factKey), node);
+        }
+    }
     const materializedEdges = [];
     for (const edge of edges) {
         const sourceIdentity = canonicalNodeIdentity(edge.sourcePlugin ?? edge.pluginName ?? '', edge.sourceFactKey);
@@ -104,6 +129,7 @@ export async function runScannerPlugins(context, plugins, resourceLimits = {}) {
             sourceId: source.id,
             targetId: target.id,
             kind: edge.kind,
+            type: edge.type ?? edge.kind,
             confidence: edge.confidence ?? 1,
             metadata: {
                 ...(edge.metadata ?? {}),
@@ -126,6 +152,33 @@ export async function runScannerPlugins(context, plugins, resourceLimits = {}) {
         if (plugin)
             contributionFor(plugin).edges.push(edge);
     }
+    for (const [plugin, retractions] of incrementalRetractions) {
+        const previous = previousContributions.get(plugin);
+        if (!previous)
+            continue;
+        const current = contributionFor(plugin);
+        const nodeKeys = new Set(retractions.nodes ?? []);
+        const edgeKeys = new Set(retractions.edges ?? []);
+        const currentNodeKeys = new Set(current.nodes.map((node) => String(node.metadata.factKey ?? '')));
+        const currentEdgeKeys = new Set(current.edges.map((edge) => String(edge.metadata.factKey ?? '')));
+        current.nodes = [
+            ...previous.nodes.filter((node) => !nodeKeys.has(String(node.metadata.factKey ?? '')) && !currentNodeKeys.has(String(node.metadata.factKey ?? ''))),
+            ...current.nodes
+        ];
+        current.edges = [
+            ...previous.edges.filter((edge) => !edgeKeys.has(String(edge.metadata.factKey ?? '')) && !currentEdgeKeys.has(String(edge.metadata.factKey ?? ''))),
+            ...current.edges
+        ];
+    }
+    const partiallyReconciledPlugins = new Set(incrementalRetractions.keys());
+    const mergedNodes = [
+        ...materializedNodes.filter((node) => !partiallyReconciledPlugins.has(String(node.metadata.plugin ?? ''))),
+        ...[...partiallyReconciledPlugins].flatMap((plugin) => pluginContributions.get(plugin)?.nodes ?? [])
+    ];
+    const mergedEdges = [
+        ...materializedEdges.filter((edge) => !partiallyReconciledPlugins.has(String(edge.metadata.plugin ?? ''))),
+        ...[...partiallyReconciledPlugins].flatMap((plugin) => pluginContributions.get(plugin)?.edges ?? [])
+    ];
     function contributionFor(plugin) {
         const existing = pluginContributions.get(plugin);
         if (existing)
@@ -134,7 +187,7 @@ export async function runScannerPlugins(context, plugins, resourceLimits = {}) {
         pluginContributions.set(plugin, created);
         return created;
     }
-    return { nodes: materializedNodes, edges: materializedEdges, diagnostics, failedPlugins, successfulPlugins, pluginContributions };
+    return { nodes: mergedNodes, edges: mergedEdges, diagnostics, failedPaths: [...failedPaths].sort(), failedPlugins, successfulPlugins, pluginContributions, enrichmentPlugins };
     function collect(plugin, result, nodeOutput, edgeOutput, ownerMap, messages, contributionLimits) {
         for (const node of result.nodes ?? []) {
             const identity = canonicalNodeIdentity(plugin.name, node.factKey);

package/dist/src/scanner/pythonPlugin.d.ts

@@ -0,0 +1,5 @@
+import type { PluginScanResult, RepositoryScanFile, ScannerPlugin } from './plugins.js';
+export declare const PYTHON_SCANNER_PLUGIN_NAME = "python-scanner-plugin";
+export declare function scanPythonFiles(files: readonly RepositoryScanFile[]): PluginScanResult;
+export declare const PythonScannerPlugin: ScannerPlugin;
+//# sourceMappingURL=pythonPlugin.d.ts.map

package/dist/src/scanner/pythonPlugin.js

@@ -0,0 +1,198 @@
+import Parser from 'tree-sitter';
+import { parseSource } from '../parser/treeSitter.js';
+import { runBatchedWorkers } from './parallelScan.js';
+export const PYTHON_SCANNER_PLUGIN_NAME = 'python-scanner-plugin';
+const PYTHON_EXTENSIONS = new Set(['.py']);
+const SYMBOL_TYPES = new Set(['class_definition', 'function_definition', 'assignment']);
+const IMPORT_TYPES = new Set(['import_statement', 'import_from_statement']);
+const CALL_TYPES = new Set(['call']);
+export function scanPythonFiles(files) {
+    const nodes = [];
+    const edges = [];
+    for (const file of files) {
+        if (!isPython(file.path))
+            continue;
+        const parsed = parseSource(file.absolutePath, file.source);
+        if (!parsed || parsed.language !== 'python')
+            continue;
+        const sourceBuffer = Buffer.from(file.source, 'utf8');
+        const fileKey = factKey(file.path, 'file', 0, sourceBuffer.length);
+        nodes.push(node(file, fileKey, parsed, 'file', 'file', file.path, parsed.tree.rootNode, sourceBuffer, { language: 'python' }));
+        walk(parsed.tree.rootNode, [], [], fileKey, file, parsed, sourceBuffer, nodes, edges);
+    }
+    return { nodes, edges };
+}
+async function scanPythonFilesInBatches(files) {
+    const pythonFiles = files.filter((file) => isPython(file.path));
+    const results = await runBatchedWorkers(pythonFiles, new URL('./pythonScanWorker.js', import.meta.url), (batch) => batch);
+    return {
+        nodes: results.flatMap((result) => result.nodes),
+        edges: results.flatMap((result) => result.edges),
+        failedPaths: results.flatMap((result) => result.failedPaths ?? []),
+        diagnostics: results.flatMap((result) => result.diagnostics ?? [])
+    };
+}
+export const PythonScannerPlugin = {
+    name: PYTHON_SCANNER_PLUGIN_NAME,
+    apiVersion: 1,
+    capabilities: ['file-scanner'],
+    scan: (context) => scanPythonFilesInBatches(context.files),
+    scanIncremental: (context, delta, previous) => scanPythonIncremental(context, delta, previous)
+};
+async function scanPythonIncremental(context, delta, previous) {
+    if (delta.full || !previous)
+        return { ...(await scanPythonFilesInBatches(context.files)), retractions: { nodes: [], edges: [] } };
+    const changed = new Set([...delta.changedPaths, ...delta.deletedPaths].filter(isPython));
+    if (changed.size === 0)
+        return { nodes: [], edges: [], retractions: { nodes: [], edges: [] } };
+    const retractions = { nodes: [], edges: [] };
+    for (const fact of previous.nodes) {
+        if (fact.metadata.filePath && changed.has(String(fact.metadata.filePath))) {
+            const key = String(fact.metadata.factKey ?? '');
+            if (key)
+                retractions.nodes.push(key);
+        }
+    }
+    for (const fact of previous.edges) {
+        if (fact.metadata.filePath && changed.has(String(fact.metadata.filePath))) {
+            const key = String(fact.metadata.factKey ?? '');
+            if (key)
+                retractions.edges.push(key);
+        }
+    }
+    return {
+        ...(await scanPythonFilesInBatches(context.files.filter((file) => changed.has(file.path)))),
+        retractions
+    };
+}
+function walk(treeNode, symbolAncestry, graphAncestry, fileKey, file, parsed, sourceBuffer, nodes, edges) {
+    let currentKey;
+    let nextSymbols = symbolAncestry;
+    let nextGraph = graphAncestry;
+    const kind = kindFor(treeNode);
+    if (kind) {
+        const name = nameFor(treeNode, sourceBuffer);
+        currentKey = factKey(file.path, kind, treeNode.startIndex, treeNode.endIndex);
+        const metadata = metadataFor(treeNode, sourceBuffer, name);
+        nodes.push(node(file, currentKey, parsed, kind, treeNode.type, name, treeNode, sourceBuffer, metadata));
+        const parentKey = graphAncestry.at(-1) ?? fileKey;
+        edges.push({
+            factKey: `contains:${file.path}:${treeNode.startIndex}:${treeNode.endIndex}`,
+            sourceFactKey: parentKey,
+            targetFactKey: currentKey,
+            filePath: file.path,
+            kind: kind === 'symbol' && symbolAncestry.length === 0 ? 'defines' : 'contains',
+            metadata: { discoveredFrom: treeNode.type }
+        });
+        if (kind === 'import') {
+            edges.push({
+                factKey: `imports:${file.path}:${treeNode.startIndex}:${treeNode.endIndex}`,
+                sourceFactKey: fileKey,
+                targetFactKey: currentKey,
+                filePath: file.path,
+                kind: 'imports',
+                confidence: 0.65,
+                metadata: { module: metadata.module ?? name }
+            });
+        }
+        else if (kind === 'call') {
+            edges.push({
+                factKey: `calls:${file.path}:${treeNode.startIndex}:${treeNode.endIndex}`,
+                sourceFactKey: symbolAncestry.at(-1) ?? fileKey,
+                targetFactKey: currentKey,
+                filePath: file.path,
+                kind: 'calls',
+                confidence: 0.65,
+                metadata: { callee: name }
+            });
+        }
+        if (kind === 'symbol') {
+            if (symbolAncestry.length === 0 && name && !name.startsWith('_')) {
+                const exportKey = factKey(file.path, 'export', treeNode.startIndex, treeNode.endIndex);
+                nodes.push(node(file, exportKey, parsed, 'export', 'implicit_export', name, treeNode, sourceBuffer, {
+                    exportKind: 'implicit-python-export',
+                    symbol: name
+                }));
+                edges.push({
+                    factKey: `exports:${file.path}:${treeNode.startIndex}:${treeNode.endIndex}`,
+                    sourceFactKey: fileKey,
+                    targetFactKey: exportKey,
+                    filePath: file.path,
+                    kind: 'exports',
+                    metadata: { symbol: name, implicit: true }
+                });
+            }
+            nextSymbols = [...symbolAncestry, currentKey];
+        }
+        nextGraph = [...graphAncestry, currentKey];
+    }
+    for (const child of treeNode.namedChildren) {
+        walk(child, nextSymbols, nextGraph, fileKey, file, parsed, sourceBuffer, nodes, edges);
+    }
+}
+function kindFor(node) {
+    if (SYMBOL_TYPES.has(node.type))
+        return 'symbol';
+    if (IMPORT_TYPES.has(node.type))
+        return 'import';
+    if (CALL_TYPES.has(node.type))
+        return 'call';
+    return undefined;
+}
+function nameFor(node, sourceBuffer) {
+    const name = node.childForFieldName('name');
+    if (name)
+        return textFor(name, sourceBuffer).trim();
+    if (node.type === 'assignment' || node.type === 'augmented_assignment') {
+        const left = node.childForFieldName('left') ?? node.namedChildren[0];
+        return left ? textFor(left, sourceBuffer).trim() : null;
+    }
+    if (node.type === 'call') {
+        const fn = node.childForFieldName('function') ?? node.namedChildren[0];
+        return fn ? textFor(fn, sourceBuffer).trim().slice(0, 120) : null;
+    }
+    if (IMPORT_TYPES.has(node.type))
+        return moduleForImport(node, sourceBuffer);
+    return null;
+}
+function metadataFor(node, sourceBuffer, name) {
+    const snippet = textFor(node, sourceBuffer).trim().slice(0, 240);
+    if (IMPORT_TYPES.has(node.type))
+        return { module: moduleForImport(node, sourceBuffer), snippet };
+    if (node.type === 'call')
+        return { callee: name, snippet };
+    return { snippet };
+}
+function moduleForImport(node, sourceBuffer) {
+    const source = textFor(node, sourceBuffer).trim();
+    if (node.type === 'import_statement')
+        return source.replace(/^import\s+/, '').split(',')[0]?.trim() ?? source;
+    return /^from\s+([^\s]+)\s+import\s+/u.exec(source)?.[1] ?? source;
+}
+function node(file, factKeyValue, parsed, kind, type, name, treeNode, sourceBuffer, metadata) {
+    return {
+        factKey: factKeyValue,
+        filePath: file.path,
+        kind,
+        type,
+        name,
+        startByte: treeNode.startIndex,
+        endByte: treeNode.endIndex,
+        startPoint: treeNode.startPosition,
+        endPoint: treeNode.endPosition,
+        sourceHash: file.hash,
+        parser: parsed.parser,
+        parserVersion: parsed.parserVersion,
+        metadata: { ...metadata, filePath: file.path, factKey: factKeyValue, sourceBytes: sourceBuffer.length }
+    };
+}
+function factKey(filePath, kind, startByte, endByte) {
+    return `${kind}:${filePath}:${startByte}:${endByte}`;
+}
+function textFor(node, sourceBuffer) {
+    return sourceBuffer.subarray(node.startIndex, node.endIndex).toString('utf8');
+}
+function isPython(filePath) {
+    return PYTHON_EXTENSIONS.has(filePath.slice(filePath.lastIndexOf('.')).toLowerCase());
+}
+//# sourceMappingURL=pythonPlugin.js.map

package/dist/src/scanner/pythonScanWorker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pythonScanWorker.d.ts.map

package/dist/src/scanner/pythonScanWorker.js

@@ -0,0 +1,8 @@
+import { parentPort } from 'node:worker_threads';
+import { scanPythonFiles } from './pythonPlugin.js';
+if (!parentPort)
+    throw new Error('python scan worker requires a parent port');
+parentPort.on('message', (files) => {
+    parentPort.postMessage(scanPythonFiles(files));
+});
+//# sourceMappingURL=pythonScanWorker.js.map

package/dist/src/storage/connection.js

@@ -9,6 +9,7 @@ export function openGraphDatabase(databasePath) {
     db.exec('PRAGMA journal_mode = WAL;');
     db.exec(CREATE_SCHEMA_SQL);
     ensureSchemaVersion(db);
+    db.exec('CREATE INDEX IF NOT EXISTS idx_edges_repo_type ON edges(repository_id, type);');
     return db;
 }
 export function openReadOnlyGraphDatabase(databasePath) {
@@ -44,6 +45,26 @@ function ensureSchemaVersion(db) {
     }
     if (currentVersion <= 3) {
         migrateSchemaV3ToV4(db);
+        db.prepare('INSERT OR IGNORE INTO schema_migrations(version) VALUES (?)').run(4);
+    }
+    if (currentVersion <= 4) {
+        migrateSchemaV4ToV5(db);
+        db.prepare('INSERT OR IGNORE INTO schema_migrations(version) VALUES (?)').run(5);
+    }
+    if (currentVersion <= 5) {
+        migrateSchemaV5ToV6(db);
+        db.prepare('INSERT OR IGNORE INTO schema_migrations(version) VALUES (?)').run(6);
+    }
+    if (currentVersion <= 6) {
+        migrateSchemaV6ToV7(db);
+        db.prepare('INSERT OR IGNORE INTO schema_migrations(version) VALUES (?)').run(7);
+    }
+    if (currentVersion <= 7) {
+        migrateSchemaV7ToV8(db);
+        db.prepare('INSERT OR IGNORE INTO schema_migrations(version) VALUES (?)').run(8);
+    }
+    if (currentVersion <= 8) {
+        migrateSchemaV8ToV9(db);
         db.prepare('INSERT OR IGNORE INTO schema_migrations(version) VALUES (?)').run(SCHEMA_VERSION);
         return;
     }
@@ -63,6 +84,70 @@ function migrateSchemaV3ToV4(db) {
     CREATE INDEX IF NOT EXISTS idx_plugin_contributions_repo ON plugin_contributions(repository_id);
   `);
 }
+function migrateSchemaV4ToV5(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS file_scan_failures (
+      repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
+      path TEXT NOT NULL,
+      diagnostic TEXT NOT NULL,
+      failed_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY(repository_id, path)
+    );
+    CREATE TABLE IF NOT EXISTS repository_scan_state (
+      repository_id TEXT PRIMARY KEY REFERENCES repositories(id) ON DELETE CASCADE,
+      state TEXT NOT NULL CHECK(state IN ('fresh', 'degraded', 'stale')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+}
+function migrateSchemaV5ToV6(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS file_enrichment_state (
+      repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
+      file_id TEXT PRIMARY KEY REFERENCES files(id) ON DELETE CASCADE,
+      source_hash TEXT NOT NULL,
+      state TEXT NOT NULL CHECK(state IN ('pending', 'complete', 'failed')),
+      diagnostic TEXT,
+      queued_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      completed_at TEXT,
+      failed_at TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_file_enrichment_state_repo_state ON file_enrichment_state(repository_id, state);
+  `);
+}
+function migrateSchemaV6ToV7(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS repository_manifest_inventory (
+      repository_id TEXT NOT NULL REFERENCES repositories(id) ON DELETE CASCADE,
+      path TEXT NOT NULL,
+      kind TEXT NOT NULL CHECK(kind IN ('maven-pom', 'gradle-groovy', 'gradle-kotlin')),
+      module_identity TEXT NOT NULL,
+      status TEXT NOT NULL CHECK(status IN ('observed', 'read_failed', 'traversal_incomplete', 'confirmed_deleted')),
+      size INTEGER NOT NULL,
+      mtime_ms INTEGER NOT NULL,
+      source_hash TEXT,
+      generation INTEGER NOT NULL,
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY(repository_id, path)
+    );
+    CREATE INDEX IF NOT EXISTS idx_repository_manifest_inventory_repo_status
+      ON repository_manifest_inventory(repository_id, status);
+  `);
+}
+function migrateSchemaV7ToV8(db) {
+    const columns = new Set(db.prepare('PRAGMA table_info(file_enrichment_state)').all().map((column) => column.name));
+    if (!columns.has('plugin_name'))
+        db.exec("ALTER TABLE file_enrichment_state ADD COLUMN plugin_name TEXT NOT NULL DEFAULT 'git-attribution-plugin'");
+    if (!columns.has('history_fingerprint'))
+        db.exec('ALTER TABLE file_enrichment_state ADD COLUMN history_fingerprint TEXT');
+    if (!columns.has('outcome'))
+        db.exec('ALTER TABLE file_enrichment_state ADD COLUMN outcome TEXT');
+}
+function migrateSchemaV8ToV9(db) {
+    db.exec('ALTER TABLE edges ADD COLUMN type TEXT NOT NULL DEFAULT kind;');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_edges_repo_type ON edges(repository_id, type);');
+}
 function getCurrentSchemaVersion(db) {
     const row = db.prepare('SELECT COALESCE(MAX(version), 0) AS version FROM schema_migrations').get();
     return Number(row?.version ?? 0);

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

@@ -5,6 +5,7 @@
  */
 export * from './connection.js';
 export * from './plugin-contributions.js';
+export * from './manifest-inventory.js';
 export * from './graph-writes.js';
 export * from './plugin-graph.js';
 export * from './queries.js';

package/dist/src/storage/database.js

@@ -5,6 +5,7 @@
  */
 export * from './connection.js';
 export * from './plugin-contributions.js';
+export * from './manifest-inventory.js';
 export * from './graph-writes.js';
 export * from './plugin-graph.js';
 export * from './queries.js';

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

@@ -0,0 +1,52 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { ExploreEdgeKind, ExploreDirection, GraphNodeKind, Point } from '../types.js';
+export interface ExploreAggregateRow {
+    id: string;
+    path: string;
+    language: string;
+    childCount: number;
+    repositoryId: string;
+}
+export interface ExploreSourceRow {
+    id: string;
+    kind: GraphNodeKind;
+    type: string;
+    name: string | null;
+    fileId: string | null;
+    path: string | null;
+    startPoint: Point;
+    endPoint: Point;
+    metadata: Record<string, unknown>;
+}
+export interface ExploreCandidateRow extends ExploreSourceRow {
+    rank: number;
+    match: 'exact' | 'qualified' | 'path' | 'prefix' | 'substring';
+    qualifiedName: string | null;
+    aggregateId: string | null;
+}
+export interface ExploreEdgeRow {
+    id: string;
+    sourceId: string;
+    targetId: string;
+    kind: ExploreEdgeKind;
+    confidence: number;
+    metadata: Record<string, unknown>;
+}
+export declare function selectExploreAggregates(db: DatabaseSync, repositoryId: string, search?: string): ExploreAggregateRow[];
+export declare function selectExploreAggregateEdges(db: DatabaseSync, repositoryId: string, kinds?: readonly ExploreEdgeKind[]): Array<ExploreEdgeRow & {
+    count: number;
+    sourceAggregateId: string;
+    targetAggregateId: string;
+}>;
+export declare function selectExploreSourcesForSearch(db: DatabaseSync, repositoryId: string, term: string, limit?: number): ExploreSourceRow[];
+export declare function selectExploreCandidates(db: DatabaseSync, repositoryId: string, term: string, { kind, file, fileAnchor, limit }?: {
+    kind?: string;
+    file?: string;
+    fileAnchor?: boolean;
+    limit?: number;
+}): ExploreCandidateRow[];
+export declare function selectExploreNode(db: DatabaseSync, repositoryId: string, id: string): ExploreSourceRow | null;
+export declare function selectExploreTraversalEdges(db: DatabaseSync, repositoryId: string, frontier: readonly string[], direction: ExploreDirection, kinds: readonly ExploreEdgeKind[], limit: number): ExploreEdgeRow[];
+export declare function selectExploreNodeRows(db: DatabaseSync, repositoryId: string, ids: readonly string[]): ExploreSourceRow[];
+export declare function aggregateId(repositoryId: string, fileId: string): string;
+//# sourceMappingURL=explore-queries.d.ts.map