@shrkcrft/inspector 0.1.0-alpha.2

package/dist/languages/command-inference.d.ts

@@ -0,0 +1,27 @@
+import { type ILanguageProfileReport } from './language-detection.js';
+import { LanguageId } from './language-id.js';
+export declare const LANGUAGE_COMMAND_SET_SCHEMA = "sharkcraft.language-command-set/v1";
+export interface ILanguageCommandSet {
+    schema: typeof LANGUAGE_COMMAND_SET_SCHEMA;
+    language: LanguageId;
+    install?: string;
+    restore?: string;
+    typecheck?: string;
+    test?: string;
+    lint?: string;
+    format?: string;
+    build?: string;
+    package?: string;
+    run?: string;
+    notes: readonly string[];
+}
+export interface ILanguageCommandReport {
+    schema: typeof LANGUAGE_COMMAND_SET_SCHEMA;
+    generatedAt: string;
+    projectRoot: string;
+    profiles: readonly ILanguageCommandSet[];
+}
+export declare function buildLanguageCommandReport(projectRoot: string, cached?: ILanguageProfileReport): ILanguageCommandReport;
+export declare function renderLanguageCommandsText(r: ILanguageCommandReport): string;
+export declare function renderLanguageCommandsMarkdown(r: ILanguageCommandReport): string;
+//# sourceMappingURL=command-inference.d.ts.map

package/dist/languages/command-inference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-inference.d.ts","sourceRoot":"","sources":["../../src/languages/command-inference.ts"],"names":[],"mappings":"AAUA,OAAO,EAGL,KAAK,sBAAsB,EAC5B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,eAAO,MAAM,2BAA2B,uCAAuC,CAAC;AAEhF,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,OAAO,2BAA2B,CAAC;IAC3C,QAAQ,EAAE,UAAU,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,OAAO,2BAA2B,CAAC;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAC1C;AAoID,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,MAAM,EACnB,MAAM,CAAC,EAAE,sBAAsB,GAC9B,sBAAsB,CAQxB;AAED,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAoB5E;AAED,wBAAgB,8BAA8B,CAAC,CAAC,EAAE,sBAAsB,GAAG,MAAM,CAoBhF"}

package/dist/languages/command-inference.js

@@ -0,0 +1,214 @@
+/**
+ * Polyglot command inference.
+ *
+ * Given a `ILanguageProfileReport`, produce a deterministic per-language
+ * `ILanguageCommandSet` for install / typecheck / test / lint / format /
+ * build / package / run. The set is *advisory* — `shrk apply` still only runs
+ * commands in `sharkcraft.config.ts verificationCommands[]`.
+ */
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { detectLanguageProfiles, } from "./language-detection.js";
+import { LanguageId } from "./language-id.js";
+export const LANGUAGE_COMMAND_SET_SCHEMA = 'sharkcraft.language-command-set/v1';
+function commandSetFor(root, p) {
+    const notes = [];
+    switch (p.language) {
+        case LanguageId.TypeScript:
+        case LanguageId.JavaScript: {
+            const pm = p.packageManager ?? 'npm';
+            const out = {
+                schema: LANGUAGE_COMMAND_SET_SCHEMA,
+                language: p.language,
+                install: `${pm} install`,
+                test: pm === 'bun' ? 'bun test' : `${pm} test`,
+                typecheck: 'bun x tsc --noEmit',
+                notes,
+            };
+            if (existsSync(nodePath.join(root, '.eslintrc')) || existsSync(nodePath.join(root, '.eslintrc.json')) || existsSync(nodePath.join(root, '.eslintrc.cjs'))) {
+                out.lint = `${pm === 'bun' ? 'bun x' : 'npx'} eslint .`;
+            }
+            if (existsSync(nodePath.join(root, '.prettierrc')) || existsSync(nodePath.join(root, '.prettierrc.json'))) {
+                out.format = `${pm === 'bun' ? 'bun x' : 'npx'} prettier --check .`;
+            }
+            return out;
+        }
+        case LanguageId.Java: {
+            if (p.buildTool === 'maven') {
+                return {
+                    schema: LANGUAGE_COMMAND_SET_SCHEMA,
+                    language: p.language,
+                    install: 'mvn install -DskipTests',
+                    test: 'mvn test',
+                    typecheck: 'mvn compile',
+                    build: 'mvn package',
+                    package: 'mvn package',
+                    run: p.frameworkSignals.includes('spring-boot') ? 'mvn spring-boot:run' : 'mvn exec:java',
+                    notes,
+                };
+            }
+            // Gradle path
+            const wrapperPresent = existsSync(nodePath.join(root, 'gradlew'));
+            const gradleCmd = wrapperPresent ? './gradlew' : 'gradle';
+            if (!wrapperPresent)
+                notes.push('No gradle wrapper detected — falling back to system `gradle`.');
+            return {
+                schema: LANGUAGE_COMMAND_SET_SCHEMA,
+                language: p.language,
+                install: `${gradleCmd} dependencies --refresh-dependencies`,
+                test: `${gradleCmd} test`,
+                typecheck: `${gradleCmd} check`,
+                build: `${gradleCmd} build`,
+                package: `${gradleCmd} build`,
+                run: p.frameworkSignals.includes('spring-boot') ? `${gradleCmd} bootRun` : `${gradleCmd} run`,
+                notes,
+            };
+        }
+        case LanguageId.CSharp:
+            return {
+                schema: LANGUAGE_COMMAND_SET_SCHEMA,
+                language: p.language,
+                restore: 'dotnet restore',
+                test: 'dotnet test',
+                typecheck: 'dotnet build --no-restore',
+                build: 'dotnet build',
+                format: 'dotnet format --verify-no-changes',
+                run: 'dotnet run',
+                notes,
+            };
+        case LanguageId.Python: {
+            const pm = p.packageManager;
+            if (pm === 'uv') {
+                return {
+                    schema: LANGUAGE_COMMAND_SET_SCHEMA,
+                    language: p.language,
+                    install: 'uv sync',
+                    test: 'uv run pytest',
+                    typecheck: p.frameworkSignals.includes('mypy') ? 'uv run mypy .' : undefined,
+                    lint: p.frameworkSignals.includes('ruff') ? 'uv run ruff check .' : undefined,
+                    format: p.frameworkSignals.includes('ruff') ? 'uv run ruff format --check .' : undefined,
+                    notes,
+                };
+            }
+            if (pm === 'poetry') {
+                return {
+                    schema: LANGUAGE_COMMAND_SET_SCHEMA,
+                    language: p.language,
+                    install: 'poetry install',
+                    test: 'poetry run pytest',
+                    typecheck: p.frameworkSignals.includes('mypy') ? 'poetry run mypy .' : undefined,
+                    lint: p.frameworkSignals.includes('ruff') ? 'poetry run ruff check .' : undefined,
+                    notes,
+                };
+            }
+            return {
+                schema: LANGUAGE_COMMAND_SET_SCHEMA,
+                language: p.language,
+                install: 'python -m pip install -r requirements.txt',
+                test: 'python -m pytest',
+                typecheck: p.frameworkSignals.includes('mypy') ? 'mypy .' : undefined,
+                lint: p.frameworkSignals.includes('ruff') ? 'ruff check .' : undefined,
+                build: existsSync(nodePath.join(root, 'pyproject.toml')) ? 'python -m build' : undefined,
+                notes,
+            };
+        }
+        case LanguageId.Go:
+            return {
+                schema: LANGUAGE_COMMAND_SET_SCHEMA,
+                language: p.language,
+                install: 'go mod download',
+                test: 'go test ./...',
+                typecheck: 'go vet ./...',
+                build: 'go build ./...',
+                format: 'gofmt -l .',
+                run: 'go run ./...',
+                notes,
+            };
+        case LanguageId.Rust:
+            return {
+                schema: LANGUAGE_COMMAND_SET_SCHEMA,
+                language: p.language,
+                install: 'cargo fetch',
+                test: 'cargo test',
+                typecheck: 'cargo check',
+                lint: 'cargo clippy -- -D warnings',
+                format: 'cargo fmt --check',
+                build: 'cargo build',
+                run: 'cargo run',
+                notes,
+            };
+        default:
+            return { schema: LANGUAGE_COMMAND_SET_SCHEMA, language: p.language, notes };
+    }
+}
+export function buildLanguageCommandReport(projectRoot, cached) {
+    const profiles = cached ?? detectLanguageProfiles(projectRoot);
+    return {
+        schema: LANGUAGE_COMMAND_SET_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        projectRoot,
+        profiles: profiles.profiles.map((p) => commandSetFor(projectRoot, p)),
+    };
+}
+export function renderLanguageCommandsText(r) {
+    let out = `=== Language commands ===\n`;
+    out += `  project root  ${r.projectRoot}\n\n`;
+    for (const c of r.profiles) {
+        out += `[${c.language}]\n`;
+        if (c.install)
+            out += `  install  : ${c.install}\n`;
+        if (c.restore)
+            out += `  restore  : ${c.restore}\n`;
+        if (c.typecheck)
+            out += `  typecheck: ${c.typecheck}\n`;
+        if (c.test)
+            out += `  test     : ${c.test}\n`;
+        if (c.lint)
+            out += `  lint     : ${c.lint}\n`;
+        if (c.format)
+            out += `  format   : ${c.format}\n`;
+        if (c.build)
+            out += `  build    : ${c.build}\n`;
+        if (c.package)
+            out += `  package  : ${c.package}\n`;
+        if (c.run)
+            out += `  run      : ${c.run}\n`;
+        if (c.notes.length) {
+            for (const n of c.notes)
+                out += `  note     : ${n}\n`;
+        }
+        out += `\n`;
+    }
+    return out;
+}
+export function renderLanguageCommandsMarkdown(r) {
+    let out = `# Language commands\n\n`;
+    out += `- **project root**: ${r.projectRoot}\n\n`;
+    for (const c of r.profiles) {
+        out += `## ${c.language}\n`;
+        if (c.install)
+            out += `- **install**: \`${c.install}\`\n`;
+        if (c.restore)
+            out += `- **restore**: \`${c.restore}\`\n`;
+        if (c.typecheck)
+            out += `- **typecheck**: \`${c.typecheck}\`\n`;
+        if (c.test)
+            out += `- **test**: \`${c.test}\`\n`;
+        if (c.lint)
+            out += `- **lint**: \`${c.lint}\`\n`;
+        if (c.format)
+            out += `- **format**: \`${c.format}\`\n`;
+        if (c.build)
+            out += `- **build**: \`${c.build}\`\n`;
+        if (c.package)
+            out += `- **package**: \`${c.package}\`\n`;
+        if (c.run)
+            out += `- **run**: \`${c.run}\`\n`;
+        if (c.notes.length) {
+            for (const n of c.notes)
+                out += `- _note_: ${n}\n`;
+        }
+        out += `\n`;
+    }
+    return out;
+}

package/dist/languages/dependency-scan.d.ts

@@ -0,0 +1,33 @@
+import { LanguageId } from './language-id.js';
+export declare const POLYGLOT_DEPENDENCY_GRAPH_SCHEMA = "sharkcraft.polyglot-dependency-graph/v1";
+export interface IPolyglotImportEdge {
+    from: string;
+    to: string;
+    language: LanguageId;
+    external?: boolean;
+}
+export interface IPolyglotLanguageDeps {
+    language: LanguageId;
+    filesScanned: number;
+    imports: readonly IPolyglotImportEdge[];
+    internalEdges: readonly IPolyglotImportEdge[];
+    externalDeps: readonly string[];
+    unresolvedDeps: readonly string[];
+    confidence: 'low' | 'medium' | 'high';
+    limitations: readonly string[];
+}
+export interface IPolyglotDependencyGraph {
+    schema: typeof POLYGLOT_DEPENDENCY_GRAPH_SCHEMA;
+    generatedAt: string;
+    projectRoot: string;
+    perLanguage: readonly IPolyglotLanguageDeps[];
+    notes: readonly string[];
+}
+declare const LANG_EXTENSIONS: Record<string, readonly string[]>;
+export declare function scanPolyglotDependencies(projectRoot: string, options?: {
+    languages?: readonly LanguageId[];
+}): IPolyglotDependencyGraph;
+export declare function renderPolyglotDependenciesText(g: IPolyglotDependencyGraph): string;
+export declare function _exportLangExtensionsForTests(): typeof LANG_EXTENSIONS;
+export {};
+//# sourceMappingURL=dependency-scan.d.ts.map

package/dist/languages/dependency-scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-scan.d.ts","sourceRoot":"","sources":["../../src/languages/dependency-scan.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,eAAO,MAAM,gCAAgC,4CAA4C,CAAC;AAE1F,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,UAAU,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,UAAU,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACxC,aAAa,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC9C,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,UAAU,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACtC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,OAAO,gCAAgC,CAAC;IAChD,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC9C,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AAyND,QAAA,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAMtD,CAAC;AAkCF,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,SAAS,UAAU,EAAE,CAAA;CAAO,GAClD,wBAAwB,CAqC1B;AAED,wBAAgB,8BAA8B,CAAC,CAAC,EAAE,wBAAwB,GAAG,MAAM,CAWlF;AAED,wBAAgB,6BAA6B,IAAI,OAAO,eAAe,CAEtE"}

package/dist/languages/dependency-scan.js

@@ -0,0 +1,343 @@
+/**
+ * Polyglot dependency scan.
+ *
+ * Parses common import / use / using / package directives across Java, C#,
+ * Python, Go, Rust. The output is approximate (no compiler integration); each
+ * profile carries its own confidence + a `limitations` block. Pure regex
+ * scanning, no AST library.
+ */
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { LanguageId } from "./language-id.js";
+import { detectLanguageProfiles } from "./language-detection.js";
+export const POLYGLOT_DEPENDENCY_GRAPH_SCHEMA = 'sharkcraft.polyglot-dependency-graph/v1';
+function tryRead(file) {
+    try {
+        return readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function rel(root, abs) {
+    return nodePath.relative(root, abs).replace(/\\/g, '/');
+}
+function scanJava(root, files) {
+    const imports = [];
+    const externals = new Set();
+    const internalPackages = new Set();
+    let filesScanned = 0;
+    // First pass: catalogue `package com.foo;` declarations so we can classify
+    // `import com.foo.Bar;` as internal vs external.
+    for (const file of files) {
+        const body = tryRead(file);
+        if (!body)
+            continue;
+        const pkg = /^\s*package\s+([a-zA-Z0-9_.]+)\s*;/m.exec(body);
+        if (pkg)
+            internalPackages.add(pkg[1]);
+    }
+    for (const file of files) {
+        const body = tryRead(file);
+        if (!body)
+            continue;
+        filesScanned++;
+        const r = rel(root, file);
+        const importRe = /^\s*import\s+(?:static\s+)?([a-zA-Z0-9_.*]+)\s*;/gm;
+        for (const m of body.matchAll(importRe)) {
+            const target = m[1].replace(/\.\*$/, '');
+            const isInternal = [...internalPackages].some((p) => target === p || target.startsWith(p + '.'));
+            imports.push({ from: r, to: target, language: LanguageId.Java, external: !isInternal });
+            if (!isInternal)
+                externals.add(target);
+        }
+    }
+    return {
+        language: LanguageId.Java,
+        filesScanned,
+        imports,
+        internalEdges: imports.filter((e) => !e.external),
+        externalDeps: [...externals].sort(),
+        unresolvedDeps: [],
+        confidence: filesScanned > 0 ? 'medium' : 'low',
+        limitations: ['Java imports parsed by regex; star imports collapsed.'],
+    };
+}
+function scanCSharp(root, files) {
+    const imports = [];
+    const externals = new Set();
+    const internalNamespaces = new Set();
+    let filesScanned = 0;
+    for (const file of files) {
+        const body = tryRead(file);
+        if (!body)
+            continue;
+        // Both file-scoped `namespace X.Y;` and block `namespace X.Y { … }`.
+        for (const m of body.matchAll(/^\s*namespace\s+([A-Za-z0-9_.]+)\s*[;{]/gm)) {
+            internalNamespaces.add(m[1]);
+        }
+    }
+    for (const file of files) {
+        const body = tryRead(file);
+        if (!body)
+            continue;
+        filesScanned++;
+        const r = rel(root, file);
+        for (const m of body.matchAll(/^\s*using\s+(?:static\s+)?([A-Za-z0-9_.]+)\s*;/gm)) {
+            const target = m[1];
+            const isInternal = [...internalNamespaces].some((ns) => target === ns || target.startsWith(ns + '.'));
+            imports.push({ from: r, to: target, language: LanguageId.CSharp, external: !isInternal });
+            if (!isInternal)
+                externals.add(target);
+        }
+    }
+    return {
+        language: LanguageId.CSharp,
+        filesScanned,
+        imports,
+        internalEdges: imports.filter((e) => !e.external),
+        externalDeps: [...externals].sort(),
+        unresolvedDeps: [],
+        confidence: filesScanned > 0 ? 'medium' : 'low',
+        limitations: ['C# usings parsed by regex; alias usings (`using X = Y;`) not categorised.'],
+    };
+}
+function scanPython(root, files) {
+    const imports = [];
+    const externals = new Set();
+    const unresolved = new Set();
+    let filesScanned = 0;
+    // Internal modules are derived from the files themselves: every directory
+    // chain rooted at a known src/ or top-level is considered local.
+    const localModules = new Set();
+    for (const f of files) {
+        const r = rel(root, f);
+        const parts = r.split('/');
+        if (parts.length > 0)
+            localModules.add(parts[0]);
+        if (r.startsWith('src/') && parts.length > 1)
+            localModules.add(parts[1]);
+    }
+    for (const file of files) {
+        const body = tryRead(file);
+        if (!body)
+            continue;
+        filesScanned++;
+        const r = rel(root, file);
+        for (const m of body.matchAll(/^\s*(?:import\s+([A-Za-z_][A-Za-z0-9_.]*)(?:\s+as\s+\w+)?|from\s+(\.?\.?[A-Za-z_][A-Za-z0-9_.]*)\s+import\s+[^\n]+)/gm)) {
+            const target = (m[1] ?? m[2] ?? '').trim();
+            if (!target)
+                continue;
+            const top = target.replace(/^\.+/, '').split('.')[0];
+            const isInternal = target.startsWith('.') || localModules.has(top);
+            imports.push({ from: r, to: target, language: LanguageId.Python, external: !isInternal });
+            if (!isInternal)
+                externals.add(top);
+            else if (target.startsWith('.') && !target.match(/^\.+[A-Za-z_]/))
+                unresolved.add(target);
+        }
+    }
+    return {
+        language: LanguageId.Python,
+        filesScanned,
+        imports,
+        internalEdges: imports.filter((e) => !e.external),
+        externalDeps: [...externals].sort(),
+        unresolvedDeps: [...unresolved].sort(),
+        confidence: filesScanned > 0 ? 'medium' : 'low',
+        limitations: ['Python imports parsed by regex; conditional / runtime imports may be missed.'],
+    };
+}
+function scanGo(root, files) {
+    const imports = [];
+    const externals = new Set();
+    let filesScanned = 0;
+    // Detect the module name from go.mod for internal classification.
+    let modulePrefix = '';
+    const goMod = tryRead(nodePath.join(root, 'go.mod'));
+    if (goMod) {
+        const m = /^module\s+([^\s]+)/m.exec(goMod);
+        if (m)
+            modulePrefix = m[1];
+    }
+    for (const file of files) {
+        const body = tryRead(file);
+        if (!body)
+            continue;
+        filesScanned++;
+        const r = rel(root, file);
+        // Single-line `import "x"`
+        for (const m of body.matchAll(/^\s*import\s+"([^"]+)"/gm)) {
+            const target = m[1];
+            const isInternal = modulePrefix.length > 0 && (target === modulePrefix || target.startsWith(modulePrefix + '/'));
+            imports.push({ from: r, to: target, language: LanguageId.Go, external: !isInternal });
+            if (!isInternal)
+                externals.add(target);
+        }
+        // Block import (foo "x" or alias)
+        const blockMatch = body.match(/import\s*\(([\s\S]*?)\)/m);
+        if (blockMatch) {
+            for (const line of blockMatch[1].split('\n')) {
+                const lm = /\s*(?:[A-Za-z_]\w*\s+)?"([^"]+)"/.exec(line);
+                if (!lm)
+                    continue;
+                const target = lm[1];
+                const isInternal = modulePrefix.length > 0 && (target === modulePrefix || target.startsWith(modulePrefix + '/'));
+                imports.push({ from: r, to: target, language: LanguageId.Go, external: !isInternal });
+                if (!isInternal)
+                    externals.add(target);
+            }
+        }
+    }
+    return {
+        language: LanguageId.Go,
+        filesScanned,
+        imports,
+        internalEdges: imports.filter((e) => !e.external),
+        externalDeps: [...externals].sort(),
+        unresolvedDeps: [],
+        confidence: filesScanned > 0 ? 'high' : 'low',
+        limitations: modulePrefix ? [] : ['No `module` directive in go.mod — internal classification may be incorrect.'],
+    };
+}
+function scanRust(root, files) {
+    const imports = [];
+    const externals = new Set();
+    let filesScanned = 0;
+    // First crate name from Cargo.toml.
+    const cargo = tryRead(nodePath.join(root, 'Cargo.toml'));
+    let crateName = '';
+    if (cargo) {
+        const m = /name\s*=\s*"([^"]+)"/.exec(cargo);
+        if (m)
+            crateName = m[1].replace(/-/g, '_');
+    }
+    for (const file of files) {
+        const body = tryRead(file);
+        if (!body)
+            continue;
+        filesScanned++;
+        const r = rel(root, file);
+        for (const m of body.matchAll(/^\s*use\s+([A-Za-z_][A-Za-z0-9_:]*)/gm)) {
+            const target = m[1];
+            const head = target.split('::')[0];
+            const isInternal = head === 'crate' || head === 'super' || head === 'self' || head === crateName;
+            imports.push({ from: r, to: target, language: LanguageId.Rust, external: !isInternal });
+            if (!isInternal)
+                externals.add(head);
+        }
+        for (const m of body.matchAll(/^\s*mod\s+([A-Za-z_][A-Za-z0-9_]*)\s*;/gm)) {
+            imports.push({ from: r, to: 'mod::' + m[1], language: LanguageId.Rust, external: false });
+        }
+    }
+    return {
+        language: LanguageId.Rust,
+        filesScanned,
+        imports,
+        internalEdges: imports.filter((e) => !e.external),
+        externalDeps: [...externals].sort(),
+        unresolvedDeps: [],
+        confidence: filesScanned > 0 ? 'medium' : 'low',
+        limitations: ['Rust `use` parsed by regex; grouped `use foo::{a, b};` only records `foo` head.'],
+    };
+}
+const LANG_EXTENSIONS = {
+    [LanguageId.Java]: ['.java'],
+    [LanguageId.CSharp]: ['.cs'],
+    [LanguageId.Python]: ['.py'],
+    [LanguageId.Go]: ['.go'],
+    [LanguageId.Rust]: ['.rs'],
+};
+function collectFilesByExtension(root, exts) {
+    // Walk the tree limited by the same ignored-dir rules.
+    const out = [];
+    const ignored = new Set(['node_modules', '.git', 'target', 'build', 'bin', 'obj', 'dist', 'out', '__pycache__', '.venv', 'venv', 'vendor']);
+    const stack = [root];
+    while (stack.length > 0 && out.length < 25000) {
+        const cur = stack.pop();
+        let entries;
+        try {
+            entries = readdirSync(cur);
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (ignored.has(e))
+                continue;
+            const abs = nodePath.join(cur, e);
+            let st;
+            try {
+                st = statSync(abs);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                stack.push(abs);
+                continue;
+            }
+            if (st.isFile() && exts.some((x) => abs.endsWith(x)))
+                out.push(abs);
+        }
+    }
+    return out;
+}
+export function scanPolyglotDependencies(projectRoot, options = {}) {
+    const cached = detectLanguageProfiles(projectRoot);
+    const wanted = options.languages && options.languages.length > 0
+        ? new Set(options.languages)
+        : new Set([LanguageId.Java, LanguageId.CSharp, LanguageId.Python, LanguageId.Go, LanguageId.Rust]);
+    const perLanguage = [];
+    void cached;
+    if (wanted.has(LanguageId.Java)) {
+        const files = collectFilesByExtension(projectRoot, LANG_EXTENSIONS[LanguageId.Java]);
+        if (files.length > 0)
+            perLanguage.push(scanJava(projectRoot, files));
+    }
+    if (wanted.has(LanguageId.CSharp)) {
+        const files = collectFilesByExtension(projectRoot, LANG_EXTENSIONS[LanguageId.CSharp]);
+        if (files.length > 0)
+            perLanguage.push(scanCSharp(projectRoot, files));
+    }
+    if (wanted.has(LanguageId.Python)) {
+        const files = collectFilesByExtension(projectRoot, LANG_EXTENSIONS[LanguageId.Python]);
+        if (files.length > 0)
+            perLanguage.push(scanPython(projectRoot, files));
+    }
+    if (wanted.has(LanguageId.Go)) {
+        const files = collectFilesByExtension(projectRoot, LANG_EXTENSIONS[LanguageId.Go]);
+        if (files.length > 0)
+            perLanguage.push(scanGo(projectRoot, files));
+    }
+    if (wanted.has(LanguageId.Rust)) {
+        const files = collectFilesByExtension(projectRoot, LANG_EXTENSIONS[LanguageId.Rust]);
+        if (files.length > 0)
+            perLanguage.push(scanRust(projectRoot, files));
+    }
+    return {
+        schema: POLYGLOT_DEPENDENCY_GRAPH_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        projectRoot,
+        perLanguage,
+        notes: ['Regex-based scan — no compiler / AST integration.'],
+    };
+}
+export function renderPolyglotDependenciesText(g) {
+    let out = `=== Polyglot dependencies ===\n`;
+    out += `  project root  ${g.projectRoot}\n`;
+    out += `  languages     ${g.perLanguage.map((p) => p.language).join(', ') || '(none)'}\n\n`;
+    for (const p of g.perLanguage) {
+        out += `[${p.language}]  files=${p.filesScanned}  imports=${p.imports.length}  internal=${p.internalEdges.length}  external=${p.externalDeps.length}  confidence=${p.confidence}\n`;
+        if (p.externalDeps.length)
+            out += `  external deps: ${p.externalDeps.slice(0, 12).join(', ')}${p.externalDeps.length > 12 ? ', …' : ''}\n`;
+        if (p.limitations.length)
+            for (const l of p.limitations)
+                out += `  note: ${l}\n`;
+        out += `\n`;
+    }
+    return out;
+}
+export function _exportLangExtensionsForTests() {
+    return LANG_EXTENSIONS;
+}

package/dist/languages/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Polyglot language module barrel.
+ */
+export * from './language-id.js';
+export * from './language-detection.js';
+export * from './command-inference.js';
+export * from './dependency-scan.js';
+export * from './test-impact.js';
+export * from './language-boundaries.js';
+export * from './polyglot-boundary.js';
+export * from './polyglot-ci.js';
+export * from './language-cache.js';
+export * from './language-runner.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/languages/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/languages/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC"}

package/dist/languages/index.js

@@ -0,0 +1,13 @@
+/**
+ * Polyglot language module barrel.
+ */
+export * from "./language-id.js";
+export * from "./language-detection.js";
+export * from "./command-inference.js";
+export * from "./dependency-scan.js";
+export * from "./test-impact.js";
+export * from "./language-boundaries.js";
+export * from "./polyglot-boundary.js";
+export * from "./polyglot-ci.js";
+export * from "./language-cache.js";
+export * from "./language-runner.js";