@shrkcrft/inspector 0.1.0-alpha.2

package/dist/languages/polyglot-boundary.js

@@ -0,0 +1,373 @@
+/**
+ * Polyglot boundary enforcement.
+ *
+ * Evaluates built-in per-language boundary rules against the polyglot
+ * dependency scan and reports violations + suggested fixes. Pure
+ * file/regex-driven, no compiler integration.
+ *
+ * The existing TypeScript boundary engine is unchanged. This report is a
+ * cross-cutting view used by `shrk boundaries enforce --language ...`,
+ * `shrk check boundaries --polyglot`, and `get_polyglot_boundary_report`.
+ */
+import { LanguageId } from "./language-id.js";
+import { detectLanguageProfiles } from "./language-detection.js";
+import { scanPolyglotDependencies } from "./dependency-scan.js";
+export const POLYGLOT_BOUNDARY_REPORT_SCHEMA = 'sharkcraft.polyglot-boundary-report/v1';
+const JAVA_RULES = [
+    {
+        id: 'java.domain.no-spring-web',
+        title: 'Domain must not depend on Spring Web',
+        language: LanguageId.Java,
+        severity: 'error',
+        fromPattern: /(^|\/)domain\//i,
+        forbiddenTargetPattern: /^org\.springframework\.web\./,
+        reason: 'Domain stays framework-agnostic; routing concerns belong in the web/controller layer.',
+        suggestedFix: 'Move web-binding to a controller and expose a service interface in domain.',
+    },
+    {
+        id: 'java.controller.no-repository-direct',
+        title: 'Controllers should not import repositories directly',
+        language: LanguageId.Java,
+        severity: 'warning',
+        fromPattern: /(^|\/)controller\//i,
+        forbiddenTargetPattern: /\.(repository|dao)\./i,
+        reason: 'Controllers should call services; persistence is an internal concern.',
+        suggestedFix: 'Inject a service that wraps the repository instead.',
+    },
+    {
+        id: 'java.main.no-test-import',
+        title: 'Production code must not import the test tree',
+        language: LanguageId.Java,
+        severity: 'error',
+        fromPattern: /(^|\/)src\/main\/java\//,
+        forbiddenTargetPattern: /(^|\.)(?:test|tests|junit|testng)\./,
+        reason: 'src/main code may not depend on src/test code.',
+        suggestedFix: 'Extract shared fixture into src/main or a dedicated test-fixtures module.',
+    },
+];
+const CSHARP_RULES = [
+    {
+        id: 'csharp.domain.no-aspnet',
+        title: 'Domain must not depend on ASP.NET',
+        language: LanguageId.CSharp,
+        severity: 'error',
+        fromPattern: /(^|\/)Domain\//,
+        forbiddenTargetPattern: /^Microsoft\.AspNetCore\./,
+        reason: 'Clean architecture: outer layers depend inward; Domain stays framework-agnostic.',
+        suggestedFix: 'Keep ASP.NET types in Web/Application; expose interfaces in Domain.',
+    },
+    {
+        id: 'csharp.web.no-infrastructure-direct',
+        title: 'Web project depends on Application, not Infrastructure',
+        language: LanguageId.CSharp,
+        severity: 'warning',
+        fromPattern: /(^|\/)Web\//,
+        forbiddenTargetPattern: /^.*\.Infrastructure\./,
+        reason: 'Application orchestrates Infrastructure; Web should not bind to it directly.',
+        suggestedFix: 'Call an Application service; inject Infrastructure via DI.',
+    },
+    {
+        id: 'csharp.main.no-test-import',
+        title: 'Production code must not import test projects',
+        language: LanguageId.CSharp,
+        severity: 'error',
+        fromPattern: /\.cs$/,
+        toPattern: /\.Tests\.csproj$/,
+        forbiddenTargetPattern: /\.Tests(\.|$)/,
+        reason: 'Production projects must not depend on test projects.',
+        suggestedFix: 'Move shared helpers into a non-test project.',
+    },
+];
+const PYTHON_RULES = [
+    {
+        id: 'python.domain.no-web-framework',
+        title: 'Domain must not import web frameworks',
+        language: LanguageId.Python,
+        severity: 'error',
+        fromPattern: /(^|\/)domain(\/|\.)/i,
+        forbiddenTargetPattern: /^(fastapi|django|flask|starlette)\b/,
+        reason: 'Domain stays framework-agnostic.',
+        suggestedFix: 'Wire web framework usage in the api/app layer; keep domain pure.',
+    },
+    {
+        id: 'python.app.no-tests-import',
+        title: 'Application code must not import the tests tree',
+        language: LanguageId.Python,
+        severity: 'error',
+        fromPattern: /^(?:src|app)\//,
+        forbiddenTargetPattern: /^(tests?|test_[a-z0-9_]+)(\.|$)/,
+        reason: 'Production code must not depend on tests.',
+        suggestedFix: 'Move shared fixtures to src/<package>/_fixtures.py or conftest.py.',
+    },
+    {
+        id: 'python.no-cross-layer-parent-relative',
+        title: 'Avoid relative imports across layers',
+        language: LanguageId.Python,
+        severity: 'warning',
+        fromPattern: /\.py$/,
+        forbiddenTargetPattern: /^\.\.\.+\w+/,
+        reason: 'Deep parent-relative imports (`from ...x`) cross too many layers.',
+        suggestedFix: 'Use an absolute import via the package root.',
+    },
+];
+const GO_RULES = [
+    {
+        id: 'go.pkg.no-cmd-import',
+        title: 'pkg/ must not import cmd/',
+        language: LanguageId.Go,
+        severity: 'error',
+        fromPattern: /^pkg\//,
+        forbiddenTargetPattern: /\/cmd\//,
+        reason: 'cmd/ is the entry point; library code must not depend on it.',
+        suggestedFix: 'Move shared helpers out of cmd/ into pkg/ or internal/.',
+    },
+    {
+        id: 'go.internal.visibility',
+        title: 'internal/ must not be imported from outside its parent',
+        language: LanguageId.Go,
+        severity: 'error',
+        fromPattern: /\.go$/,
+        forbiddenTargetPattern: /\/internal\//,
+        reason: 'Go enforces internal at compile time; surface it earlier in review.',
+        suggestedFix: 'Promote the type to a non-internal package or duplicate the small helper.',
+    },
+    {
+        id: 'go.no-import-cycle-hint',
+        title: 'Watch for cyclic imports between sibling packages',
+        language: LanguageId.Go,
+        severity: 'warning',
+        fromPattern: /\.go$/,
+        forbiddenTargetPattern: /^cycle:.*$/,
+        reason: 'Cyclic imports break compilation; surfaced from the dep-graph cycle list.',
+        suggestedFix: 'Extract the cyclic surface into a third package both sides depend on.',
+    },
+];
+const RUST_RULES = [
+    {
+        id: 'rust.lib.no-tests-import',
+        title: 'Library crate must not depend on tests/',
+        language: LanguageId.Rust,
+        severity: 'error',
+        fromPattern: /^src\//,
+        forbiddenTargetPattern: /^tests::/,
+        reason: 'Production crate code must not depend on the tests/ tree.',
+        suggestedFix: 'Move shared fixtures into src/test_helpers (gated by #[cfg(test)]).',
+    },
+    {
+        id: 'rust.no-test-only-module-import',
+        title: 'Do not import `#[cfg(test)]`-gated modules from non-test code',
+        language: LanguageId.Rust,
+        severity: 'warning',
+        fromPattern: /\.rs$/,
+        forbiddenTargetPattern: /^crate::test(_| ::)/,
+        reason: 'cfg(test) modules disappear in release builds; relying on them breaks the build.',
+        suggestedFix: 'Promote the symbol or wrap with #[cfg(test)] guard at the import site.',
+    },
+    {
+        id: 'rust.no-super-cross-crate-hint',
+        title: 'Avoid `super::super::super::` chains',
+        language: LanguageId.Rust,
+        severity: 'warning',
+        fromPattern: /\.rs$/,
+        forbiddenTargetPattern: /^(?:super::){3,}/,
+        reason: 'Deep super chains indicate accidental crate boundary crossing.',
+        suggestedFix: 'Reorganise the module tree or use `crate::` absolute paths.',
+    },
+];
+const TYPESCRIPT_RULES = [
+// TS rules deliberately live in the existing TS engine — kept empty
+// here so `--language all` doesn't return surprising TS results.
+];
+const ALL_RULES_BY_LANG = {
+    [LanguageId.TypeScript]: TYPESCRIPT_RULES,
+    [LanguageId.JavaScript]: TYPESCRIPT_RULES,
+    [LanguageId.Java]: JAVA_RULES,
+    [LanguageId.CSharp]: CSHARP_RULES,
+    [LanguageId.Python]: PYTHON_RULES,
+    [LanguageId.Go]: GO_RULES,
+    [LanguageId.Rust]: RUST_RULES,
+    [LanguageId.Mixed]: [],
+    [LanguageId.Unknown]: [],
+};
+export function listPolyglotBoundaryRules(language) {
+    if (language)
+        return ALL_RULES_BY_LANG[language] ?? [];
+    return [
+        ...JAVA_RULES,
+        ...CSHARP_RULES,
+        ...PYTHON_RULES,
+        ...GO_RULES,
+        ...RUST_RULES,
+    ];
+}
+function applyRule(rule, edge) {
+    if (edge.language !== rule.language)
+        return null;
+    if (!rule.fromPattern.test(edge.from))
+        return null;
+    if (rule.toPattern && edge.to && !rule.toPattern.test(edge.to))
+        return null;
+    if (!rule.forbiddenTargetPattern.test(edge.to))
+        return null;
+    let confidence = 'medium';
+    if (rule.severity === 'error')
+        confidence = 'high';
+    return {
+        ruleId: rule.id,
+        language: rule.language,
+        severity: rule.severity,
+        fromFile: edge.from,
+        importSpecifier: edge.to,
+        reason: rule.reason,
+        suggestedFix: rule.suggestedFix,
+        confidence,
+    };
+}
+export function buildPolyglotBoundaryReport(options) {
+    const limit = options.limit ?? 200;
+    const profile = options.cached ?? detectLanguageProfiles(options.projectRoot);
+    const detected = new Set(profile.profiles.map((p) => p.language));
+    const wantedLanguages = options.languages && options.languages.length > 0
+        ? options.languages
+        : [LanguageId.Java, LanguageId.CSharp, LanguageId.Python, LanguageId.Go, LanguageId.Rust];
+    const evaluatedLanguages = wantedLanguages.filter((l) => detected.has(l));
+    const rules = [];
+    for (const lang of evaluatedLanguages)
+        rules.push(...(ALL_RULES_BY_LANG[lang] ?? []));
+    // Reuse caller's dep graph or compute one. When evaluatedLanguages is empty
+    // we still produce an empty report rather than failing.
+    let graph;
+    if (options.graph) {
+        graph = options.graph;
+    }
+    else if (evaluatedLanguages.length === 0) {
+        graph = {
+            schema: 'sharkcraft.polyglot-dependency-graph/v1',
+            generatedAt: new Date().toISOString(),
+            projectRoot: options.projectRoot,
+            perLanguage: [],
+            notes: ['No applicable polyglot languages detected.'],
+        };
+    }
+    else {
+        graph = scanPolyglotDependencies(options.projectRoot, { languages: evaluatedLanguages });
+    }
+    const edges = [];
+    for (const langDeps of graph.perLanguage) {
+        if (!evaluatedLanguages.includes(langDeps.language))
+            continue;
+        edges.push(...langDeps.imports);
+    }
+    const violations = [];
+    for (const edge of edges) {
+        for (const rule of rules) {
+            const v = applyRule(rule, edge);
+            if (v) {
+                violations.push(v);
+                if (violations.length >= limit)
+                    break;
+            }
+        }
+        if (violations.length >= limit)
+            break;
+    }
+    const errors = violations.filter((v) => v.severity === 'error').length;
+    const warnings = violations.filter((v) => v.severity === 'warning').length;
+    const limitations = [
+        'Polyglot dep scan is regex-based — false positives/negatives are possible.',
+        'Rules are conservative built-ins; tune via project-local boundary rules when needed.',
+    ];
+    if (violations.length >= limit) {
+        limitations.push(`Result capped at ${limit} violations; rerun with --limit to widen.`);
+    }
+    if (evaluatedLanguages.length === 0) {
+        limitations.push('No applicable polyglot languages detected in the workspace.');
+    }
+    const suggestedFixes = Array.from(new Set(violations.map((v) => v.suggestedFix))).slice(0, 10);
+    return {
+        schema: POLYGLOT_BOUNDARY_REPORT_SCHEMA,
+        generatedAt: new Date().toISOString(),
+        projectRoot: options.projectRoot,
+        languages: evaluatedLanguages,
+        rules,
+        edges,
+        violations,
+        counts: { rules: rules.length, edges: edges.length, violations: violations.length, errors, warnings },
+        limitations,
+        suggestedFixes,
+    };
+}
+export function renderPolyglotBoundaryReportText(r) {
+    let out = `=== Polyglot boundary report ===\n`;
+    out += `  project root  ${r.projectRoot}\n`;
+    out += `  languages     ${r.languages.join(', ') || '(none)'}\n`;
+    out += `  rules         ${r.counts.rules}\n`;
+    out += `  edges         ${r.counts.edges}\n`;
+    out += `  violations    ${r.counts.violations}  (errors=${r.counts.errors}  warnings=${r.counts.warnings})\n`;
+    if (r.violations.length > 0) {
+        out += `\nViolations:\n`;
+        for (const v of r.violations.slice(0, 60)) {
+            out += `  [${v.severity}] ${v.ruleId}\n`;
+            out += `    from   ${v.fromFile}\n`;
+            out += `    import ${v.importSpecifier}\n`;
+            out += `    fix    ${v.suggestedFix}\n`;
+        }
+        if (r.violations.length > 60)
+            out += `  ... ${r.violations.length - 60} more\n`;
+    }
+    if (r.limitations.length > 0) {
+        out += `\nLimitations:\n`;
+        for (const l of r.limitations)
+            out += `  - ${l}\n`;
+    }
+    return out;
+}
+export function renderPolyglotBoundaryReportMarkdown(r) {
+    const lines = [];
+    lines.push('# Polyglot boundary report');
+    lines.push('');
+    lines.push(`- Languages: ${r.languages.map((l) => '`' + l + '`').join(', ') || '_(none)_'}`);
+    lines.push(`- Rules: **${r.counts.rules}**`);
+    lines.push(`- Edges: **${r.counts.edges}**`);
+    lines.push(`- Violations: **${r.counts.violations}** (errors=${r.counts.errors}, warnings=${r.counts.warnings})`);
+    lines.push('');
+    if (r.violations.length > 0) {
+        lines.push('## Violations');
+        lines.push('');
+        lines.push('| Severity | Rule | From | Import | Fix |');
+        lines.push('|---|---|---|---|---|');
+        for (const v of r.violations) {
+            lines.push(`| ${v.severity} | \`${v.ruleId}\` | \`${v.fromFile}\` | \`${v.importSpecifier}\` | ${v.suggestedFix} |`);
+        }
+        lines.push('');
+    }
+    if (r.suggestedFixes.length > 0) {
+        lines.push('## Suggested fixes');
+        lines.push('');
+        for (const f of r.suggestedFixes)
+            lines.push(`- ${f}`);
+        lines.push('');
+    }
+    if (r.limitations.length > 0) {
+        lines.push('## Limitations');
+        lines.push('');
+        for (const l of r.limitations)
+            lines.push(`- ${l}`);
+    }
+    return lines.join('\n');
+}
+export function renderPolyglotBoundaryReportJson(r) {
+    // Strip RegExp objects from rules for safe JSON serialisation.
+    const safe = {
+        ...r,
+        rules: r.rules.map((rule) => ({
+            id: rule.id,
+            title: rule.title,
+            language: rule.language,
+            severity: rule.severity,
+            reason: rule.reason,
+            suggestedFix: rule.suggestedFix,
+        })),
+    };
+    return JSON.stringify(safe, null, 2);
+}

package/dist/languages/polyglot-ci.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Polyglot CI scaffold.
+ *
+ * Emits GitHub Actions job snippets for detected language profiles. Each job
+ * runs install / build / test (and optional lint/format when detected). No
+ * publish/deploy steps. Output is concatenated to the existing CI YAML.
+ */
+import { LanguageId } from './language-id.js';
+import { type ILanguageProfileReport } from './language-detection.js';
+export interface IPolyglotCiOptions {
+    cached?: ILanguageProfileReport;
+}
+export declare function renderPolyglotGitHubActionsJobs(projectRoot: string, options?: IPolyglotCiOptions): string;
+export declare function listPolyglotCiLanguages(projectRoot: string): readonly LanguageId[];
+interface IRenderPolyglotOptions {
+    cached?: ILanguageProfileReport;
+    /** When provided, restricts the emitted languages. */
+    languages?: readonly LanguageId[];
+}
+export declare function renderPolyglotGitlabJobs(projectRoot: string, options?: IRenderPolyglotOptions): string;
+export declare function renderPolyglotBitbucketSteps(projectRoot: string, options?: IRenderPolyglotOptions): string;
+export declare function renderPolyglotAzureStages(projectRoot: string, options?: IRenderPolyglotOptions): string;
+export declare function renderPolyglotJenkinsStages(projectRoot: string, options?: IRenderPolyglotOptions): string;
+export {};
+//# sourceMappingURL=polyglot-ci.d.ts.map

package/dist/languages/polyglot-ci.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyglot-ci.d.ts","sourceRoot":"","sources":["../../src/languages/polyglot-ci.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAA0B,KAAK,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAuF9F,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,sBAAsB,CAAC;CACjC;AAED,wBAAgB,+BAA+B,CAC7C,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,kBAAuB,GAC/B,MAAM,CAgCR;AAED,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,UAAU,EAAE,CAKlF;AASD,UAAU,sBAAsB;IAC9B,MAAM,CAAC,EAAE,sBAAsB,CAAC;IAChC,sDAAsD;IACtD,SAAS,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;CACnC;AAoBD,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,sBAA2B,GACnC,MAAM,CA4BR;AAED,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,sBAA2B,GACnC,MAAM,CAsBR;AAED,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,sBAA2B,GACnC,MAAM,CAsBR;AAED,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,sBAA2B,GACnC,MAAM,CAuBR"}

package/dist/languages/polyglot-ci.js

@@ -0,0 +1,278 @@
+/**
+ * Polyglot CI scaffold.
+ *
+ * Emits GitHub Actions job snippets for detected language profiles. Each job
+ * runs install / build / test (and optional lint/format when detected). No
+ * publish/deploy steps. Output is concatenated to the existing CI YAML.
+ */
+import { LanguageId } from "./language-id.js";
+import { detectLanguageProfiles } from "./language-detection.js";
+import { buildLanguageCommandReport } from "./command-inference.js";
+function jobIdFor(lang) {
+    return `polyglot-${lang}`;
+}
+function githubJobForJava(c) {
+    const isMaven = c.install?.startsWith('mvn') ?? false;
+    const javaVersion = '21';
+    let yaml = `  ${jobIdFor(c.language)}:\n`;
+    yaml += `    runs-on: ubuntu-latest\n`;
+    yaml += `    timeout-minutes: 25\n`;
+    yaml += `    steps:\n`;
+    yaml += `      - uses: actions/checkout@v4\n`;
+    yaml += `      - uses: actions/setup-java@v4\n`;
+    yaml += `        with:\n`;
+    yaml += `          distribution: temurin\n`;
+    yaml += `          java-version: '${javaVersion}'\n`;
+    if (isMaven) {
+        yaml += `          cache: maven\n`;
+        yaml += `      - run: mvn -B verify\n`;
+    }
+    else {
+        yaml += `          cache: gradle\n`;
+        yaml += `      - run: ./gradlew test\n`;
+    }
+    return yaml;
+}
+function githubJobForCSharp(_c) {
+    let yaml = `  polyglot-csharp:\n`;
+    yaml += `    runs-on: ubuntu-latest\n`;
+    yaml += `    timeout-minutes: 25\n`;
+    yaml += `    steps:\n`;
+    yaml += `      - uses: actions/checkout@v4\n`;
+    yaml += `      - uses: actions/setup-dotnet@v4\n`;
+    yaml += `        with:\n`;
+    yaml += `          dotnet-version: '8.x'\n`;
+    yaml += `      - run: dotnet restore\n`;
+    yaml += `      - run: dotnet build --no-restore\n`;
+    yaml += `      - run: dotnet test --no-build\n`;
+    return yaml;
+}
+function githubJobForPython(c) {
+    let yaml = `  polyglot-python:\n`;
+    yaml += `    runs-on: ubuntu-latest\n`;
+    yaml += `    timeout-minutes: 20\n`;
+    yaml += `    steps:\n`;
+    yaml += `      - uses: actions/checkout@v4\n`;
+    yaml += `      - uses: actions/setup-python@v5\n`;
+    yaml += `        with:\n`;
+    yaml += `          python-version: '3.12'\n`;
+    if (c.install)
+        yaml += `      - run: ${c.install}\n`;
+    if (c.lint)
+        yaml += `      - run: ${c.lint}\n`;
+    if (c.typecheck)
+        yaml += `      - run: ${c.typecheck}\n`;
+    if (c.test)
+        yaml += `      - run: ${c.test}\n`;
+    return yaml;
+}
+function githubJobForGo(_c) {
+    let yaml = `  polyglot-go:\n`;
+    yaml += `    runs-on: ubuntu-latest\n`;
+    yaml += `    timeout-minutes: 20\n`;
+    yaml += `    steps:\n`;
+    yaml += `      - uses: actions/checkout@v4\n`;
+    yaml += `      - uses: actions/setup-go@v5\n`;
+    yaml += `        with:\n`;
+    yaml += `          go-version: '1.22'\n`;
+    yaml += `      - run: go vet ./...\n`;
+    yaml += `      - run: go test ./...\n`;
+    return yaml;
+}
+function githubJobForRust(_c) {
+    let yaml = `  polyglot-rust:\n`;
+    yaml += `    runs-on: ubuntu-latest\n`;
+    yaml += `    timeout-minutes: 25\n`;
+    yaml += `    steps:\n`;
+    yaml += `      - uses: actions/checkout@v4\n`;
+    yaml += `      - uses: dtolnay/rust-toolchain@stable\n`;
+    yaml += `      - run: cargo fmt --check\n`;
+    yaml += `      - run: cargo clippy -- -D warnings\n`;
+    yaml += `      - run: cargo test\n`;
+    return yaml;
+}
+export function renderPolyglotGitHubActionsJobs(projectRoot, options = {}) {
+    const cmds = buildLanguageCommandReport(projectRoot, options.cached);
+    let yaml = `\n  # Polyglot jobs\n`;
+    let any = false;
+    for (const c of cmds.profiles) {
+        switch (c.language) {
+            case LanguageId.Java:
+                yaml += githubJobForJava(c);
+                any = true;
+                break;
+            case LanguageId.CSharp:
+                yaml += githubJobForCSharp(c);
+                any = true;
+                break;
+            case LanguageId.Python:
+                yaml += githubJobForPython(c);
+                any = true;
+                break;
+            case LanguageId.Go:
+                yaml += githubJobForGo(c);
+                any = true;
+                break;
+            case LanguageId.Rust:
+                yaml += githubJobForRust(c);
+                any = true;
+                break;
+            default:
+                break;
+        }
+    }
+    if (!any)
+        yaml += `  # (no non-JS/TS languages detected — nothing to add)\n`;
+    return yaml;
+}
+export function listPolyglotCiLanguages(projectRoot) {
+    const r = detectLanguageProfiles(projectRoot);
+    return r.profiles
+        .map((p) => p.language)
+        .filter((l) => l === LanguageId.Java || l === LanguageId.CSharp || l === LanguageId.Python || l === LanguageId.Go || l === LanguageId.Rust);
+}
+function selectCommands(projectRoot, options) {
+    const cmds = buildLanguageCommandReport(projectRoot, options.cached);
+    if (!options.languages || options.languages.length === 0) {
+        return cmds.profiles.filter((c) => c.language === LanguageId.Java
+            || c.language === LanguageId.CSharp
+            || c.language === LanguageId.Python
+            || c.language === LanguageId.Go
+            || c.language === LanguageId.Rust);
+    }
+    const wanted = new Set(options.languages);
+    return cmds.profiles.filter((c) => wanted.has(c.language));
+}
+export function renderPolyglotGitlabJobs(projectRoot, options = {}) {
+    const cmds = selectCommands(projectRoot, options);
+    if (cmds.length === 0)
+        return '# (no non-JS/TS languages detected — no polyglot stages added)\n';
+    let yaml = '\n# Polyglot stages\n';
+    for (const c of cmds) {
+        if (c.language === LanguageId.Java) {
+            const isMaven = (c.install ?? '').startsWith('mvn');
+            yaml += `polyglot:java:\n  stage: sharkcraft_quality\n  image: ${isMaven ? 'maven:3-eclipse-temurin-21' : 'gradle:8-jdk21'}\n  script:\n`;
+            if (isMaven) {
+                yaml += `    - mvn -B verify\n`;
+            }
+            else {
+                yaml += `    - ./gradlew test\n`;
+            }
+        }
+        else if (c.language === LanguageId.CSharp) {
+            yaml += `polyglot:csharp:\n  stage: sharkcraft_quality\n  image: mcr.microsoft.com/dotnet/sdk:8.0\n  script:\n    - dotnet restore\n    - dotnet build --no-restore\n    - dotnet test --no-build\n`;
+        }
+        else if (c.language === LanguageId.Python) {
+            yaml += `polyglot:python:\n  stage: sharkcraft_quality\n  image: python:3.12\n  script:\n`;
+            if (c.install)
+                yaml += `    - ${c.install}\n`;
+            if (c.lint)
+                yaml += `    - ${c.lint}\n`;
+            if (c.typecheck)
+                yaml += `    - ${c.typecheck}\n`;
+            if (c.test)
+                yaml += `    - ${c.test}\n`;
+        }
+        else if (c.language === LanguageId.Go) {
+            yaml += `polyglot:go:\n  stage: sharkcraft_quality\n  image: golang:1.22\n  script:\n    - go vet ./...\n    - go test ./...\n`;
+        }
+        else if (c.language === LanguageId.Rust) {
+            yaml += `polyglot:rust:\n  stage: sharkcraft_quality\n  image: rust:1\n  script:\n    - cargo fmt --check\n    - cargo clippy -- -D warnings\n    - cargo test\n`;
+        }
+    }
+    return yaml;
+}
+export function renderPolyglotBitbucketSteps(projectRoot, options = {}) {
+    const cmds = selectCommands(projectRoot, options);
+    if (cmds.length === 0)
+        return '# (no non-JS/TS languages detected — no polyglot steps added)\n';
+    let yaml = '\n# Polyglot steps\n';
+    for (const c of cmds) {
+        if (c.language === LanguageId.Java) {
+            const isMaven = (c.install ?? '').startsWith('mvn');
+            yaml += `    - step: &polyglot-java\n        name: Polyglot Java\n        image: ${isMaven ? 'maven:3-eclipse-temurin-21' : 'gradle:8-jdk21'}\n        script:\n          - ${isMaven ? 'mvn -B verify' : './gradlew test'}\n`;
+        }
+        else if (c.language === LanguageId.CSharp) {
+            yaml += `    - step: &polyglot-csharp\n        name: Polyglot .NET\n        image: mcr.microsoft.com/dotnet/sdk:8.0\n        script:\n          - dotnet restore\n          - dotnet build --no-restore\n          - dotnet test --no-build\n`;
+        }
+        else if (c.language === LanguageId.Python) {
+            yaml += `    - step: &polyglot-python\n        name: Polyglot Python\n        image: python:3.12\n        script:\n`;
+            if (c.install)
+                yaml += `          - ${c.install}\n`;
+            if (c.lint)
+                yaml += `          - ${c.lint}\n`;
+            if (c.test)
+                yaml += `          - ${c.test}\n`;
+        }
+        else if (c.language === LanguageId.Go) {
+            yaml += `    - step: &polyglot-go\n        name: Polyglot Go\n        image: golang:1.22\n        script:\n          - go vet ./...\n          - go test ./...\n`;
+        }
+        else if (c.language === LanguageId.Rust) {
+            yaml += `    - step: &polyglot-rust\n        name: Polyglot Rust\n        image: rust:1\n        script:\n          - cargo fmt --check\n          - cargo clippy -- -D warnings\n          - cargo test\n`;
+        }
+    }
+    return yaml;
+}
+export function renderPolyglotAzureStages(projectRoot, options = {}) {
+    const cmds = selectCommands(projectRoot, options);
+    if (cmds.length === 0)
+        return '# (no non-JS/TS languages detected — no polyglot stages added)\n';
+    let yaml = '\n# Polyglot stages\n';
+    for (const c of cmds) {
+        if (c.language === LanguageId.Java) {
+            const isMaven = (c.install ?? '').startsWith('mvn');
+            yaml += `  - stage: Polyglot_Java\n    dependsOn: SharkCraft_Install\n    jobs:\n      - job: Java\n        steps:\n          - task: ${isMaven ? 'Maven@4' : 'Gradle@2'}\n            displayName: ${isMaven ? 'mvn verify' : 'gradle test'}\n`;
+        }
+        else if (c.language === LanguageId.CSharp) {
+            yaml += `  - stage: Polyglot_DotNet\n    dependsOn: SharkCraft_Install\n    jobs:\n      - job: DotNet\n        steps:\n          - task: UseDotNet@2\n            inputs:\n              version: '8.x'\n          - script: dotnet restore && dotnet build --no-restore && dotnet test --no-build\n            displayName: 'dotnet test'\n`;
+        }
+        else if (c.language === LanguageId.Python) {
+            yaml += `  - stage: Polyglot_Python\n    dependsOn: SharkCraft_Install\n    jobs:\n      - job: Python\n        steps:\n          - task: UsePythonVersion@0\n            inputs:\n              versionSpec: '3.12'\n`;
+            if (c.install)
+                yaml += `          - script: ${c.install}\n            displayName: install\n`;
+            if (c.lint)
+                yaml += `          - script: ${c.lint}\n            displayName: lint\n`;
+            if (c.test)
+                yaml += `          - script: ${c.test}\n            displayName: test\n`;
+        }
+        else if (c.language === LanguageId.Go) {
+            yaml += `  - stage: Polyglot_Go\n    dependsOn: SharkCraft_Install\n    jobs:\n      - job: Go\n        steps:\n          - task: GoTool@0\n            inputs:\n              version: '1.22'\n          - script: go vet ./... && go test ./...\n            displayName: 'go test'\n`;
+        }
+        else if (c.language === LanguageId.Rust) {
+            yaml += `  - stage: Polyglot_Rust\n    dependsOn: SharkCraft_Install\n    jobs:\n      - job: Rust\n        steps:\n          - script: curl -sSf https://sh.rustup.rs | sh -s -- -y && source $HOME/.cargo/env && cargo fmt --check && cargo clippy -- -D warnings && cargo test\n            displayName: 'cargo test'\n`;
+        }
+    }
+    return yaml;
+}
+export function renderPolyglotJenkinsStages(projectRoot, options = {}) {
+    const cmds = selectCommands(projectRoot, options);
+    if (cmds.length === 0)
+        return '// (no non-JS/TS languages detected — no polyglot stages added)\n';
+    let groovy = '\n// Polyglot stages\n';
+    for (const c of cmds) {
+        if (c.language === LanguageId.Java) {
+            const isMaven = (c.install ?? '').startsWith('mvn');
+            groovy += `    stage('Polyglot Java') {\n      steps {\n        sh '${isMaven ? 'mvn -B verify' : './gradlew test'}'\n      }\n    }\n`;
+        }
+        else if (c.language === LanguageId.CSharp) {
+            groovy += `    stage('Polyglot .NET') {\n      steps {\n        sh 'dotnet restore && dotnet build --no-restore && dotnet test --no-build'\n      }\n    }\n`;
+        }
+        else if (c.language === LanguageId.Python) {
+            groovy += `    stage('Polyglot Python') {\n      steps {\n`;
+            if (c.install)
+                groovy += `        sh '${c.install}'\n`;
+            if (c.lint)
+                groovy += `        sh '${c.lint}'\n`;
+            if (c.test)
+                groovy += `        sh '${c.test}'\n`;
+            groovy += `      }\n    }\n`;
+        }
+        else if (c.language === LanguageId.Go) {
+            groovy += `    stage('Polyglot Go') {\n      steps {\n        sh 'go vet ./...'\n        sh 'go test ./...'\n      }\n    }\n`;
+        }
+        else if (c.language === LanguageId.Rust) {
+            groovy += `    stage('Polyglot Rust') {\n      steps {\n        sh 'cargo fmt --check'\n        sh 'cargo clippy -- -D warnings'\n        sh 'cargo test'\n      }\n    }\n`;
+        }
+    }
+    return groovy;
+}