@psnext/lscg 0.1.1

package/dist/src/graph/repository.js

@@ -0,0 +1,361 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { databasePathForScope, homeDatabasePath, normalizeScope, repoDatabasePath, resolveProjectRoot } from '../config/paths.js';
+import { parseSource } from '../parser/treeSitter.js';
+import { discoverSourceFiles } from '../scanner/discover.js';
+import { collectRepositoryFingerprint } from '../scanner/fingerprint.js';
+import { attachDatabase, closeDatabase, getStatus, openGraphDatabase, replaceFileGraph, runSelect, selectCallGraph, selectEdges, selectNeighbors, selectNodes, selectNodeTextRows, upsertRepository, reconcileDeletedFiles, selectFileInventory, selectContextCandidates, selectContextRelationships } from '../storage/database.js';
+import { extractGraph, hashParts } from './extract.js';
+import { buildFileAttribution } from './attribution.js';
+export function repositoryForRoot(root = process.cwd()) {
+    const resolvedRoot = resolveProjectRoot(root);
+    return {
+        id: hashParts(['repository', resolvedRoot]),
+        root: resolvedRoot,
+        name: path.basename(resolvedRoot)
+    };
+}
+export function initGraph({ root = process.cwd(), scope = 'repo' } = {}) {
+    const repository = repositoryForRoot(root);
+    const scopes = normalizeScope(scope);
+    const initialized = [];
+    for (const graphScope of scopes) {
+        const databasePath = databasePathForScope(graphScope, repository.root);
+        const db = openGraphDatabase(databasePath);
+        try {
+            upsertRepository(db, repository);
+            initialized.push({ scope: graphScope, databasePath });
+        }
+        finally {
+            closeDatabase(db);
+        }
+    }
+    return { repository, initialized };
+}
+export async function scanRepository({ root = process.cwd(), scope = 'repo' } = {}) {
+    const repository = repositoryForRoot(root);
+    const scopes = normalizeScope(scope);
+    const files = discoverSourceFiles(repository.root);
+    const opened = scopes.map((graphScope) => {
+        const databasePath = databasePathForScope(graphScope, repository.root);
+        return { scope: graphScope, databasePath, db: openGraphDatabase(databasePath) };
+    });
+    let filesScanned = 0;
+    let nodesWritten = 0;
+    let edgesWritten = 0;
+    const skipped = [];
+    try {
+        for (const handle of opened)
+            upsertRepository(handle.db, repository);
+        for (const relativePath of files) {
+            const absolutePath = path.join(repository.root, relativePath);
+            const source = readFileSync(absolutePath, 'utf8');
+            const parseResult = parseSource(absolutePath, source);
+            if (!parseResult) {
+                skipped.push(relativePath);
+                continue;
+            }
+            const stat = statSync(absolutePath);
+            const sourceHash = sha256(source);
+            const fileId = hashParts([repository.id, relativePath]);
+            const file = {
+                id: fileId,
+                path: relativePath,
+                language: parseResult.language,
+                hash: sourceHash,
+                size: stat.size,
+                mtimeMs: Math.round(stat.mtimeMs)
+            };
+            const graph = extractGraph({
+                repositoryId: repository.id,
+                fileId,
+                relativePath,
+                source,
+                sourceHash,
+                parseResult
+            });
+            const attribution = buildFileAttribution({
+                root: repository.root,
+                relativePath,
+                source,
+                nodes: graph.nodes
+            });
+            for (const handle of opened) {
+                replaceFileGraph(handle.db, { repository, file, nodes: graph.nodes, edges: graph.edges, attribution });
+            }
+            filesScanned += 1;
+            nodesWritten += graph.nodes.length + (attribution?.contributorEmails.length ?? 0);
+            edgesWritten += graph.edges.length + (attribution?.nodeAttributions.reduce((sum, entry) => sum + entry.contributorEmails.length, 0) ?? 0);
+        }
+    }
+    finally {
+        for (const handle of opened)
+            closeDatabase(handle.db);
+    }
+    return {
+        repository,
+        scopes: opened.map(({ scope: graphScope, databasePath }) => ({ scope: graphScope, databasePath })),
+        filesDiscovered: files.length,
+        filesScanned,
+        nodesWritten,
+        edgesWritten,
+        skipped
+    };
+}
+export function graphStatus({ root = process.cwd(), scope = 'repo' } = {}) {
+    const repository = repositoryForRoot(root);
+    return withScopes(repository, scope, (db, graphScope, databasePath) => ({
+        scope: graphScope,
+        databasePath,
+        ...getStatus(db, repository.id)
+    }));
+}
+export function listNodes({ root = process.cwd(), scope = 'repo', kind, limit = 50 } = {}) {
+    const repository = repositoryForRoot(root);
+    return withScopes(repository, scope, (db, graphScope) => selectNodes(db, repository.id, { kind, limit }).map((row) => ({ scope: graphScope, ...row }))).flat();
+}
+export function listNodeText({ root = process.cwd(), scope = 'repo', kind, term, limit = 50 } = {}) {
+    const repository = repositoryForRoot(root);
+    return withScopes(repository, scope, (db, graphScope) => selectNodeTextRows(db, repository.id, { kind, term, limit }).map((row) => ({
+        scope: graphScope,
+        root: repository.root,
+        ...row,
+        path: row.path ? path.resolve(repository.root, row.path) : null
+    }))).flat();
+}
+export function listEdges({ root = process.cwd(), scope = 'repo', kind, limit = 50 } = {}) {
+    const repository = repositoryForRoot(root);
+    return withScopes(repository, scope, (db, graphScope) => selectEdges(db, repository.id, { kind, limit }).map((row) => ({ scope: graphScope, ...row }))).flat();
+}
+export function neighbors({ root = process.cwd(), scope = 'repo', nodeId, depth = 1, limit = 100 } = {}) {
+    if (!nodeId)
+        throw new Error('neighbors requires a nodeId');
+    const repository = repositoryForRoot(root);
+    return withScopes(repository, scope, (db, graphScope) => selectNeighbors(db, repository.id, nodeId, { depth, limit }).map((row) => ({ scope: graphScope, ...row }))).flat();
+}
+export function callGraph({ root = process.cwd(), scope = 'repo', term, kind, depth = 5, limit = 100 } = {}) {
+    if (!term?.trim())
+        throw new Error('callgraph requires a term');
+    const repository = repositoryForRoot(root);
+    return withScopes(repository, scope, (db, graphScope) => selectCallGraph(db, repository.id, term.trim(), { kind, depth, limit }).map((row) => ({ scope: graphScope, ...row }))).flat();
+}
+const CONTEXT_DEFAULTS = {
+    depth: 2,
+    relationshipLimit: 50,
+    candidateLimit: 20,
+    excerptLines: 80,
+    excerptBytes: 12_000
+};
+export async function contextGraph(options) {
+    if (!options.symbol?.trim())
+        throw new Error('context requires a symbol');
+    const repository = repositoryForRoot(options.root);
+    const scopeValue = options.scope ?? 'repo';
+    const budget = {
+        depth: clampContext(options.depth, 0, 5, CONTEXT_DEFAULTS.depth),
+        relationshipLimit: clampContext(options.limit, 1, 500, CONTEXT_DEFAULTS.relationshipLimit),
+        candidateLimit: clampContext(options.candidateLimit, 1, 100, CONTEXT_DEFAULTS.candidateLimit),
+        excerptLines: clampContext(options.excerptLines, 1, 500, CONTEXT_DEFAULTS.excerptLines),
+        excerptBytes: clampContext(options.excerptBytes, 1, 100_000, CONTEXT_DEFAULTS.excerptBytes)
+    };
+    const request = {
+        symbol: options.symbol.trim(),
+        root: repository.root,
+        scope: scopeValue,
+        ...(options.kind ? { kind: options.kind } : {}),
+        ...(options.file ? { file: options.file } : {}),
+        budget,
+        excerpts: Boolean(options.excerpts)
+    };
+    const scopes = normalizeScope(scopeValue);
+    const scopeResults = [];
+    for (const graphScope of scopes) {
+        scopeResults.push(await contextForScope(repository, graphScope, request, options.excerpts === true));
+    }
+    return { contract_version: 1, repository, request, scopes: scopeResults };
+}
+async function contextForScope(repository, graphScope, request, excerpts) {
+    const databasePath = databasePathForScope(graphScope, repository.root);
+    const discovered = discoverSourceFiles(repository.root);
+    const beforeFingerprint = collectRepositoryFingerprint(repository.root);
+    let db = openGraphDatabase(databasePath);
+    let refresh = {
+        outcome: 'reused', filesDiscovered: discovered.length, filesScanned: 0, skipped: []
+    };
+    let freshness = 'unchanged';
+    let priorGraph = false;
+    try {
+        upsertRepository(db, repository);
+        const inventory = selectFileInventory(db, repository.id);
+        priorGraph = inventory.length > 0;
+        const inventoryChanged = inventory.length !== discovered.length || discovered.some((file, index) => {
+            const row = inventory[index];
+            if (!row || row.path !== file)
+                return true;
+            try {
+                const stat = statSync(path.join(repository.root, file));
+                return row.size !== stat.size || row.mtimeMs !== Math.round(stat.mtimeMs);
+            }
+            catch {
+                return true;
+            }
+        });
+        if (inventoryChanged) {
+            closeDatabase(db);
+            db = undefined;
+            try {
+                const summary = await scanRepository({ root: repository.root, scope: graphScope });
+                refresh = {
+                    outcome: summary.skipped.length > 0 ? 'refresh_failed' : 'refreshed',
+                    filesDiscovered: summary.filesDiscovered,
+                    filesScanned: summary.filesScanned,
+                    skipped: summary.skipped
+                };
+                if (summary.skipped.length > 0)
+                    return failedContextScope(graphScope, databasePath, refresh, priorGraph);
+                const refreshedDb = openGraphDatabase(databasePath);
+                try {
+                    reconcileDeletedFiles(refreshedDb, repository.id, discovered);
+                }
+                finally {
+                    closeDatabase(refreshedDb);
+                }
+                freshness = 'refreshed';
+                db = openGraphDatabase(databasePath);
+                upsertRepository(db, repository);
+            }
+            catch (error) {
+                refresh = { ...refresh, outcome: 'refresh_failed', skipped: [error instanceof Error ? error.message : String(error)] };
+                return failedContextScope(graphScope, databasePath, refresh, priorGraph);
+            }
+        }
+        const afterFingerprint = collectRepositoryFingerprint(repository.root);
+        if (afterFingerprint !== beforeFingerprint) {
+            return failedContextScope(graphScope, databasePath, refresh, priorGraph, 'stale');
+        }
+        const candidateRows = selectContextCandidates(db, repository.id, request.symbol, {
+            kind: request.kind,
+            file: request.file,
+            limit: request.budget.candidateLimit + 1
+        });
+        const candidateTruncated = candidateRows.length > request.budget.candidateLimit;
+        const candidates = candidateRows.slice(0, request.budget.candidateLimit);
+        const truncation = candidateTruncated
+            ? [{ section: 'candidates', reason: 'candidate_limit', omitted: 1 }]
+            : [];
+        if (candidates.length === 0) {
+            return { scope: graphScope, databasePath, result: { state: 'not_found', impact: [], dependencies: [], warnings: [], truncation }, freshness: { state: freshness, verification: 'metadata_only', refresh } };
+        }
+        if (candidateTruncated || candidates.length !== 1) {
+            return { scope: graphScope, databasePath, result: { state: 'ambiguous', candidates: candidates.map(stripCandidate), impact: [], dependencies: [], warnings: [], truncation }, freshness: { state: freshness, verification: 'metadata_only', refresh } };
+        }
+        const anchor = stripInternalReference(candidates[0]);
+        const rawRelations = request.budget.depth === 0
+            ? []
+            : selectContextRelationships(db, repository.id, anchor.id, request.budget.relationshipLimit, request.budget.depth);
+        const impact = [];
+        const dependencies = [];
+        for (const relation of rawRelations) {
+            const source = stripInternalReference(relation.source);
+            const target = stripInternalReference(relation.target);
+            if (relation.edgeKind === 'calls') {
+                impact.push({ category: 'impact', edgeKind: relation.edgeKind, direction: relation.source.id === anchor.id ? 'callee' : 'caller', source, target, confidence: relation.confidence, provenance: relation.metadata, depth: relation.depth });
+            }
+            else {
+                dependencies.push({ category: 'dependency', edgeKind: relation.edgeKind, direction: relation.edgeKind === 'imports' ? 'import' : 'export', source, target, confidence: relation.confidence, provenance: relation.metadata, depth: relation.depth });
+            }
+        }
+        const warnings = candidates[0]?.match === 'substring' ? ['substring_search=bounded_like'] : [];
+        let verification = 'metadata_only';
+        if (excerpts) {
+            const excerptStatus = await addExcerpt(repository.root, anchor, request.budget);
+            if (excerptStatus === 'checked')
+                verification = 'content_hash';
+            if (excerptStatus === 'unavailable')
+                warnings.push('excerpt_unavailable');
+            if (excerptStatus === 'mismatch')
+                warnings.push('excerpt_unavailable:source_hash_mismatch');
+        }
+        return {
+            scope: graphScope,
+            databasePath,
+            result: { state: 'ok', anchor, definition: anchor, impact, dependencies, warnings, truncation },
+            freshness: { state: freshness, verification, refresh }
+        };
+    }
+    finally {
+        if (db)
+            closeDatabase(db);
+    }
+}
+function failedContextScope(scope, databasePath, refresh, priorGeneration, state = 'refresh_failed') {
+    return {
+        scope,
+        databasePath,
+        result: { state, impact: [], dependencies: [], warnings: refresh.skipped, truncation: [] },
+        freshness: { state: state === 'stale' || priorGeneration ? 'stale' : 'refresh_failed', verification: 'metadata_only', refresh: { ...refresh, outcome: state === 'stale' ? refresh.outcome : 'refresh_failed' } }
+    };
+}
+function stripCandidate(candidate) {
+    const { fileId: _fileId, ...publicCandidate } = candidate;
+    return publicCandidate;
+}
+function stripInternalReference(reference) {
+    const { fileId: _fileId, rank: _rank, match: _match, ...publicReference } = reference;
+    return publicReference;
+}
+async function addExcerpt(root, anchor, budget) {
+    if (!anchor.path || !anchor.sourceHash)
+        return 'unavailable';
+    try {
+        const source = readFileSync(path.join(root, anchor.path), 'utf8');
+        if (sha256(source) !== anchor.sourceHash)
+            return 'mismatch';
+        const lines = source.split(/\r?\n/);
+        const start = Math.max(0, anchor.span.start.row);
+        const end = Math.min(lines.length, start + budget.excerptLines);
+        const bounded = Buffer.from(lines.slice(start, end).join('\\n'), 'utf8').subarray(0, budget.excerptBytes).toString('utf8');
+        anchor.excerpt = bounded;
+        return 'checked';
+    }
+    catch {
+        return 'unavailable';
+    }
+}
+function clampContext(value, min, max, fallback) {
+    if (value === undefined || !Number.isFinite(value))
+        return fallback;
+    return Math.max(min, Math.min(max, Math.trunc(value)));
+}
+export function runReadOnlySql({ root = process.cwd(), scope = 'repo', sql, attachHome = false, limit = 200 } = {}) {
+    if (!sql)
+        throw new Error('query requires SQL text');
+    const repository = repositoryForRoot(root);
+    return withScopes(repository, scope, (db, graphScope) => {
+        if (attachHome && graphScope === 'repo')
+            attachDatabase(db, 'home_graph', homeDatabasePath());
+        const rows = runSelect(db, sql, { limit });
+        return { scope: graphScope, rows };
+    });
+}
+function withScopes(repository, scope, fn) {
+    const scopes = normalizeScope(scope);
+    const results = [];
+    for (const graphScope of scopes) {
+        const databasePath = graphScope === 'repo' ? repoDatabasePath(repository.root) : homeDatabasePath();
+        const db = openGraphDatabase(databasePath);
+        try {
+            upsertRepository(db, repository);
+            results.push(fn(db, graphScope, databasePath));
+        }
+        finally {
+            closeDatabase(db);
+        }
+    }
+    return results;
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+//# sourceMappingURL=repository.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export { initGraph, listEdges, listNodes, graphStatus, callGraph, neighbors, contextGraph, runReadOnlySql, scanRepository } from './graph/repository.js';
+export { watchRepository } from './watch.js';
+export { viewGraph, loadViewSnapshot, buildViewModel, renderInteractiveHtml, renderSvgMarkup, openInDefaultBrowser, openHtmlArtifactInBrowser, writeTemporaryHtmlArtifact } from './view/index.js';
+export { repoDatabasePath, homeDatabasePath, resolveProjectRoot } from './config/paths.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -0,0 +1,5 @@
+export { initGraph, listEdges, listNodes, graphStatus, callGraph, neighbors, contextGraph, runReadOnlySql, scanRepository } from './graph/repository.js';
+export { watchRepository } from './watch.js';
+export { viewGraph, loadViewSnapshot, buildViewModel, renderInteractiveHtml, renderSvgMarkup, openInDefaultBrowser, openHtmlArtifactInBrowser, writeTemporaryHtmlArtifact } from './view/index.js';
+export { repoDatabasePath, homeDatabasePath, resolveProjectRoot } from './config/paths.js';
+//# sourceMappingURL=index.js.map

package/dist/src/mcp/server.d.ts

@@ -0,0 +1,6 @@
+interface ServerOptions {
+    root?: string | undefined;
+}
+export declare function startMcpServer({ root }?: ServerOptions): Promise<void>;
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/src/mcp/server.js

@@ -0,0 +1,81 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { graphStatus, listEdges, listNodes, neighbors, runReadOnlySql, scanRepository } from '../graph/repository.js';
+const scopeSchema = z.enum(['repo', 'home', 'both']).default('repo');
+export async function startMcpServer({ root = process.cwd() } = {}) {
+    const server = new McpServer({
+        name: 'lscg',
+        version: '0.1.0'
+    });
+    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 })));
+    tool('context_graph_status', 'Return repository graph counts and database paths.', {
+        root: z.string().optional(),
+        scope: scopeSchema
+    }, async (input) => jsonResponse(graphStatus({ root: input.root ?? root, scope: input.scope })));
+    tool('context_graph_nodes', 'List graph nodes discovered in the repository.', {
+        root: z.string().optional(),
+        scope: scopeSchema,
+        kind: z.enum(['file', 'symbol', 'import', 'export', 'call', 'user']).optional(),
+        limit: z.number().int().positive().max(500).default(50)
+    }, async (input) => jsonResponse(listNodes({
+        root: input.root ?? root,
+        scope: input.scope,
+        kind: input.kind,
+        limit: input.limit
+    })));
+    tool('context_graph_edges', 'List graph edges discovered in the repository.', {
+        root: z.string().optional(),
+        scope: scopeSchema,
+        kind: z.enum(['contains', 'defines', 'imports', 'exports', 'calls', 'attributed_to']).optional(),
+        limit: z.number().int().positive().max(500).default(50)
+    }, async (input) => jsonResponse(listEdges({
+        root: input.root ?? root,
+        scope: input.scope,
+        kind: input.kind,
+        limit: input.limit
+    })));
+    tool('context_graph_neighbors', 'Return nearby nodes around a graph node id.', {
+        root: z.string().optional(),
+        scope: scopeSchema,
+        nodeId: z.string().min(1),
+        depth: z.number().int().positive().max(5).default(1),
+        limit: z.number().int().positive().max(500).default(100)
+    }, async (input) => jsonResponse(neighbors({
+        root: input.root ?? root,
+        scope: input.scope,
+        nodeId: input.nodeId,
+        depth: input.depth,
+        limit: input.limit
+    })));
+    tool('context_graph_query', 'Run a read-only SQLite query against the graph database. Only SELECT, WITH, and PRAGMA are allowed.', {
+        root: z.string().optional(),
+        scope: scopeSchema,
+        sql: z.string().min(1),
+        attachHome: z.boolean().default(false).describe('When querying repo scope, ATTACH the home graph as home_graph.'),
+        limit: z.number().int().positive().max(1000).default(200)
+    }, async (input) => jsonResponse(runReadOnlySql({
+        root: input.root ?? root,
+        scope: input.scope,
+        sql: input.sql,
+        attachHome: input.attachHome,
+        limit: input.limit
+    })));
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+function jsonResponse(value) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(value, null, 2)
+            }
+        ]
+    };
+}
+//# sourceMappingURL=server.js.map

package/dist/src/parser/treeSitter.d.ts

@@ -0,0 +1,13 @@
+import type { ParseResult } from '../types.js';
+type LanguageConfig = {
+    name: string;
+    parserVersion: string;
+    extensions: string[];
+    language: any;
+};
+export declare function supportedExtensions(): string[];
+export declare function languageForPath(filePath: string): LanguageConfig | undefined;
+export declare function isSupportedSourceFile(filePath: string): boolean;
+export declare function parseSource(filePath: string, source: string): ParseResult | null;
+export {};
+//# sourceMappingURL=treeSitter.d.ts.map

package/dist/src/parser/treeSitter.js

@@ -0,0 +1,61 @@
+import path from 'node:path';
+import Parser from 'tree-sitter';
+import JavaScriptLanguage from 'tree-sitter-javascript';
+import TypeScriptLanguages from 'tree-sitter-typescript';
+const typeScriptModule = TypeScriptLanguages.default ?? TypeScriptLanguages;
+const LANGUAGE_CONFIGS = [
+    {
+        name: 'javascript',
+        parserVersion: 'tree-sitter-javascript',
+        extensions: ['.js', '.mjs', '.cjs', '.jsx'],
+        language: JavaScriptLanguage.default ?? JavaScriptLanguage
+    },
+    {
+        name: 'typescript',
+        parserVersion: 'tree-sitter-typescript',
+        extensions: ['.ts', '.mts', '.cts'],
+        language: typeScriptModule.typescript ?? typeScriptModule
+    },
+    {
+        name: 'tsx',
+        parserVersion: 'tree-sitter-typescript-tsx',
+        extensions: ['.tsx'],
+        language: typeScriptModule.tsx ?? typeScriptModule.typescript ?? typeScriptModule
+    }
+];
+const byExtension = new Map();
+for (const config of LANGUAGE_CONFIGS) {
+    for (const extension of config.extensions) {
+        byExtension.set(extension, config);
+    }
+}
+const parserCache = new Map();
+export function supportedExtensions() {
+    return [...byExtension.keys()];
+}
+export function languageForPath(filePath) {
+    return byExtension.get(path.extname(filePath));
+}
+export function isSupportedSourceFile(filePath) {
+    return Boolean(languageForPath(filePath));
+}
+export function parseSource(filePath, source) {
+    const config = languageForPath(filePath);
+    if (!config)
+        return null;
+    let parser = parserCache.get(config.name);
+    if (!parser) {
+        parser = new Parser();
+        parser.setLanguage(config.language);
+        parserCache.set(config.name, parser);
+    }
+    let tree;
+    try {
+        tree = parser.parse(source);
+    }
+    catch {
+        return null;
+    }
+    return { tree, language: config.name, parser: 'tree-sitter', parserVersion: config.parserVersion };
+}
+//# sourceMappingURL=treeSitter.js.map

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

@@ -0,0 +1,4 @@
+export declare function discoverSourceFiles(root: string, { ignores }?: {
+    ignores?: Set<string>;
+}): string[];
+//# sourceMappingURL=discover.d.ts.map

package/dist/src/scanner/discover.js

@@ -0,0 +1,62 @@
+import { readdirSync, statSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { isSupportedSourceFile } from '../parser/treeSitter.js';
+const DEFAULT_IGNORES = new Set([
+    '.git',
+    '.sling',
+    '.pi-subagents',
+    'node_modules',
+    'dist',
+    'coverage',
+    '.next',
+    '.turbo',
+    '.cache'
+]);
+export function discoverSourceFiles(root, { ignores = DEFAULT_IGNORES } = {}) {
+    const files = [];
+    walk(root, root, files, ignores);
+    return files.sort();
+}
+function walk(root, current, files, ignores) {
+    const entries = readdirSync(current, { withFileTypes: true });
+    const relativePaths = entries.map((entry) => path.relative(root, path.join(current, entry.name)));
+    const gitIgnored = ignoredByGit(root, relativePaths);
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (!entry)
+            continue;
+        if (ignores.has(entry.name))
+            continue;
+        const fullPath = path.join(current, entry.name);
+        const relativePath = relativePaths[index];
+        if (!relativePath || gitIgnored.has(relativePath))
+            continue;
+        if (entry.isDirectory()) {
+            walk(root, fullPath, files, ignores);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if (!isSupportedSourceFile(fullPath))
+            continue;
+        const stat = statSync(fullPath);
+        if (stat.size > 2_000_000)
+            continue;
+        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'
+    });
+    if (result.error || (result.status !== 0 && result.status !== 1)) {
+        return new Set();
+    }
+    return new Set(result.stdout.split('\0').filter(Boolean));
+}
+//# sourceMappingURL=discover.js.map

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

@@ -0,0 +1,3 @@
+/** Fast metadata fingerprint shared by watch and context freshness checks. */
+export declare function collectRepositoryFingerprint(root: string): string;
+//# sourceMappingURL=fingerprint.d.ts.map

package/dist/src/scanner/fingerprint.js

@@ -0,0 +1,27 @@
+import { createHash } from 'node:crypto';
+import { statSync } from 'node:fs';
+import path from 'node:path';
+import { discoverSourceFiles } from './discover.js';
+/** Fast metadata fingerprint shared by watch and context freshness checks. */
+export function collectRepositoryFingerprint(root) {
+    const files = discoverSourceFiles(root);
+    const hash = createHash('sha256');
+    for (const relativePath of files) {
+        const absolutePath = path.join(root, relativePath);
+        try {
+            const stat = statSync(absolutePath);
+            hash.update(relativePath);
+            hash.update('\0');
+            hash.update(String(stat.size));
+            hash.update('\0');
+            hash.update(String(Math.round(stat.mtimeMs)));
+            hash.update('\0');
+        }
+        catch {
+            hash.update(relativePath);
+            hash.update('\0missing\0');
+        }
+    }
+    return hash.digest('hex');
+}
+//# sourceMappingURL=fingerprint.js.map