@shrkcrft/cli 0.1.0-alpha.2

package/dist/commands/biome.command.js

@@ -0,0 +1,350 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { inspectSharkcraft } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson, header } from "../output/format-output.js";
+/**
+ * Biome bridge. Biome's rule grammar is narrower than ESLint's, so this
+ * adapter is intentionally smaller: scaffold a `biome.sharkcraft.json` that
+ * ignores any generated paths SharkCraft tracks, and documents which
+ * SharkCraft rules Biome cannot express (so the user knows to keep
+ * `shrk check boundaries` in CI for those).
+ */
+const SCAFFOLD_DEFAULT_RELPATH = 'biome.sharkcraft.json';
+function renderBiomeSnippet(generatedGlobs) {
+    const ignored = generatedGlobs.length > 0 ? generatedGlobs : ['**/dist/**', '**/build/**'];
+    const config = {
+        $schema: 'https://biomejs.dev/schemas/1.9.0/schema.json',
+        organizeImports: { enabled: true },
+        formatter: { enabled: true },
+        linter: {
+            enabled: true,
+            rules: { recommended: true },
+        },
+        // Generated paths SharkCraft tracks — Biome should skip them.
+        files: { ignore: ignored },
+    };
+    return JSON.stringify(config, null, 2) + '\n';
+}
+const BIOME_NOTES = `\
+# Biome bridge — limitations
+
+Biome cannot express SharkCraft's cross-layer / cross-package boundary
+rules. Keep \`shrk check boundaries\` in CI for those.
+
+Run on every PR:
+  $ shrk check boundaries --changed-only --json > boundaries.json
+  $ shrk ci scaffold github-actions --quickstart   # one-flag setup
+`;
+export const biomeScaffoldCommand = {
+    name: 'scaffold',
+    description: 'Scaffold a minimal Biome config that ignores SharkCraft generated paths. Documents which SharkCraft rules Biome cannot express. Dry-run by default; `--write` persists.',
+    usage: 'shrk biome scaffold [--output <path>] [--preset auto] [--write] [--force] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const presetMode = flagString(args, 'preset');
+        if (presetMode && presetMode !== 'auto') {
+            process.stderr.write(`Unknown --preset value "${presetMode}" (only "auto" is supported).\n`);
+            return 2;
+        }
+        let generatedGlobs = [];
+        try {
+            const inspection = await inspectSharkcraft({ cwd });
+            const pathList = inspection.pathService.list();
+            generatedGlobs = pathList
+                .filter((p) => p.tags?.some((t) => /generated|build|dist|output/i.test(t)))
+                .map((p) => (typeof p.metadata?.path === 'string' ? p.metadata.path : null))
+                .filter((g) => typeof g === 'string' && g.length > 0);
+        }
+        catch {
+            // best-effort — the scaffold still works without sharkcraft/.
+        }
+        const body = renderBiomeSnippet(generatedGlobs);
+        const outputRel = flagString(args, 'output') ?? SCAFFOLD_DEFAULT_RELPATH;
+        const outputAbs = nodePath.isAbsolute(outputRel) ? outputRel : nodePath.join(cwd, outputRel);
+        if (flagBool(args, 'json')) {
+            const mode = flagBool(args, 'write') ? 'write' : 'dry-run';
+            process.stdout.write(asJson({ mode, output: outputAbs, bytes: body.length, body }) + '\n');
+            if (mode !== 'write')
+                return 0;
+        }
+        if (!flagBool(args, 'write')) {
+            process.stdout.write(header('Biome scaffold — dry-run'));
+            process.stdout.write(`output: ${outputAbs}\n`);
+            process.stdout.write(`bytes:  ${body.length}\n\n`);
+            process.stdout.write(body);
+            process.stdout.write('\n' + BIOME_NOTES);
+            process.stdout.write('\nRun with --write to persist.\n');
+            return 0;
+        }
+        if (existsSync(outputAbs) && !flagBool(args, 'force')) {
+            process.stderr.write(`Refusing to overwrite existing file: ${outputAbs}. Pass --force.\n`);
+            return 1;
+        }
+        mkdirSync(nodePath.dirname(outputAbs), { recursive: true });
+        writeFileSync(outputAbs, body, 'utf8');
+        process.stdout.write(`Wrote ${outputAbs}\n${BIOME_NOTES}`);
+        return 0;
+    },
+};
+export const biomeReportCommand = {
+    name: 'report',
+    description: 'Convert `shrk check boundaries --json` output to a Biome-adjacent diagnostics JSON shape. Biome cannot natively consume this, but Biome-result-consuming tooling can.',
+    usage: 'shrk biome report [--from <path>] [--output <path>] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const from = flagString(args, 'from');
+        const fromAbs = from
+            ? nodePath.isAbsolute(from)
+                ? from
+                : nodePath.join(cwd, from)
+            : null;
+        if (!fromAbs) {
+            process.stderr.write('No --from <boundary-report.json> passed. Generate one first:\n' +
+                '  $ shrk check boundaries --json > boundaries.json\n' +
+                '  $ shrk biome report --from boundaries.json > biome-adjacent.json\n');
+            return 2;
+        }
+        if (!existsSync(fromAbs)) {
+            process.stderr.write(`--from file not found: ${fromAbs}\n`);
+            return 1;
+        }
+        let report;
+        try {
+            report = JSON.parse(readFileSync(fromAbs, 'utf8'));
+        }
+        catch (e) {
+            process.stderr.write(`Failed to parse boundary report JSON: ${e.message}\n`);
+            return 1;
+        }
+        const out = [];
+        for (const v of report.violations ?? []) {
+            const path = v.file ?? '<unknown>';
+            const diag = {
+                category: 'sharkcraft/boundary-violation',
+                severity: 'error',
+                location: { path: nodePath.isAbsolute(path) ? path : nodePath.join(cwd, path) },
+                description: (v.reason ?? 'SharkCraft boundary violation') +
+                    (v.source && v.target ? ` (${v.source} → ${v.target})` : ''),
+                source: 'sharkcraft',
+            };
+            if (typeof v.line === 'number')
+                diag.location.line = v.line;
+            if (typeof v.column === 'number')
+                diag.location.column = v.column;
+            out.push(diag);
+        }
+        const text = asJson({
+            schema: 'sharkcraft.biome-adjacent/v1',
+            tool: 'sharkcraft',
+            generatedAt: new Date().toISOString(),
+            diagnostics: out,
+            note: 'Adjacent to Biome — not native Biome output. See `shrk biome explain-limitations`.',
+        }) + '\n';
+        const outputRel = flagString(args, 'output');
+        if (outputRel) {
+            const outputAbs = nodePath.isAbsolute(outputRel) ? outputRel : nodePath.join(cwd, outputRel);
+            mkdirSync(nodePath.dirname(outputAbs), { recursive: true });
+            writeFileSync(outputAbs, text, 'utf8');
+            process.stdout.write(`Wrote ${outputAbs}\n`);
+        }
+        else {
+            process.stdout.write(text);
+        }
+        return out.length > 0 ? 1 : 0;
+    },
+};
+const BIOME_LIMITATIONS = `\
+# Biome bridge — limitations
+
+What the bridge **can** do today:
+
+  • \`shrk biome scaffold\` — emit a minimal biome.json that ignores
+    SharkCraft generated paths and lists the SharkCraft rules Biome
+    cannot express.
+  • \`shrk biome report\` — convert \`shrk check boundaries --json\`
+    output to a Biome-adjacent diagnostics shape that Biome-result-
+    consuming tooling can ingest. **Not native Biome output** — Biome
+    has no public custom-rule plugin surface today.
+
+What the bridge **cannot** express in Biome:
+
+  • All cross-layer / cross-package boundary rules. Biome's lint
+    grammar is narrower than ESLint's.
+  • Plan safety, pack signatures, knowledge stale-check, template
+    drift, self-config doctor. None of these have a Biome analog.
+  • Custom SharkCraft rules with action hints.
+
+Recommendation: use Biome for fast file-local linting / formatting;
+keep \`shrk doctor\`, \`shrk check boundaries\`, \`shrk safety audit\`
+in CI.
+
+If you need a single tool to ingest SharkCraft findings, prefer
+\`shrk eslint report\` (native ESLint result format) or
+\`shrk checks aggregate\` (universal protocol). The Biome adjacent
+report is a fallback for repos that have standardized on Biome and
+don't want to add ESLint just for SharkCraft.
+`;
+function buildBiomeBridgeInventory(rules, paths) {
+    const rows = [];
+    for (const r of rules) {
+        const tagText = (r.tags ?? []).join(' ').toLowerCase();
+        let status = 'not-bridgeable';
+        let notes = 'No Biome analog — keep in `shrk doctor` / `shrk check boundaries`.';
+        if (tagText.includes('format') || tagText.includes('style') || tagText.includes('naming')) {
+            status = 'bridgeable';
+            notes = "Likely covered by Biome's built-in linter/formatter recommended rules.";
+        }
+        else if (tagText.includes('import') || tagText.includes('boundary') || tagText.includes('layer')) {
+            status = 'adjacent';
+            notes = 'Adjacent — `shrk biome report` re-emits boundary findings; Biome itself cannot enforce.';
+        }
+        else if (tagText.includes('safety') || tagText.includes('signing') || tagText.includes('plan') || tagText.includes('pack')) {
+            status = 'not-bridgeable';
+            notes = 'Plan / pack / signing semantics — Biome has no concept.';
+        }
+        rows.push({ kind: 'rule', id: r.id, status, notes });
+    }
+    for (const p of paths) {
+        const tagText = (p.tags ?? []).join(' ').toLowerCase();
+        const isGenerated = /generated|build|dist|output/.test(tagText);
+        rows.push({
+            kind: 'path',
+            id: p.id,
+            status: isGenerated ? 'bridgeable' : 'adjacent',
+            notes: isGenerated
+                ? "Goes in biome.json `files.ignore`."
+                : 'Adjacent: SharkCraft surfaces for context; not directly enforceable.',
+        });
+    }
+    rows.push({
+        kind: 'boundary',
+        id: 'check-boundaries',
+        status: 'adjacent',
+        notes: '`shrk biome report` emits Biome-adjacent diagnostics; Biome cannot enforce.',
+    });
+    rows.push({
+        kind: 'safety',
+        id: 'plan-signing / pack-signatures / knowledge-stale / template-drift / self-config',
+        status: 'not-bridgeable',
+        notes: 'CI gate only — Biome has no semantic for any of these.',
+    });
+    return rows;
+}
+export const biomeRulesCommand = {
+    name: 'rules',
+    description: 'Inventory which SharkCraft constructs can be bridged to Biome (bridgeable / adjacent / not-bridgeable). Read-only.',
+    usage: 'shrk biome rules [--json] [--filter bridgeable|adjacent|not-bridgeable]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        let rules = [];
+        let paths = [];
+        try {
+            const inspection = await inspectSharkcraft({ cwd });
+            rules = inspection.ruleService.list().map((r) => ({ id: r.id, tags: r.tags ?? [] }));
+            paths = inspection.pathService.list().map((p) => ({ id: p.id, tags: p.tags ?? [] }));
+        }
+        catch {
+            // best-effort
+        }
+        const inventory = buildBiomeBridgeInventory(rules, paths);
+        const filter = flagString(args, 'filter');
+        const filtered = filter ? inventory.filter((r) => r.status === filter) : inventory;
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({ total: inventory.length, rows: filtered }) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Biome bridge inventory (${filtered.length} of ${inventory.length})`));
+        const buckets = {
+            bridgeable: [],
+            adjacent: [],
+            'not-bridgeable': [],
+        };
+        for (const r of filtered)
+            buckets[r.status].push(r);
+        for (const status of ['bridgeable', 'adjacent', 'not-bridgeable']) {
+            const rows = buckets[status];
+            if (!rows.length)
+                continue;
+            process.stdout.write(`\n[${status}] ${rows.length}\n`);
+            for (const r of rows) {
+                process.stdout.write(`  ${r.kind.padEnd(9)} ${r.id}\n`);
+                process.stdout.write(`            ${r.notes}\n`);
+            }
+        }
+        process.stdout.write('\nKeep in CI: `shrk check boundaries`, `shrk safety audit`, `shrk packs doctor`, `shrk knowledge stale-check`, `shrk templates drift`.\n');
+        return 0;
+    },
+};
+export const biomeExplainLimitationsCommand = {
+    name: 'explain-limitations',
+    description: 'Print the honest list of what cannot be bridged from SharkCraft to Biome and what to keep in CI.',
+    usage: 'shrk biome explain-limitations [--json]',
+    async run(args) {
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({
+                bridgeable: [
+                    'generated path ignores',
+                    'formatter / organizeImports defaults',
+                ],
+                adjacent: [
+                    'shrk check boundaries (via `shrk biome report`, non-native shape)',
+                ],
+                notBridgeable: [
+                    'cross-layer boundary rules',
+                    'plan signing',
+                    'pack signatures',
+                    'knowledge stale-check',
+                    'template drift',
+                    'self-config doctor',
+                    'custom SharkCraft rules with action hints',
+                ],
+                keepInCi: [
+                    'shrk doctor',
+                    'shrk check boundaries',
+                    'shrk safety audit',
+                    'shrk packs doctor',
+                    'shrk knowledge stale-check',
+                    'shrk templates drift',
+                ],
+            }) + '\n');
+            return 0;
+        }
+        process.stdout.write(BIOME_LIMITATIONS);
+        return 0;
+    },
+};
+export const biomeCommand = {
+    name: 'biome',
+    description: 'Biome bridge. `scaffold` emits a minimal biome.json that ignores SharkCraft generated paths; `report` converts boundary JSON to a Biome-adjacent diagnostics shape; `rules` inventories what can be bridged; `explain-limitations` documents what cannot. `config` is an alias for `scaffold`.',
+    usage: 'shrk biome <scaffold|config|report|rules|explain-limitations> [...flags]',
+    async run(args) {
+        const verb = args.positional[0];
+        if (verb === 'scaffold' || verb === 'config') {
+            return biomeScaffoldCommand.run({
+                ...args,
+                positional: args.positional.slice(1),
+            });
+        }
+        if (verb === 'report') {
+            return biomeReportCommand.run({
+                ...args,
+                positional: args.positional.slice(1),
+            });
+        }
+        if (verb === 'rules') {
+            return biomeRulesCommand.run({
+                ...args,
+                positional: args.positional.slice(1),
+            });
+        }
+        if (verb === 'explain-limitations') {
+            return biomeExplainLimitationsCommand.run({
+                ...args,
+                positional: args.positional.slice(1),
+            });
+        }
+        process.stderr.write('Usage: shrk biome <scaffold|config|report|rules|explain-limitations> [...flags]\n');
+        return 2;
+    },
+};

package/dist/commands/boundaries.command.d.ts

@@ -0,0 +1,9 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const boundariesListCommand: ICommandHandler;
+export declare const boundariesGetCommand: ICommandHandler;
+export declare const boundariesExplainCommand: ICommandHandler;
+export declare const boundariesInferCommand: ICommandHandler;
+/** Polyglot enforcement subcommand. */
+export declare const boundariesEnforceCommand: ICommandHandler;
+export declare const boundariesSuggestCommand: ICommandHandler;
+//# sourceMappingURL=boundaries.command.d.ts.map

package/dist/commands/boundaries.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundaries.command.d.ts","sourceRoot":"","sources":["../../src/commands/boundaries.command.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAwB,KAAK,eAAe,EAA+B,MAAM,wBAAwB,CAAC;AAGjH,eAAO,MAAM,qBAAqB,EAAE,eAuBnC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,eAqClC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAmDtC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAyEpC,CAAC;AAsCF,uCAAuC;AACvC,eAAO,MAAM,wBAAwB,EAAE,eAqEtC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eA0CtC,CAAC"}

package/dist/commands/boundaries.command.js

@@ -0,0 +1,314 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildOnboardingPlan, buildPolyglotBoundaryReport, inspectSharkcraft, renderPolyglotBoundaryReportMarkdown, renderPolyglotBoundaryReportText, suggestBoundaryFixes, } from '@shrkcrft/inspector';
+import { evaluateBoundaries, loadTsconfigPaths, scanImports, } from '@shrkcrft/boundaries';
+import { flagBool, flagString, resolveCwd } from "../command-registry.js";
+import { asJson, header, kv } from "../output/format-output.js";
+export const boundariesListCommand = {
+    name: 'list',
+    description: 'List all registered boundary rules (local + pack-contributed).',
+    usage: 'shrk [--cwd <dir>] boundaries list [--json]',
+    async run(args) {
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const rules = inspection.boundaryRegistry.list();
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(rules) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Boundary rules (${rules.length})`));
+        if (rules.length === 0) {
+            process.stdout.write('  (none registered)\n');
+            return 0;
+        }
+        for (const r of rules) {
+            process.stdout.write(`  ${(r.severity ?? 'warning').toUpperCase().padEnd(8)} ${r.id.padEnd(36)} ${r.title}\n`);
+        }
+        return 0;
+    },
+};
+export const boundariesGetCommand = {
+    name: 'get',
+    description: 'Show one boundary rule (by id) in full.',
+    usage: 'shrk [--cwd <dir>] boundaries get <ruleId> [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk boundaries get <ruleId>\n');
+            return 2;
+        }
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const rule = inspection.boundaryRegistry.get(id);
+        if (!rule) {
+            process.stderr.write(`No boundary rule with id "${id}".\n`);
+            return 1;
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(rule) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Boundary rule: ${rule.id}`));
+        process.stdout.write(kv('title', rule.title) + '\n');
+        process.stdout.write(kv('severity', rule.severity ?? 'warning') + '\n');
+        if (rule.from && rule.from.length > 0) {
+            process.stdout.write(kv('from', rule.from.join(', ')) + '\n');
+        }
+        if (rule.forbiddenImports && rule.forbiddenImports.length > 0) {
+            process.stdout.write(kv('forbidden', rule.forbiddenImports.join(', ')) + '\n');
+        }
+        if (rule.allowedImports && rule.allowedImports.length > 0) {
+            process.stdout.write(kv('allowed', rule.allowedImports.join(', ')) + '\n');
+        }
+        if (rule.suggestedFix) {
+            process.stdout.write(kv('suggestedFix', rule.suggestedFix) + '\n');
+        }
+        return 0;
+    },
+};
+export const boundariesExplainCommand = {
+    name: 'explain',
+    description: 'Explain a boundary rule: where it came from (local vs pack), what it forbids, what to do about violations.',
+    usage: 'shrk [--cwd <dir>] boundaries explain <ruleId> [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk boundaries explain <ruleId>\n');
+            return 2;
+        }
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const rule = inspection.boundaryRegistry.get(id);
+        if (!rule) {
+            process.stderr.write(`No boundary rule with id "${id}".\n`);
+            return 1;
+        }
+        const source = inspection.boundarySources.get(id);
+        const explanation = {
+            id: rule.id,
+            title: rule.title,
+            severity: rule.severity ?? 'warning',
+            origin: source ? (source.type === 'pack' ? `pack: ${source.packageName}` : 'local') : 'unknown',
+            from: rule.from ?? [],
+            forbiddenImports: rule.forbiddenImports ?? [],
+            allowedImports: rule.allowedImports ?? [],
+            suggestedFix: rule.suggestedFix,
+            howToFix: 'Adjust the offending import to either (a) drop the disallowed dependency, (b) use a public interface from the allowed list, or (c) move the importer into a layer where this dependency is permitted.',
+        };
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(explanation) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Boundary explain: ${rule.id}`));
+        process.stdout.write(kv('title', rule.title) + '\n');
+        process.stdout.write(kv('severity', rule.severity ?? 'warning') + '\n');
+        process.stdout.write(kv('origin', explanation.origin) + '\n');
+        if (explanation.from.length > 0) {
+            process.stdout.write(kv('applies to', explanation.from.join(', ')) + '\n');
+        }
+        if (explanation.forbiddenImports.length > 0) {
+            process.stdout.write(kv('forbidden', explanation.forbiddenImports.join(', ')) + '\n');
+        }
+        if (explanation.allowedImports.length > 0) {
+            process.stdout.write(kv('allowed', explanation.allowedImports.join(', ')) + '\n');
+        }
+        if (rule.suggestedFix)
+            process.stdout.write(`\nSuggested fix: ${rule.suggestedFix}\n`);
+        process.stdout.write(`\nHow to fix: ${explanation.howToFix}\n`);
+        return 0;
+    },
+};
+export const boundariesInferCommand = {
+    name: 'infer',
+    description: 'Infer candidate boundary rules from the current repo (monorepo structure, package boundaries, naming heuristics). Dry-run by default; --write-drafts writes to sharkcraft/boundary-drafts/boundaries.draft.ts. --language all|java|csharp|python|go|rust adds polyglot suggestions.',
+    usage: 'shrk [--cwd <dir>] boundaries infer [--write-drafts] [--language all|java|csharp|python|go|rust] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const plan = buildOnboardingPlan(inspection, {});
+        const inferred = plan.inferredBoundaryRules;
+        const langFlag = flagString(args, 'language');
+        let languageSuggestions = null;
+        if (langFlag) {
+            const { suggestLanguageBoundaries } = await import('@shrkcrft/inspector');
+            const lang = langFlag.toLowerCase();
+            languageSuggestions = suggestLanguageBoundaries(cwd, lang === 'all' ? {} : { language: lang });
+        }
+        const wantJson = flagBool(args, 'json');
+        const writeDrafts = flagBool(args, 'write-drafts');
+        if (writeDrafts) {
+            const outDir = nodePath.join(cwd, 'sharkcraft', 'boundary-drafts');
+            mkdirSync(outDir, { recursive: true });
+            const outFile = nodePath.join(outDir, 'boundaries.draft.ts');
+            if (!outFile.startsWith(outDir + nodePath.sep)) {
+                process.stderr.write('Refusing to write outside boundary-drafts dir.\n');
+                return 1;
+            }
+            const body = renderInferredBoundariesDraft(inferred);
+            writeFileSync(outFile, body, 'utf8');
+            if (wantJson) {
+                process.stdout.write(asJson({ mode: 'write-drafts', outFile, bytes: body.length, count: inferred.length }) +
+                    '\n');
+                return 0;
+            }
+            process.stdout.write(header('Boundary inference (write-drafts)'));
+            process.stdout.write(kv('outFile', outFile) + '\n');
+            process.stdout.write(kv('count', String(inferred.length)) + '\n');
+            return 0;
+        }
+        if (wantJson) {
+            process.stdout.write(asJson({ inferred, ...(languageSuggestions ? { languageSuggestions } : {}) }) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Inferred boundary rules (${inferred.length})`));
+        if (inferred.length === 0) {
+            process.stdout.write('  (no candidates inferred)\n');
+        }
+        for (const r of inferred) {
+            process.stdout.write(`  ${r.severity.toUpperCase().padEnd(8)} ${r.id.padEnd(36)} ${r.title}\n`);
+            process.stdout.write(`           reason: ${r.reason}\n`);
+        }
+        if (languageSuggestions && languageSuggestions.suggestions.length > 0) {
+            process.stdout.write(`\nPolyglot suggestions (${languageSuggestions.suggestions.length}):\n`);
+            for (const s of languageSuggestions.suggestions) {
+                process.stdout.write(`  ${s.severity.toUpperCase().padEnd(8)} [${s.language}] ${s.id.padEnd(48)} ${s.title}\n`);
+                process.stdout.write(`           reason: ${s.reason}\n`);
+            }
+        }
+        process.stdout.write('\nDry-run only. Re-run with `--write-drafts` to write sharkcraft/boundary-drafts/boundaries.draft.ts.\n');
+        return 0;
+    },
+};
+function renderInferredBoundariesDraft(rules) {
+    const lines = [];
+    lines.push('// Boundary rules inferred by `shrk boundaries infer --write-drafts`.');
+    lines.push('// Review and copy keepers into sharkcraft/boundaries.ts.');
+    lines.push('export default [');
+    for (const r of rules) {
+        lines.push(`  {`);
+        lines.push(`    id: '${r.id}',`);
+        lines.push(`    title: ${JSON.stringify(r.title)},`);
+        lines.push(`    severity: '${r.severity}',`);
+        lines.push(`    from: ${JSON.stringify(r.from)},`);
+        if (r.forbiddenImports && r.forbiddenImports.length > 0) {
+            lines.push(`    forbiddenImports: ${JSON.stringify(r.forbiddenImports)},`);
+        }
+        if (r.allowedImports && r.allowedImports.length > 0) {
+            lines.push(`    allowedImports: ${JSON.stringify(r.allowedImports)},`);
+        }
+        lines.push(`    suggestedFix: ${JSON.stringify(r.suggestedFix)},`);
+        lines.push(`    // reason: ${r.reason}`);
+        lines.push(`  },`);
+    }
+    lines.push('];');
+    return lines.join('\n') + '\n';
+}
+/** Polyglot enforcement subcommand. */
+export const boundariesEnforceCommand = {
+    name: 'enforce',
+    description: 'Polyglot boundary enforcement report. Read-only; CLI-only — never mutates source.',
+    usage: 'shrk [--cwd <dir>] boundaries enforce [--language all|java|csharp|python|go|rust|typescript] [--changed-only|--since <ref>|--staged|--files a,b,c] [--format text|markdown|json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const langFlag = (flagString(args, 'language') ?? 'all').toLowerCase();
+        const languages = langFlag === 'all' ? undefined : [langFlag];
+        const report = buildPolyglotBoundaryReport({ projectRoot: cwd, ...(languages ? { languages } : {}) });
+        // Changed-only filtering against the polyglot report.
+        const changedOnly = flagBool(args, 'changed-only');
+        const staged = flagBool(args, 'staged');
+        const since = flagString(args, 'since');
+        const filesRaw = flagString(args, 'files');
+        const fileList = filesRaw
+            ? filesRaw.split(',').map((s) => s.trim()).filter(Boolean)
+            : [];
+        const wantChangedScope = changedOnly || staged || Boolean(since) || fileList.length > 0;
+        const { filterViolationsToChangedScope } = await import('@shrkcrft/inspector');
+        const filtered = wantChangedScope
+            ? filterViolationsToChangedScope(report.violations, {
+                projectRoot: cwd,
+                ...(fileList.length > 0 ? { files: fileList } : {}),
+                ...(staged ? { staged: true } : {}),
+                ...(since ? { since } : {}),
+                ...(changedOnly && !staged && !since && fileList.length === 0
+                    ? { includeWorktree: true }
+                    : {}),
+            })
+            : null;
+        const finalViolations = filtered ? filtered.includedViolations : report.violations;
+        const errors = finalViolations.filter((v) => v.severity === 'error').length;
+        const warnings = finalViolations.filter((v) => v.severity === 'warning').length;
+        const format = (flagString(args, 'format') ?? 'text').toLowerCase();
+        if (flagBool(args, 'json') || format === 'json') {
+            const payload = {
+                ...report,
+                violations: finalViolations,
+                counts: { ...report.counts, errors, warnings },
+                ...(filtered
+                    ? {
+                        changedScope: {
+                            mode: filtered.mode,
+                            changedFiles: filtered.changedFiles,
+                            ignoredLegacyCount: filtered.ignoredLegacyCount,
+                            ignoredLegacyByRule: filtered.ignoredLegacyByRule,
+                        },
+                    }
+                    : {}),
+            };
+            process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
+            return errors > 0 ? 1 : 0;
+        }
+        if (format === 'markdown' || format === 'md') {
+            process.stdout.write(renderPolyglotBoundaryReportMarkdown({ ...report, violations: finalViolations, counts: { ...report.counts, errors, warnings } }) + '\n');
+            return errors > 0 ? 1 : 0;
+        }
+        // Default text path: render via existing renderer and append changed-scope footer.
+        process.stdout.write(renderPolyglotBoundaryReportText({ ...report, violations: finalViolations, counts: { ...report.counts, errors, warnings } }));
+        if (filtered) {
+            process.stdout.write(`\nMode: ${filtered.mode}\n`);
+            process.stdout.write(`Changed files: ${filtered.changedFiles.length}\n`);
+            process.stdout.write(`Legacy ignored: ${filtered.ignoredLegacyCount}\n`);
+            if (finalViolations.length === 0) {
+                process.stdout.write('No polyglot boundary violations introduced by changed files.\n');
+            }
+        }
+        return errors > 0 ? 1 : 0;
+    },
+};
+export const boundariesSuggestCommand = {
+    name: 'suggest',
+    description: 'Suggest fixes for boundary violations (by rule id, file, or all).',
+    usage: 'shrk boundaries suggest [<ruleId or file>] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const rules = inspection.boundaryRegistry.list();
+        if (rules.length === 0) {
+            process.stderr.write('No boundary rules configured.\n');
+            return 0;
+        }
+        const scan = scanImports({ projectRoot: cwd });
+        const tsconfigPaths = loadTsconfigPaths(cwd);
+        const evalResult = evaluateBoundaries(scan, rules, {
+            ...(tsconfigPaths.aliases.size > 0 ? { tsconfigPaths } : {}),
+        });
+        const filter = args.positional[0];
+        const filtered = filter
+            ? evalResult.violations.filter((v) => v.ruleId === filter || v.file.includes(filter))
+            : evalResult.violations;
+        const suggestions = suggestBoundaryFixes(inspection, filtered.map((v) => ({
+            ruleId: v.ruleId,
+            file: v.file,
+            line: v.line,
+            importSpecifier: v.importSpecifier,
+            ...(v.suggestedFix ? { suggestedFix: v.suggestedFix } : {}),
+        })));
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(suggestions) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Boundary fix suggestions (${suggestions.length})`));
+        for (const s of suggestions) {
+            process.stdout.write(`  ${s.ruleId}  ${s.file}:${s.line}\n`);
+            for (const sug of s.suggestions)
+                process.stdout.write(`    ↳ ${sug}\n`);
+        }
+        return 0;
+    },
+};