@psnext/lscg 0.1.5 → 0.1.6

package/dist/src/graph/repository.d.ts

@@ -15,6 +15,8 @@ export interface ScanRepositoryOptions {
     root?: string | undefined;
     scope?: StorageScope | 'both' | undefined;
     plugins?: readonly ScannerPlugin[] | undefined;
+    /** Enables the bundled Git attribution enrichment plugin. */
+    attribution?: boolean | undefined;
     pluginLimits?: Partial<PluginResourceLimits> | undefined;
     full?: boolean | undefined;
     enrichmentRunner?: EnrichmentRunner | undefined;
@@ -32,12 +34,14 @@ export interface DrainRepositoryEnrichmentOptions {
     root?: string | undefined;
     scope?: StorageScope | 'both' | undefined;
     enrichmentRunner?: EnrichmentRunner | undefined;
+    pluginName?: string | undefined;
+    historyFingerprint?: string | null | undefined;
 }
 /**
  * Drains persisted, hash-compatible attribution work. This is deliberately
  * explicit: one-shot structural scans persist work but never start it.
  */
-export declare function drainRepositoryEnrichment({ root, scope, enrichmentRunner }?: DrainRepositoryEnrichmentOptions): Promise<EnrichmentSummary>;
+export declare function drainRepositoryEnrichment({ root, scope, enrichmentRunner, pluginName, historyFingerprint }?: DrainRepositoryEnrichmentOptions): Promise<EnrichmentSummary>;
 export declare function graphStatus({ root, scope }?: {
     root?: string | undefined;
     scope?: StorageScope | 'both' | undefined;
@@ -65,10 +69,11 @@ export declare function listNodeText({ root, scope, kind, term, limit }?: {
     root: string;
     freshness: FreshnessReport;
 } & GraphNodeTextRow>;
-export declare function listEdges({ root, scope, kind, limit }?: {
+export declare function listEdges({ root, scope, kind, type, limit }?: {
     root?: string | undefined;
     scope?: StorageScope | 'both' | undefined;
     kind?: string | undefined;
+    type?: string | undefined;
     limit?: number | undefined;
 }): Array<{
     scope: StorageScope;

package/dist/src/graph/repository.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { databasePathForScope, homeDatabasePath, normalizeScope, repoDatabasePath, resolveProjectRoot } from '../config/paths.js';
@@ -11,6 +12,7 @@ import { PackagePlugin } from '../scanner/packagePlugin.js';
 import { PythonScannerPlugin } from '../scanner/pythonPlugin.js';
 import { JavaScannerPlugin } from '../scanner/javaPlugin.js';
 import { JavaDependencyPlugin } from '../scanner/javaDependencyPlugin.js';
+import { AttributionPlugin, ATTRIBUTION_PLUGIN_NAME } from '../scanner/attributionPlugin.js';
 import { inspectRepositoryManifests, mergeManifestInventories } from '../scanner/artifactInventory.js';
 import { runBatchedWorkers } from '../scanner/parallelScan.js';
 function normalizePluginFilePath(value) {
@@ -89,8 +91,8 @@ export async function scanRepository(options = {}) {
         try {
             const summary = await scanRepositoryOnce({ ...options, attempt: 1 });
             reportProgress(progress, {
-                kind: 'scan', operation, scope, phase: 'terminal', status: summary.enrichment.state === 'complete' ? 'completed' : 'degraded',
-                repository: summary.repository, attempt: 1, detail: summary.enrichment.state === 'complete' ? 'scan complete' : `scan complete with enrichment ${summary.enrichment.state}`,
+                kind: 'scan', operation, scope, phase: 'terminal', status: summary.enrichment.state === 'complete' || summary.enrichment.state === 'disabled' ? 'completed' : 'degraded',
+                repository: summary.repository, attempt: 1, detail: summary.enrichment.state === 'complete' || summary.enrichment.state === 'disabled' ? 'scan complete' : `scan complete with enrichment ${summary.enrichment.state}`,
                 counts: { processed: summary.filesScanned, skipped: summary.skipped.length, pending: summary.enrichment.pending, complete: summary.enrichment.complete, failed: summary.enrichment.failed }
             });
             return summary;
@@ -105,8 +107,8 @@ export async function scanRepository(options = {}) {
             const summary = await scanRepositoryOnce({ ...options, attempt });
             if (summary.enrichment.pending === 0) {
                 reportProgress(progress, {
-                    kind: 'scan', operation, scope, phase: 'terminal', status: summary.enrichment.state === 'complete' ? 'completed' : 'degraded',
-                    repository: summary.repository, attempt, detail: summary.enrichment.state === 'complete' ? 'full scan complete; enrichment stabilized' : `full scan complete with enrichment ${summary.enrichment.state}`,
+                    kind: 'scan', operation, scope, phase: 'terminal', status: summary.enrichment.state === 'complete' || summary.enrichment.state === 'disabled' ? 'completed' : 'degraded',
+                    repository: summary.repository, attempt, detail: summary.enrichment.state === 'complete' || summary.enrichment.state === 'disabled' ? 'full scan complete; enrichment stabilized' : `full scan complete with enrichment ${summary.enrichment.state}`,
                     counts: { processed: summary.filesScanned, skipped: summary.skipped.length, pending: summary.enrichment.pending, complete: summary.enrichment.complete, failed: summary.enrichment.failed }
                 });
                 return summary;
@@ -124,8 +126,9 @@ export async function scanRepository(options = {}) {
     reportProgress(progress, { kind: 'scan', operation, scope, phase: 'terminal', status: 'failed', repository: repositoryForRoot(options.root), attempt: MAX_FULL_ENRICHMENT_ATTEMPTS, detail: error.message });
     throw error;
 }
-async function scanRepositoryOnce({ root = process.cwd(), scope = 'repo', plugins = [], pluginLimits, full = false, enrichmentRunner, progress, attempt = 1 } = {}) {
+async function scanRepositoryOnce({ root = process.cwd(), scope = 'repo', plugins = [], attribution = false, pluginLimits, full = false, enrichmentRunner, progress, attempt = 1 } = {}) {
     const repository = repositoryForRoot(root);
+    const attributionEnabled = attribution || plugins.some((plugin) => plugin.name === ATTRIBUTION_PLUGIN_NAME);
     const scopes = normalizeScope(scope);
     const files = discoverSourceFiles(repository.root);
     const operation = full ? 'full' : 'incremental';
@@ -161,9 +164,24 @@ async function scanRepositoryOnce({ root = process.cwd(), scope = 'repo', plugin
         // Keep the analyzer active for current manifests and for one final
         // reconciliation after a restart/deletion of the last manifest.
         ...(hasJavaManifests || hasPriorJavaDependencyContribution ? [JavaDependencyPlugin] : []),
-        ...plugins.filter((plugin) => ![PackagePlugin.name, PythonScannerPlugin.name, JavaScannerPlugin.name, JavaDependencyPlugin.name].includes(plugin.name))
+        ...(attribution || plugins.some((plugin) => plugin.name === ATTRIBUTION_PLUGIN_NAME) ? [AttributionPlugin] : []),
+        ...plugins.filter((plugin) => ![PackagePlugin.name, PythonScannerPlugin.name, JavaScannerPlugin.name, JavaDependencyPlugin.name, ATTRIBUTION_PLUGIN_NAME].includes(plugin.name))
     ];
-    const filesToScan = full || inventoriesByScope.some((inventory) => inventory.size === 0)
+    const historyFingerprint = attributionEnabled ? gitHeadFingerprint(repository.root) : null;
+    const priorHistoryFingerprint = attributionEnabled && opened[0]
+        ? opened[0].db.prepare(`SELECT history_fingerprint AS historyFingerprint FROM file_enrichment_state WHERE repository_id = ? ORDER BY updated_at DESC LIMIT 1`).get(repository.id)?.historyFingerprint ?? null
+        : null;
+    const historyChanged = attributionEnabled && historyFingerprint !== priorHistoryFingerprint;
+    const missingAttributionState = attributionEnabled && opened[0]
+        ? Number(opened[0].db.prepare(`
+      SELECT count(*) AS count FROM files f
+      WHERE f.repository_id = ? AND NOT EXISTS (
+        SELECT 1 FROM file_enrichment_state e
+        WHERE e.file_id = f.id AND e.plugin_name = ?
+      )
+    `).get(repository.id, ATTRIBUTION_PLUGIN_NAME).count) > 0
+        : false;
+    const filesToScan = full || historyChanged || missingAttributionState || inventoriesByScope.some((inventory) => inventory.size === 0)
         ? files
         : files.filter((relativePath) => {
             try {
@@ -308,7 +326,13 @@ async function scanRepositoryOnce({ root = process.cwd(), scope = 'repo', plugin
                 edges: builtInGraph.edges
             };
             for (const handle of opened) {
-                replaceFileGraph(handle.db, { repository, file, nodes: graph.nodes, edges: graph.edges });
+                replaceFileGraph(handle.db, {
+                    repository,
+                    file,
+                    nodes: graph.nodes,
+                    edges: graph.edges,
+                    ...(attributionEnabled ? { enrichment: { pluginName: ATTRIBUTION_PLUGIN_NAME, historyFingerprint } } : {})
+                });
                 clearFileScanFailure(handle.db, repository.id, relativePath);
             }
             filesScanned += 1;
@@ -343,12 +367,16 @@ async function scanRepositoryOnce({ root = process.cwd(), scope = 'repo', plugin
             closeDatabase(handle.db);
     }
     reportProgress(progress, { kind: 'scan', operation, scope, phase: 'enrichment', status: 'started', repository, attempt });
-    const enrichment = full
-        ? await drainRepositoryEnrichment({ root: repository.root, scope, enrichmentRunner })
-        : summarizeRepositoryEnrichment(repository, scopes);
+    const selectedEnrichmentPlugin = pluginRun.enrichmentPlugins?.get(ATTRIBUTION_PLUGIN_NAME);
+    const selectedRunner = enrichmentRunner ?? (selectedEnrichmentPlugin?.enrich?.bind(selectedEnrichmentPlugin));
+    const enrichment = attributionEnabled && full
+        ? await drainRepositoryEnrichment({ root: repository.root, scope, enrichmentRunner: selectedRunner, pluginName: ATTRIBUTION_PLUGIN_NAME, historyFingerprint })
+        : attributionEnabled
+            ? summarizeRepositoryEnrichment(repository, scopes)
+            : disabledEnrichmentSummary();
     reportProgress(progress, {
-        kind: 'scan', operation, scope, phase: 'enrichment', status: enrichment.state === 'complete' ? 'completed' : enrichment.state === 'pending' ? 'deferred' : 'degraded', repository, attempt,
-        detail: enrichment.state === 'pending' ? 'structural scan complete; enrichment deferred' : enrichment.state === 'failed' ? 'enrichment failed; scan is degraded' : 'enrichment complete',
+        kind: 'scan', operation, scope, phase: 'enrichment', status: enrichment.state === 'complete' || enrichment.state === 'disabled' ? 'completed' : enrichment.state === 'pending' ? 'deferred' : 'degraded', repository, attempt,
+        detail: enrichment.state === 'pending' ? 'structural scan complete; enrichment deferred' : enrichment.state === 'failed' ? 'enrichment failed; scan is degraded' : enrichment.state === 'disabled' ? 'optional enrichment disabled' : 'enrichment complete',
         counts: { pending: enrichment.pending, complete: enrichment.complete, failed: enrichment.failed }
     });
     return {
@@ -375,13 +403,13 @@ export const defaultEnrichmentRunner = ({ repository, work, source, nodes }) =>
  * Drains persisted, hash-compatible attribution work. This is deliberately
  * explicit: one-shot structural scans persist work but never start it.
  */
-export async function drainRepositoryEnrichment({ root = process.cwd(), scope = 'repo', enrichmentRunner = defaultEnrichmentRunner } = {}) {
+export async function drainRepositoryEnrichment({ root = process.cwd(), scope = 'repo', enrichmentRunner = defaultEnrichmentRunner, pluginName = ATTRIBUTION_PLUGIN_NAME, historyFingerprint = null } = {}) {
     const repository = repositoryForRoot(root);
     const scopes = normalizeScope(scope);
     for (const graphScope of scopes) {
         const db = openGraphDatabase(databasePathForScope(graphScope, repository.root));
         try {
-            const workItems = selectEnrichmentWork(db, repository.id);
+            const workItems = selectEnrichmentWork(db, repository.id).filter((work) => work.pluginName === pluginName && (historyFingerprint === null || work.historyFingerprint === historyFingerprint));
             for (const work of workItems) {
                 let outcome;
                 try {
@@ -405,7 +433,7 @@ export async function drainRepositoryEnrichment({ root = process.cwd(), scope =
                 catch (error) {
                     outcome = { status: 'failed', diagnostic: `enrichment failed: ${diagnosticFor(error)}` };
                 }
-                applyFileAttribution(db, { repository, fileId: work.fileId, sourceHash: work.sourceHash, outcome });
+                applyFileAttribution(db, { repository, fileId: work.fileId, sourceHash: work.sourceHash, outcome, pluginName, historyFingerprint });
             }
         }
         finally {
@@ -414,6 +442,21 @@ export async function drainRepositoryEnrichment({ root = process.cwd(), scope =
     }
     return summarizeRepositoryEnrichment(repository, scopes);
 }
+function disabledEnrichmentSummary() {
+    return { state: 'disabled', pending: 0, complete: 0, failed: 0, unavailable: 0, notApplicable: 0, diagnostics: [] };
+}
+function gitHeadFingerprint(root) {
+    try {
+        const result = spawnSync('git', ['-C', root, 'rev-parse', '--verify', 'HEAD'], { encoding: 'utf8' });
+        if (result.status !== 0)
+            return null;
+        const head = String(result.stdout ?? '').trim();
+        return head || null;
+    }
+    catch {
+        return null;
+    }
+}
 function summarizeRepositoryEnrichment(repository, scopes) {
     const states = [];
     for (const graphScope of scopes) {
@@ -428,11 +471,14 @@ function summarizeRepositoryEnrichment(repository, scopes) {
     const pending = states.filter((entry) => entry.state === 'pending').length;
     const complete = states.filter((entry) => entry.state === 'complete').length;
     const failedEntries = states.filter((entry) => entry.state === 'failed');
+    const unavailableEntries = states.filter((entry) => entry.outcome === 'unavailable');
     return {
         state: failedEntries.length > 0 ? 'failed' : pending > 0 ? 'pending' : 'complete',
         pending,
-        complete,
+        complete: complete - unavailableEntries.length,
         failed: failedEntries.length,
+        unavailable: unavailableEntries.length,
+        notApplicable: unavailableEntries.filter((entry) => entry.diagnostic === 'unavailable:not_applicable').length,
         diagnostics: failedEntries.flatMap((entry) => entry.diagnostic ? [entry.diagnostic] : [])
     };
 }
@@ -485,7 +531,7 @@ export function graphStatus({ root = process.cwd(), scope = 'repo' } = {}) {
             nodes: 0,
             edges: 0,
             freshness: { state: 'stale', reason: 'not_scanned' },
-            enrichment: { state: 'complete', pending: 0, complete: 0, failed: 0, diagnostics: [] }
+            enrichment: disabledEnrichmentSummary()
         });
 }
 export function listNodes({ root = process.cwd(), scope = 'repo', kind, limit = 50 } = {}) {
@@ -512,13 +558,13 @@ export function listNodeText({ root = process.cwd(), scope = 'repo', kind, term,
         }));
     }).flat();
 }
-export function listEdges({ root = process.cwd(), scope = 'repo', kind, limit = 50 } = {}) {
+export function listEdges({ root = process.cwd(), scope = 'repo', kind, type, limit = 50 } = {}) {
     const repository = repositoryForRoot(root);
     return withReadOnlyScopes(repository, scope, (db, graphScope) => {
         if (!db)
             return [];
         const freshness = selectFreshnessReport(db, repository.id);
-        return selectEdges(db, repository.id, { kind, limit }).map((row) => ({ scope: graphScope, freshness, ...row }));
+        return selectEdges(db, repository.id, { kind, type, limit }).map((row) => ({ scope: graphScope, freshness, ...row }));
     }).flat();
 }
 export function neighbors({ root = process.cwd(), scope = 'repo', nodeId, depth = 1, limit = 100 } = {}) {

package/dist/src/index.d.ts

@@ -6,6 +6,7 @@ export { PackagePlugin } from './scanner/packagePlugin.js';
 export { PythonScannerPlugin, PYTHON_SCANNER_PLUGIN_NAME, scanPythonFiles } from './scanner/pythonPlugin.js';
 export { JavaScannerPlugin, JAVA_SCANNER_PLUGIN_NAME, scanJavaFiles } from './scanner/javaPlugin.js';
 export { JavaDependencyPlugin, JAVA_DEPENDENCY_PLUGIN_NAME, scanJavaDependencies } from './scanner/javaDependencyPlugin.js';
+export { AttributionPlugin, ATTRIBUTION_PLUGIN_NAME } from './scanner/attributionPlugin.js';
 export { inventoryRepositoryManifests, inspectRepositoryManifests, mergeManifestInventories } from './scanner/artifactInventory.js';
 export type { RepositoryManifest, ManifestKind, ManifestStatus } from './scanner/artifactInventory.js';
 export { viewGraph, loadViewSnapshot, buildViewModel, renderInteractiveHtml, renderSvgMarkup, openInDefaultBrowser, openHtmlArtifactInBrowser, writeTemporaryHtmlArtifact } from './view/index.js';

package/dist/src/index.js

@@ -5,6 +5,7 @@ export { PackagePlugin } from './scanner/packagePlugin.js';
 export { PythonScannerPlugin, PYTHON_SCANNER_PLUGIN_NAME, scanPythonFiles } from './scanner/pythonPlugin.js';
 export { JavaScannerPlugin, JAVA_SCANNER_PLUGIN_NAME, scanJavaFiles } from './scanner/javaPlugin.js';
 export { JavaDependencyPlugin, JAVA_DEPENDENCY_PLUGIN_NAME, scanJavaDependencies } from './scanner/javaDependencyPlugin.js';
+export { AttributionPlugin, ATTRIBUTION_PLUGIN_NAME } from './scanner/attributionPlugin.js';
 export { inventoryRepositoryManifests, inspectRepositoryManifests, mergeManifestInventories } from './scanner/artifactInventory.js';
 export { viewGraph, loadViewSnapshot, buildViewModel, renderInteractiveHtml, renderSvgMarkup, openInDefaultBrowser, openHtmlArtifactInBrowser, writeTemporaryHtmlArtifact } from './view/index.js';
 export { repoDatabasePath, homeDatabasePath, resolveProjectRoot } from './config/paths.js';

package/dist/src/mcp/server.js

@@ -11,8 +11,9 @@ export async function startMcpServer({ root = process.cwd() } = {}) {
     const tool = server.tool.bind(server);
     tool('context_graph_scan', 'Parse repository files with Tree-sitter and write discovered graph nodes/edges to SQLite.', {
         root: z.string().optional().describe('Repository root. Defaults to the MCP server cwd.'),
-        scope: scopeSchema.describe('Graph storage scope to update.')
-    }, async (input) => jsonResponse(await scanRepository({ root: input.root ?? root, scope: input.scope })));
+        scope: scopeSchema.describe('Graph storage scope to update.'),
+        attribution: z.boolean().default(false).describe('Enable optional Git user attribution enrichment.')
+    }, async (input) => jsonResponse(await scanRepository({ root: input.root ?? root, scope: input.scope, attribution: input.attribution })));
     tool('context_graph_context', 'Return stored, relationship-aware context and its persisted freshness report without scanning.', {
         root: z.string().optional(),
         scope: scopeSchema,
@@ -47,11 +48,13 @@ export async function startMcpServer({ root = process.cwd() } = {}) {
         root: z.string().optional(),
         scope: scopeSchema,
         kind: z.enum(['contains', 'defines', 'imports', 'exports', 'calls', 'attributed_to', 'provides']).optional(),
+        type: z.string().min(1).optional(),
         limit: z.number().int().positive().max(500).default(50)
     }, async (input) => jsonResponse(listEdges({
         root: input.root ?? root,
         scope: input.scope,
         kind: input.kind,
+        type: input.type,
         limit: input.limit
     })));
     tool('context_graph_neighbors', 'Return nearby nodes around a graph node id.', {

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

@@ -0,0 +1,5 @@
+import type { ScannerPlugin } from './plugins.js';
+export declare const ATTRIBUTION_PLUGIN_NAME = "git-attribution-plugin";
+/** Optional deferred Git attribution for structural graph nodes. */
+export declare const AttributionPlugin: ScannerPlugin;
+//# sourceMappingURL=attributionPlugin.d.ts.map

package/dist/src/scanner/attributionPlugin.js

@@ -0,0 +1,16 @@
+import { buildFileAttribution } from '../graph/attribution.js';
+export const ATTRIBUTION_PLUGIN_NAME = 'git-attribution-plugin';
+/** Optional deferred Git attribution for structural graph nodes. */
+export const AttributionPlugin = {
+    name: ATTRIBUTION_PLUGIN_NAME,
+    apiVersion: 1,
+    capabilities: ['enrichment'],
+    scan: () => ({ nodes: [], edges: [] }),
+    enrich: ({ repository, work, source, nodes }) => buildFileAttribution({
+        root: repository.root,
+        relativePath: work.path,
+        source,
+        nodes
+    })
+};
+//# sourceMappingURL=attributionPlugin.js.map

package/dist/src/scanner/discover.js

@@ -1,5 +1,4 @@
-import { readdirSync, statSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
+import { readFileSync, readdirSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { isSupportedSourceFile } from '../parser/treeSitter.js';
 const DEFAULT_IGNORES = new Set([
@@ -13,13 +12,14 @@ const DEFAULT_IGNORES = new Set([
 ]);
 export function discoverSourceFiles(root, { ignores = DEFAULT_IGNORES } = {}) {
     const files = [];
-    walk(root, root, files, ignores);
+    const gitignore = readGitignore(root);
+    walk(root, root, files, ignores, gitignore);
     return files.sort();
 }
-function walk(root, current, files, ignores) {
+function walk(root, current, files, ignores, gitignore) {
     const entries = readdirSync(current, { withFileTypes: true });
     const relativePaths = entries.map((entry) => path.relative(root, path.join(current, entry.name)));
-    const gitIgnored = ignoredByGit(root, relativePaths);
+    const gitIgnored = ignoredByGit(gitignore, relativePaths);
     for (let index = 0; index < entries.length; index += 1) {
         const entry = entries[index];
         if (!entry)
@@ -31,7 +31,7 @@ function walk(root, current, files, ignores) {
         if (!relativePath || gitIgnored.has(relativePath))
             continue;
         if (entry.isDirectory()) {
-            walk(root, fullPath, files, ignores);
+            walk(root, fullPath, files, ignores, gitignore);
             continue;
         }
         if (!entry.isFile())
@@ -44,17 +44,90 @@ function walk(root, current, files, ignores) {
         files.push(relativePath);
     }
 }
-function ignoredByGit(root, relativePaths) {
-    if (relativePaths.length === 0)
-        return new Set();
-    const result = spawnSync('git', ['check-ignore', '--stdin', '-z'], {
-        cwd: root,
-        input: `${relativePaths.join('\0')}\0`,
-        encoding: 'utf8'
+function readGitignore(root) {
+    let contents;
+    try {
+        contents = readFileSync(path.join(root, '.gitignore'), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    return contents
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith('#'))
+        .map((line) => {
+        const negated = line.startsWith('!');
+        const pattern = negated ? line.slice(1) : line;
+        return { expression: gitignorePatternToRegExp(pattern), negated };
     });
-    if (result.error || (result.status !== 0 && result.status !== 1)) {
-        return new Set();
+}
+function ignoredByGit(patterns, relativePaths) {
+    const ignored = new Set();
+    for (const relativePath of relativePaths) {
+        const normalizedPath = relativePath.split(path.sep).join('/');
+        let isIgnored = false;
+        for (const pattern of patterns) {
+            if (pattern.expression.test(normalizedPath))
+                isIgnored = !pattern.negated;
+        }
+        if (isIgnored)
+            ignored.add(relativePath);
+    }
+    return ignored;
+}
+function gitignorePatternToRegExp(pattern) {
+    const directoryOnly = pattern.endsWith('/');
+    const withoutTrailingSlash = directoryOnly ? pattern.slice(0, -1) : pattern;
+    const anchored = withoutTrailingSlash.startsWith('/');
+    const value = anchored ? withoutTrailingSlash.slice(1) : withoutTrailingSlash;
+    const source = globToRegExp(value);
+    // A pattern without a slash applies to a name at any depth. Patterns with
+    // a slash are relative to the repository root, as they are in gitignore.
+    if (!value.includes('/')) {
+        return new RegExp(`(?:^|/)${source}(?:$|/)`);
+    }
+    return new RegExp(`^${source}(?:$|/)`);
+}
+function globToRegExp(pattern) {
+    let result = '';
+    for (let index = 0; index < pattern.length; index += 1) {
+        const character = pattern[index];
+        if (character === undefined)
+            continue;
+        if (character === '*') {
+            if (pattern[index + 1] === '*') {
+                while (pattern[index + 1] === '*')
+                    index += 1;
+                if (pattern[index + 1] === '/') {
+                    index += 1;
+                    result += '(?:.*/)?';
+                }
+                else {
+                    result += '.*';
+                }
+            }
+            else {
+                result += '[^/]*';
+            }
+        }
+        else if (character === '?') {
+            result += '[^/]';
+        }
+        else if (character === '[') {
+            const closing = pattern.indexOf(']', index + 1);
+            if (closing !== -1) {
+                result += pattern.slice(index, closing + 1);
+                index = closing;
+            }
+            else {
+                result += '\\[';
+            }
+        }
+        else {
+            result += /[\\^$+.()|{}]/u.test(character) ? `\\${character}` : character;
+        }
     }
-    return new Set(result.stdout.split('\0').filter(Boolean));
+    return result;
 }
 //# sourceMappingURL=discover.js.map

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

@@ -1,8 +1,8 @@
-import type { FileRecord, GraphEdge, GraphNode, GraphExtractionResult, Point } from '../types.js';
+import type { EnrichmentRunnerInput, AttributionOutcome, FileRecord, GraphEdge, GraphNode, GraphExtractionResult, Point } from '../types.js';
 import { type RepositoryManifest } from './artifactInventory.js';
 export declare const SCANNER_PLUGIN_API_VERSION: 1;
 export type PluginConflictPolicy = 'merge' | 'replace' | 'reject';
-export type ScannerCapability = 'file-scanner' | 'repository-analyzer';
+export type ScannerCapability = 'file-scanner' | 'repository-analyzer' | 'enrichment';
 export interface RepositoryScanFile extends FileRecord {
     absolutePath: string;
     source: string;
@@ -45,6 +45,7 @@ export interface PluginEdgeFact {
     targetPlugin?: string;
     filePath?: string;
     kind: GraphEdge['kind'];
+    type?: string;
     confidence?: number;
     metadata?: Record<string, unknown>;
     conflict?: PluginConflictPolicy;
@@ -99,6 +100,8 @@ export interface ScannerPlugin {
     dispose?(context: RepositoryScanContext): void | Promise<void>;
     /** Opt-in delta hook. Plugins without it retain the complete-repository v1 scan contract. */
     scanIncremental?(context: RepositoryScanContext, delta: RepositoryScanDelta, previous?: PreviousPluginContribution): IncrementalPluginScanResult | Promise<IncrementalPluginScanResult>;
+    /** Optional deferred enrichment hook. The host supplies structural nodes after the file scan. */
+    enrich?(input: EnrichmentRunnerInput): AttributionOutcome | Promise<AttributionOutcome>;
 }
 export interface PluginRunResult extends GraphExtractionResult {
     diagnostics: string[];
@@ -110,6 +113,7 @@ export interface PluginRunResult extends GraphExtractionResult {
         nodes: GraphNode[];
         edges: GraphEdge[];
     }>;
+    enrichmentPlugins?: Map<string, ScannerPlugin>;
 }
 export declare function createRepositoryScanContext(repoPath: string, suppliedManifests?: readonly RepositoryManifest[]): RepositoryScanContext;
 export declare function runScannerPlugins(context: RepositoryScanContext, plugins: readonly ScannerPlugin[], resourceLimits?: Partial<PluginResourceLimits>, delta?: RepositoryScanDelta, previousContributions?: ReadonlyMap<string, PreviousPluginContribution>): Promise<PluginRunResult>;

package/dist/src/scanner/plugins.js

@@ -50,6 +50,7 @@ export async function runScannerPlugins(context, plugins, resourceLimits = {}, d
     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) {
@@ -72,6 +73,11 @@ export async function runScannerPlugins(context, plugins, resourceLimits = {}, d
             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);
@@ -123,6 +129,7 @@ export async function runScannerPlugins(context, plugins, resourceLimits = {}, d
             sourceId: source.id,
             targetId: target.id,
             kind: edge.kind,
+            type: edge.type ?? edge.kind,
             confidence: edge.confidence ?? 1,
             metadata: {
                 ...(edge.metadata ?? {}),
@@ -180,7 +187,7 @@ export async function runScannerPlugins(context, plugins, resourceLimits = {}, d
         pluginContributions.set(plugin, created);
         return created;
     }
-    return { nodes: mergedNodes, edges: mergedEdges, diagnostics, failedPaths: [...failedPaths].sort(), 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/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) {
@@ -56,6 +57,14 @@ function ensureSchemaVersion(db) {
     }
     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;
     }
@@ -126,6 +135,19 @@ function migrateSchemaV6ToV7(db) {
       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/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