@psnext/lscg 0.1.4 → 0.1.6

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

@@ -0,0 +1,21 @@
+import { extractGraph } from './extract.js';
+export interface RepositoryScanTask {
+    repositoryId: string;
+    relativePath: string;
+    absolutePath: string;
+    source: string;
+    sourceHash: string;
+    mtimeMs: number;
+}
+export interface RepositoryScanResult {
+    relativePath: string;
+    sourceHash: string;
+    size: number;
+    mtimeMs: number;
+    language?: string;
+    parser?: string;
+    parserVersion?: string;
+    graph?: ReturnType<typeof extractGraph>;
+    error?: string;
+}
+//# sourceMappingURL=repositoryScanWorker.d.ts.map

package/dist/src/graph/repositoryScanWorker.js

@@ -0,0 +1,45 @@
+import { parentPort } from 'node:worker_threads';
+import { extractGraph, hashParts } from './extract.js';
+import { parseSource } from '../parser/treeSitter.js';
+if (!parentPort)
+    throw new Error('repository scan worker requires a parent port');
+parentPort.on('message', (tasks) => {
+    const results = tasks.map((task) => {
+        const parsed = parseSource(task.absolutePath, task.source);
+        if (!parsed) {
+            return { relativePath: task.relativePath, sourceHash: task.sourceHash, size: Buffer.byteLength(task.source, 'utf8'), mtimeMs: task.mtimeMs, error: 'unsupported or unparseable source' };
+        }
+        try {
+            return {
+                relativePath: task.relativePath,
+                sourceHash: task.sourceHash,
+                size: Buffer.byteLength(task.source, 'utf8'),
+                mtimeMs: task.mtimeMs,
+                language: parsed.language,
+                parser: parsed.parser,
+                parserVersion: parsed.parserVersion,
+                graph: parsed.language === 'python' || parsed.language === 'java'
+                    ? { nodes: [], edges: [] }
+                    : extractGraph({
+                        repositoryId: task.repositoryId,
+                        fileId: hashParts([task.repositoryId, task.relativePath]),
+                        relativePath: task.relativePath,
+                        source: task.source,
+                        sourceHash: task.sourceHash,
+                        parseResult: parsed
+                    })
+            };
+        }
+        catch (error) {
+            return {
+                relativePath: task.relativePath,
+                sourceHash: task.sourceHash,
+                size: Buffer.byteLength(task.source, 'utf8'),
+                mtimeMs: task.mtimeMs,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    });
+    parentPort.postMessage(results);
+});
+//# sourceMappingURL=repositoryScanWorker.js.map

package/dist/src/index.d.ts

@@ -3,6 +3,12 @@ export { watchRepository } from './watch.js';
 export { SCANNER_PLUGIN_API_VERSION, DEFAULT_PLUGIN_RESOURCE_LIMITS, createRepositoryScanContext, runScannerPlugins, BUILTIN_GRAPH_PLUGIN } from './scanner/plugins.js';
 export type { ScannerPlugin, ScannerCapability, PluginConflictPolicy, PluginNodeFact, PluginEdgeFact, PluginScanResult, PluginRunResult, PluginResourceLimits, RepositoryScanContext, RepositoryScanFile } from './scanner/plugins.js';
 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';
 export { repoDatabasePath, homeDatabasePath, resolveProjectRoot } from './config/paths.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -2,6 +2,11 @@ export { initGraph, listEdges, listNodes, graphStatus, callGraph, neighbors, con
 export { watchRepository } from './watch.js';
 export { SCANNER_PLUGIN_API_VERSION, DEFAULT_PLUGIN_RESOURCE_LIMITS, createRepositoryScanContext, runScannerPlugins, BUILTIN_GRAPH_PLUGIN } from './scanner/plugins.js';
 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';
 //# sourceMappingURL=index.js.map

package/dist/src/mcp/server.js

@@ -1,7 +1,7 @@
 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';
+import { contextGraph, 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({
@@ -11,8 +11,24 @@ 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,
+        symbol: z.string().min(1),
+        kind: z.enum(['file', 'symbol', 'import', 'export', 'call', 'user', 'package']).optional(),
+        depth: z.number().int().min(0).max(5).optional(),
+        limit: z.number().int().positive().max(500).optional()
+    }, async (input) => jsonResponse(await contextGraph({
+        root: input.root ?? root,
+        scope: input.scope,
+        symbol: input.symbol,
+        kind: input.kind,
+        depth: input.depth,
+        limit: input.limit
+    })));
     tool('context_graph_status', 'Return repository graph counts and database paths.', {
         root: z.string().optional(),
         scope: scopeSchema
@@ -32,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/parser/treeSitter.js

@@ -2,6 +2,8 @@ import path from 'node:path';
 import Parser from 'tree-sitter';
 import JavaScriptLanguage from 'tree-sitter-javascript';
 import TypeScriptLanguages from 'tree-sitter-typescript';
+import PythonLanguage from 'tree-sitter-python';
+import JavaLanguage from 'tree-sitter-java';
 const typeScriptModule = TypeScriptLanguages.default ?? TypeScriptLanguages;
 const LANGUAGE_CONFIGS = [
     {
@@ -21,6 +23,18 @@ const LANGUAGE_CONFIGS = [
         parserVersion: 'tree-sitter-typescript-tsx',
         extensions: ['.tsx'],
         language: typeScriptModule.tsx ?? typeScriptModule.typescript ?? typeScriptModule
+    },
+    {
+        name: 'python',
+        parserVersion: 'tree-sitter-python',
+        extensions: ['.py'],
+        language: PythonLanguage.default ?? PythonLanguage
+    },
+    {
+        name: 'java',
+        parserVersion: 'tree-sitter-java@0.21.0',
+        extensions: ['.java'],
+        language: JavaLanguage.default ?? JavaLanguage
     }
 ];
 const byExtension = new Map();
@@ -30,6 +44,7 @@ for (const config of LANGUAGE_CONFIGS) {
     }
 }
 const parserCache = new Map();
+const MIN_PARSE_BUFFER_SIZE = 32 * 1024;
 export function supportedExtensions() {
     return [...byExtension.keys()];
 }
@@ -51,7 +66,11 @@ export function parseSource(filePath, source) {
     }
     let tree;
     try {
-        tree = parser.parse(source);
+        // tree-sitter's native string input path rejects sources larger than its
+        // default 32 KiB input buffer. Give it enough room for this source while
+        // retaining the default-sized buffer for smaller files.
+        const bufferSize = Math.max(MIN_PARSE_BUFFER_SIZE, Buffer.byteLength(source, 'utf8') + 1);
+        tree = parser.parse(source, undefined, { bufferSize });
     }
     catch {
         return null;

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

@@ -0,0 +1,35 @@
+export type ManifestKind = 'maven-pom' | 'gradle-groovy' | 'gradle-kotlin';
+export type ManifestStatus = 'observed' | 'read_failed' | 'traversal_incomplete' | 'confirmed_deleted';
+/** The in-memory representation passed to repository analyzers. */
+export interface RepositoryManifest {
+    path: string;
+    kind: ManifestKind;
+    moduleIdentity: string;
+    size: number;
+    mtimeMs: number;
+    sourceHash: string | null;
+    content: string | null;
+    status: ManifestStatus;
+    /** Set when this record came from the durable inventory. */
+    generation?: number;
+}
+export interface ManifestInventoryResult {
+    manifests: RepositoryManifest[];
+    /** False means the absence of a prior path must not be interpreted as deletion. */
+    complete: boolean;
+}
+export declare const MAX_MANIFEST_BYTES: number;
+export declare const MAX_MANIFESTS = 256;
+export declare const MAX_MANIFEST_CONTENT_BYTES: number;
+/**
+ * Return the bounded Maven/Gradle inventory used by repository analyzers.
+ * Only the repository root and its immediate child modules are considered;
+ * symlinks and deeper build trees are deliberately ignored.
+ */
+export declare function inventoryRepositoryManifests(root: string, previous?: readonly RepositoryManifest[]): RepositoryManifest[];
+/** Perform one bounded filesystem traversal, without interpreting missing paths as deletions. */
+export declare function inspectRepositoryManifests(root: string): ManifestInventoryResult;
+/** Merge a current traversal with durable records, retaining uncertain paths. */
+export declare function mergeManifestInventories(current: readonly RepositoryManifest[], previous: readonly RepositoryManifest[], complete: boolean): RepositoryManifest[];
+export declare function kindForPath(relativePath: string): ManifestKind | undefined;
+//# sourceMappingURL=artifactInventory.d.ts.map

package/dist/src/scanner/artifactInventory.js

@@ -0,0 +1,139 @@
+import { createHash } from 'node:crypto';
+import { lstatSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+export const MAX_MANIFEST_BYTES = 1 * 1024 * 1024;
+export const MAX_MANIFESTS = 256;
+export const MAX_MANIFEST_CONTENT_BYTES = 16 * 1024 * 1024;
+const IGNORED_MODULE_DIRECTORIES = new Set(['.git', '.sling', 'node_modules', 'dist', 'coverage', '.next', '.turbo', '.cache']);
+/**
+ * Return the bounded Maven/Gradle inventory used by repository analyzers.
+ * Only the repository root and its immediate child modules are considered;
+ * symlinks and deeper build trees are deliberately ignored.
+ */
+export function inventoryRepositoryManifests(root, previous = []) {
+    const result = inspectRepositoryManifests(root);
+    return mergeManifestInventories(result.manifests, previous, result.complete);
+}
+/** Perform one bounded filesystem traversal, without interpreting missing paths as deletions. */
+export function inspectRepositoryManifests(root) {
+    const candidates = new Set();
+    const addDirectory = (directory, relativeDirectory) => {
+        for (const name of ['pom.xml', 'build.gradle', 'build.gradle.kts']) {
+            const relative = relativeDirectory ? path.posix.join(relativeDirectory, name) : name;
+            candidates.add(relative);
+        }
+    };
+    addDirectory(root, '');
+    let children;
+    try {
+        children = readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return { manifests: [], complete: false };
+    }
+    for (const entry of children) {
+        if (!entry.isDirectory() || entry.isSymbolicLink() || IGNORED_MODULE_DIRECTORIES.has(entry.name))
+            continue;
+        addDirectory(path.join(root, entry.name), entry.name);
+    }
+    const sortedCandidates = [...candidates].sort();
+    let complete = true;
+    const manifests = [];
+    const existingCandidates = [];
+    for (const relativePath of sortedCandidates) {
+        const absolute = path.join(root, relativePath);
+        const kind = kindForPath(relativePath);
+        if (!kind)
+            continue;
+        try {
+            // lstat is intentional: a symlink is never a supported artifact, even if
+            // its target happens to be a regular manifest.
+            const stat = lstatSync(absolute);
+            if (!stat.isSymbolicLink() && stat.isFile())
+                existingCandidates.push({ relativePath, kind, stat });
+        }
+        catch (error) {
+            // A path that is simply absent is not an artifact candidate. Other
+            // failures (permissions/races) are retained as uncertain reads.
+            if (error.code === 'ENOENT')
+                continue;
+            complete = false;
+            manifests.push(unavailableManifest(relativePath, kind, 'read_failed'));
+        }
+    }
+    if (existingCandidates.length > MAX_MANIFESTS)
+        complete = false;
+    let aggregate = 0;
+    for (const { relativePath, kind, stat } of existingCandidates.slice(0, MAX_MANIFESTS)) {
+        const absolute = path.join(root, relativePath);
+        const size = stat.size;
+        const mtimeMs = Math.round(stat.mtimeMs);
+        if (size > MAX_MANIFEST_BYTES || aggregate + size > MAX_MANIFEST_CONTENT_BYTES) {
+            manifests.push({ path: relativePath, kind, moduleIdentity: moduleIdentityFor(relativePath), size, mtimeMs, sourceHash: null, content: null, status: 'traversal_incomplete' });
+            continue;
+        }
+        try {
+            const content = readFileSync(absolute, 'utf8');
+            const bytes = Buffer.byteLength(content, 'utf8');
+            let afterRead;
+            try {
+                afterRead = statSync(absolute);
+            }
+            catch {
+                manifests.push(unavailableManifest(relativePath, kind, 'read_failed', size, mtimeMs));
+                continue;
+            }
+            if (bytes > MAX_MANIFEST_BYTES || aggregate + bytes > MAX_MANIFEST_CONTENT_BYTES || afterRead.size !== size || Math.round(afterRead.mtimeMs) !== mtimeMs) {
+                manifests.push({ path: relativePath, kind, moduleIdentity: moduleIdentityFor(relativePath), size: afterRead.size, mtimeMs: Math.round(afterRead.mtimeMs), sourceHash: null, content: null, status: 'traversal_incomplete' });
+                continue;
+            }
+            aggregate += bytes;
+            manifests.push({ path: relativePath, kind, moduleIdentity: moduleIdentityFor(relativePath), size, mtimeMs, sourceHash: sha256(content), content, status: 'observed' });
+        }
+        catch {
+            manifests.push(unavailableManifest(relativePath, kind, 'read_failed', size, mtimeMs));
+        }
+    }
+    return { manifests: manifests.sort((a, b) => a.path.localeCompare(b.path)), complete: complete && !manifests.some((manifest) => manifest.status === 'traversal_incomplete' || manifest.status === 'read_failed') };
+}
+/** Merge a current traversal with durable records, retaining uncertain paths. */
+export function mergeManifestInventories(current, previous, complete) {
+    const merged = new Map(previous.map((manifest) => [manifest.path, { ...manifest, content: null }]));
+    for (const manifest of current)
+        merged.set(manifest.path, manifest);
+    if (complete) {
+        for (const [manifestPath, previousManifest] of merged) {
+            if (current.some((manifest) => manifest.path === manifestPath))
+                continue;
+            merged.set(manifestPath, { ...previousManifest, content: null, status: 'confirmed_deleted' });
+        }
+    }
+    else {
+        for (const [manifestPath, previousManifest] of merged) {
+            if (current.some((manifest) => manifest.path === manifestPath))
+                continue;
+            merged.set(manifestPath, { ...previousManifest, content: null, status: 'traversal_incomplete' });
+        }
+    }
+    return [...merged.values()].sort((a, b) => a.path.localeCompare(b.path));
+}
+export function kindForPath(relativePath) {
+    if (relativePath === 'pom.xml' || relativePath.endsWith('/pom.xml'))
+        return 'maven-pom';
+    if (relativePath.endsWith('/build.gradle') || relativePath === 'build.gradle')
+        return 'gradle-groovy';
+    if (relativePath.endsWith('/build.gradle.kts') || relativePath === 'build.gradle.kts')
+        return 'gradle-kotlin';
+    return undefined;
+}
+function moduleIdentityFor(relativePath) {
+    const directory = path.posix.dirname(relativePath);
+    return directory === '.' ? 'root' : directory;
+}
+function unavailableManifest(pathValue, kind, status, size = 0, mtimeMs = 0) {
+    return { path: pathValue, kind, moduleIdentity: moduleIdentityFor(pathValue), size, mtimeMs, sourceHash: null, content: null, status };
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+//# sourceMappingURL=artifactInventory.js.map

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/fingerprint.js

@@ -2,9 +2,11 @@ import { createHash } from 'node:crypto';
 import { statSync } from 'node:fs';
 import path from 'node:path';
 import { discoverSourceFiles } from './discover.js';
+import { inventoryRepositoryManifests } from './artifactInventory.js';
 /** Fast metadata fingerprint shared by watch and context freshness checks. */
 export function collectRepositoryFingerprint(root) {
     const files = discoverSourceFiles(root);
+    const manifests = inventoryRepositoryManifests(root);
     const hash = createHash('sha256');
     for (const relativePath of files) {
         const absolutePath = path.join(root, relativePath);
@@ -22,6 +24,9 @@ export function collectRepositoryFingerprint(root) {
             hash.update('\0missing\0');
         }
     }
+    for (const manifest of manifests) {
+        hash.update(`manifest:${manifest.path}\0${manifest.size}\0${manifest.mtimeMs}\0${manifest.sourceHash ?? manifest.status}\0`);
+    }
     return hash.digest('hex');
 }
 //# sourceMappingURL=fingerprint.js.map

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

@@ -0,0 +1,5 @@
+import type { PluginScanResult, ScannerPlugin, RepositoryScanContext } from './plugins.js';
+export declare const JAVA_DEPENDENCY_PLUGIN_NAME = "java-dependency-plugin";
+export declare const JavaDependencyPlugin: ScannerPlugin;
+export declare function scanJavaDependencies(context: RepositoryScanContext): PluginScanResult;
+//# sourceMappingURL=javaDependencyPlugin.d.ts.map