@shrkcrft/cli 0.1.0-alpha.2

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

@@ -0,0 +1,5 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const architectureMapCommand: ICommandHandler;
+export declare const architectureViolationsCommand: ICommandHandler;
+export declare const architectureAreaCommand: ICommandHandler;
+//# sourceMappingURL=architecture.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"architecture.command.d.ts","sourceRoot":"","sources":["../../src/commands/architecture.command.ts"],"names":[],"mappings":"AAgBA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAehC,eAAO,MAAM,sBAAsB,EAAE,eA8BpC,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,eAmE3C,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,eAyBrC,CAAC"}

package/dist/commands/architecture.command.js

@@ -0,0 +1,141 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildArchitectureArea, buildArchitectureMap, buildArchitectureViolations, buildArchitectureViolationsDiff, inspectSharkcraft, renderArchitectureMapHtml, renderArchitectureMapMarkdown, renderArchitectureMapText, renderArchitectureViolationsDiffHtml, renderArchitectureViolationsDiffMarkdown, renderArchitectureViolationsDiffText, } from '@shrkcrft/inspector';
+import { flagBool, flagString, flagList, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+const ALL_INCLUDES = ['layers', 'constructs', 'boundaries', 'policies', 'public-api', 'tests', 'ownership'];
+function parseInclude(args) {
+    const raw = flagList(args, 'include');
+    if (raw.length === 0)
+        return ALL_INCLUDES;
+    const flat = raw
+        .flatMap((v) => v.split(','))
+        .map((v) => v.trim())
+        .filter(Boolean);
+    return flat.length > 0 ? flat : ALL_INCLUDES;
+}
+export const architectureMapCommand = {
+    name: 'map',
+    description: 'Build an architecture map (layers, constructs, boundaries, public-api surfaces, tests/ownership hints, risks). Read-only.',
+    usage: 'shrk architecture map [--include layers,constructs,...] [--risk] [--signals] [--format text|markdown|html|json] [--output <file>]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const include = parseInclude(args);
+        const risk = flagBool(args, 'risk');
+        const signals = flagBool(args, 'signals');
+        const map = await buildArchitectureMap(inspection, { include, risk, signals });
+        const format = flagString(args, 'format') ?? (flagBool(args, 'json') ? 'json' : 'text');
+        const output = flagString(args, 'output');
+        let body = '';
+        if (format === 'json')
+            body = asJson(map) + '\n';
+        else if (format === 'markdown')
+            body = renderArchitectureMapMarkdown(map);
+        else if (format === 'html')
+            body = renderArchitectureMapHtml(map);
+        else
+            body = renderArchitectureMapText(map);
+        if (output) {
+            const abs = nodePath.isAbsolute(output) ? output : nodePath.resolve(cwd, output);
+            mkdirSync(nodePath.dirname(abs), { recursive: true });
+            writeFileSync(abs, body, 'utf8');
+            process.stdout.write(`Wrote ${abs}\n`);
+            return 0;
+        }
+        process.stdout.write(body);
+        return 0;
+    },
+};
+export const architectureViolationsCommand = {
+    name: 'violations',
+    description: 'Show boundary violations as a flat report (read-only). `--since <ref>` / `--staged` / `--files a,b,c` / `--baseline <json>` scope/diff the report.',
+    usage: 'shrk architecture violations [--since <ref>] [--staged] [--files a,b,c] [--baseline <json>] [--format text|markdown|html|json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const since = flagString(args, 'since');
+        const staged = flagBool(args, 'staged');
+        const changedOnly = flagBool(args, 'changed-only');
+        const baselineFile = flagString(args, 'baseline');
+        const filesRaw = flagString(args, 'files');
+        const files = filesRaw
+            ? filesRaw.split(',').map((f) => f.trim()).filter((f) => f.length > 0)
+            : [];
+        // --changed-only is an alias that selects working-tree changes
+        // (untracked + modified) when no other scope flag is provided.
+        const isDiff = Boolean(since || staged || baselineFile || changedOnly) || files.length > 0;
+        const format = (flagString(args, 'format') ?? '').toLowerCase();
+        if (!isDiff) {
+            const report = await buildArchitectureViolations(inspection);
+            if (flagBool(args, 'json') || format === 'json') {
+                process.stdout.write(asJson(report) + '\n');
+                return report.total === 0 ? 0 : 1;
+            }
+            process.stdout.write(`=== Architecture violations ===\n  total ${report.total}\n`);
+            if (report.byRule.length > 0) {
+                process.stdout.write('By rule:\n');
+                for (const r of report.byRule)
+                    process.stdout.write(`  ${String(r.count).padStart(4)}  ${r.ruleId}\n`);
+            }
+            for (const v of report.violations.slice(0, 30))
+                process.stdout.write(`  [${v.severity}] ${v.ruleId} ${v.file}:${v.line} → ${v.importSpecifier}\n`);
+            return report.total === 0 ? 0 : 1;
+        }
+        // When --changed-only is set without a more specific scope, pull
+        // the working-tree changed files (untracked + modified) and pass through
+        // the `files` channel so the diff engine treats them as the changed set.
+        let resolvedFiles = files;
+        if (changedOnly && !since && !staged && files.length === 0) {
+            const { getChangedFiles } = await import('@shrkcrft/inspector');
+            resolvedFiles = getChangedFiles(cwd, { includeWorktree: true });
+        }
+        const diff = await buildArchitectureViolationsDiff(inspection, {
+            ...(since ? { since } : {}),
+            ...(staged ? { staged: true } : {}),
+            ...(baselineFile ? { baselineFile } : {}),
+            ...(resolvedFiles.length > 0 ? { files: resolvedFiles } : {}),
+        });
+        if (flagBool(args, 'json') || format === 'json') {
+            process.stdout.write(asJson(diff) + '\n');
+            return diff.counts.newInChangedFile === 0 ? 0 : 1;
+        }
+        if (format === 'markdown') {
+            process.stdout.write(renderArchitectureViolationsDiffMarkdown(diff));
+            return diff.counts.newInChangedFile === 0 ? 0 : 1;
+        }
+        if (format === 'html') {
+            process.stdout.write(renderArchitectureViolationsDiffHtml(diff));
+            return diff.counts.newInChangedFile === 0 ? 0 : 1;
+        }
+        process.stdout.write(renderArchitectureViolationsDiffText(diff));
+        return diff.counts.newInChangedFile === 0 ? 0 : 1;
+    },
+};
+export const architectureAreaCommand = {
+    name: 'area',
+    description: 'Show members of an architecture area (layer id: core/foundations/asset-registries/...).',
+    usage: 'shrk architecture area <areaId> [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk architecture area <areaId>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const r = await buildArchitectureArea(inspection, id);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(r) + '\n');
+            return r.found ? 0 : 1;
+        }
+        if (!r.found) {
+            process.stderr.write(`Area not found: ${id}\n`);
+            return 1;
+        }
+        process.stdout.write(`=== Area ${r.area} ===\n`);
+        for (const m of r.members)
+            process.stdout.write(`  • ${m}\n`);
+        return 0;
+    },
+};

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

@@ -0,0 +1,3 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const askCommand: ICommandHandler;
+//# sourceMappingURL=ask.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ask.command.d.ts","sourceRoot":"","sources":["../../src/commands/ask.command.ts"],"names":[],"mappings":"AAGA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAIhC,eAAO,MAAM,UAAU,EAAE,eA2DxB,CAAC"}

package/dist/commands/ask.command.js

@@ -0,0 +1,58 @@
+import { inspectSharkcraft, buildProjectOverview, renderOverviewText } from '@shrkcrft/inspector';
+import { buildContext } from '@shrkcrft/context';
+import { ClaudeProvider, AiMessageRole, buildPromptMessages } from '@shrkcrft/ai';
+import { flagBool, flagNumber, flagString, resolveCwd, } from "../command-registry.js";
+import { header } from "../output/format-output.js";
+import { printError } from "../output/print-error.js";
+export const askCommand = {
+    name: 'ask',
+    description: 'Ask a question. Builds repository context, sends prompt to Claude (requires ANTHROPIC_API_KEY).',
+    usage: 'shrk ask "<question>" [--max-tokens 3000] [--model claude-sonnet-4-6] [--dry-run]',
+    async run(args) {
+        const question = args.positional.join(' ').trim();
+        if (!question) {
+            process.stderr.write('Usage: shrk ask "<question>"\n');
+            return 2;
+        }
+        const maxTokens = flagNumber(args, 'max-tokens') ?? 3000;
+        const model = flagString(args, 'model');
+        const dryRun = flagBool(args, 'dry-run');
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const overview = buildProjectOverview(inspection.workspace, inspection.config?.projectName);
+        const ctx = buildContext(inspection.knowledgeEntries, {
+            task: question,
+            maxTokens,
+            projectOverview: renderOverviewText(overview),
+        });
+        const messages = buildPromptMessages({
+            systemPreamble: 'You are an AI engineer working in a SharkCraft-instrumented repository. Use the supplied repository context as authoritative ground truth. Quote knowledge entry ids you used.',
+            context: ctx.body,
+            task: question,
+        });
+        if (dryRun) {
+            process.stdout.write(header('Prompt (dry-run)'));
+            for (const m of messages) {
+                process.stdout.write(`\n[${m.role}]\n${m.content}\n`);
+            }
+            return 0;
+        }
+        const provider = new ClaudeProvider();
+        if (model)
+            provider.configure({ model });
+        if (!provider.isReady()) {
+            process.stderr.write('ANTHROPIC_API_KEY is not set. Use --dry-run to print the prompt instead.\n');
+            return 1;
+        }
+        const res = await provider.send({
+            messages: [...messages, { role: AiMessageRole.User, content: question }],
+            maxTokens: 1024,
+            model,
+        });
+        if (!res.ok) {
+            printError(res.error);
+            return 1;
+        }
+        process.stdout.write(res.value.content + '\n');
+        return 0;
+    },
+};

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

@@ -0,0 +1,3 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const auditProjectCouplingCommand: ICommandHandler;
+//# sourceMappingURL=audit.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"audit.command.d.ts","sourceRoot":"","sources":["../../src/commands/audit.command.ts"],"names":[],"mappings":"AAoBA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA8IhC,eAAO,MAAM,2BAA2B,EAAE,eAiBzC,CAAC"}

package/dist/commands/audit.command.js

@@ -0,0 +1,141 @@
+/**
+ * `shrk audit project-coupling`.
+ *
+ * The project-coupling audit is the load-bearing surface from the old
+ * `migrate` namespace; the rest of `migrate` was speculative and removed.
+ *
+ * Read-only:
+ *   - `audit`  prints to stdout
+ *   - `plan`   prints a structured plan to stdout
+ *   - `report` writes report files under `.sharkcraft/reports/`
+ *
+ * Never edits source.
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { auditProjectCoupling, renderProjectCouplingAuditMarkdown, renderProjectCouplingAuditText, } from '@shrkcrft/inspector';
+import { flagBool, flagString, flagList, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+function parseTokens(args) {
+    return flagList(args, 'token');
+}
+/**
+ * Exit-code logic is category-specific.
+ *
+ * `--fail-on engine` exits non-zero iff at least one hit is classified as
+ * `engine` (the file lives in engine source: `packages/`, `apps/`, `libs/`).
+ * Pack-target hits in localConfig and other categories no longer leak into
+ * the engine exit.
+ *
+ * `--fail-on any` exits non-zero iff there is any non-noise hit (anything
+ * outside fixture-only / docs-example / false-positive).
+ *
+ * `--fail-on never` always exits 0.
+ */
+function exitCodeForFailOn(failOn, report) {
+    if (failOn === 'never')
+        return 0;
+    if (failOn === 'engine') {
+        return report.hits.some((h) => h.externalizationTarget === 'engine') ? 1 : 0;
+    }
+    const anyReal = report.hits.some((h) => h.externalizationTarget !== 'false-positive' &&
+        h.externalizationTarget !== 'fixture-only' &&
+        h.externalizationTarget !== 'docs-example');
+    return anyReal ? 1 : 0;
+}
+function describeFailOn(failOn, report) {
+    if (failOn === 'never')
+        return 'fail-on=never → exit always 0.';
+    if (failOn === 'engine') {
+        const engineHits = report.hits.filter((h) => h.externalizationTarget === 'engine').length;
+        return `fail-on=engine → exit non-zero iff engine-category hits > 0 (current: ${engineHits}).`;
+    }
+    const real = report.hits.filter((h) => h.externalizationTarget !== 'false-positive' &&
+        h.externalizationTarget !== 'fixture-only' &&
+        h.externalizationTarget !== 'docs-example').length;
+    return `fail-on=any → exit non-zero iff non-noise hits > 0 (current: ${real}).`;
+}
+async function runAudit(args) {
+    const cwd = resolveCwd(args);
+    const tokens = parseTokens(args);
+    if (tokens.length === 0) {
+        process.stderr.write('Usage: shrk audit project-coupling audit --token <pat> [--token <pat> ...] [--fail-on engine|any|never] [--word-boundary|--no-word-boundary] [--format text|markdown|json] [--output <file>]\n');
+        return 2;
+    }
+    const wordBoundary = !flagBool(args, 'no-word-boundary');
+    const failOnArg = (flagString(args, 'fail-on') ?? 'engine').toLowerCase();
+    const failOn = failOnArg === 'any' || failOnArg === 'never' || failOnArg === 'engine'
+        ? failOnArg
+        : 'engine';
+    const report = auditProjectCoupling({ projectRoot: cwd, tokens, wordBoundary });
+    const format = flagString(args, 'format') ?? 'text';
+    const output = flagString(args, 'output');
+    if (output) {
+        const absOut = nodePath.isAbsolute(output) ? output : nodePath.resolve(cwd, output);
+        mkdirSync(nodePath.dirname(absOut), { recursive: true });
+        if (absOut.endsWith('.json'))
+            writeFileSync(absOut, JSON.stringify(report, null, 2) + '\n', 'utf8');
+        else if (absOut.endsWith('.md'))
+            writeFileSync(absOut, renderProjectCouplingAuditMarkdown(report), 'utf8');
+        else
+            writeFileSync(absOut, renderProjectCouplingAuditText(report), 'utf8');
+    }
+    if (flagBool(args, 'json') || format === 'json') {
+        process.stdout.write(asJson(report) + '\n');
+        return exitCodeForFailOn(failOn, report);
+    }
+    if (format === 'markdown') {
+        process.stdout.write(renderProjectCouplingAuditMarkdown(report));
+        process.stdout.write(`\n_${describeFailOn(failOn, report)}_\n`);
+        return exitCodeForFailOn(failOn, report);
+    }
+    process.stdout.write(renderProjectCouplingAuditText(report));
+    process.stdout.write(`  ${describeFailOn(failOn, report)}\n`);
+    return exitCodeForFailOn(failOn, report);
+}
+async function runPlan(args) {
+    const cwd = resolveCwd(args);
+    const tokens = parseTokens(args);
+    if (tokens.length === 0) {
+        process.stderr.write('Usage: shrk audit project-coupling plan --token <pat> ...\n');
+        return 2;
+    }
+    const wordBoundary = !flagBool(args, 'no-word-boundary');
+    const report = auditProjectCoupling({ projectRoot: cwd, tokens, wordBoundary });
+    process.stdout.write(renderProjectCouplingAuditMarkdown(report));
+    return 0;
+}
+async function runReport(args) {
+    const cwd = resolveCwd(args);
+    const tokens = parseTokens(args);
+    if (tokens.length === 0) {
+        process.stderr.write('Usage: shrk audit project-coupling report --token <pat> ...\n');
+        return 2;
+    }
+    const wordBoundary = !flagBool(args, 'no-word-boundary');
+    const report = auditProjectCoupling({ projectRoot: cwd, tokens, wordBoundary });
+    const outDir = nodePath.join(cwd, '.sharkcraft', 'reports');
+    mkdirSync(outDir, { recursive: true });
+    const base = `project-coupling-audit-${new Date().toISOString().replace(/[:.]/g, '-')}`;
+    writeFileSync(nodePath.join(outDir, `${base}.json`), JSON.stringify(report, null, 2) + '\n', 'utf8');
+    writeFileSync(nodePath.join(outDir, `${base}.md`), renderProjectCouplingAuditMarkdown(report), 'utf8');
+    process.stdout.write(`Wrote .sharkcraft/reports/${base}.{json,md}\n`);
+    return report.verdict === 'clean' ? 0 : 1;
+}
+export const auditProjectCouplingCommand = {
+    name: 'project-coupling',
+    description: 'Audit / plan / report project-specific coupling. Pass --token to scan for identifiers; the engine ships zero built-in tokens.',
+    usage: 'shrk audit project-coupling <audit|plan|report> --token <pat> [...]',
+    async run(args) {
+        const sub = args.positional[0];
+        args.positional = args.positional.slice(1);
+        if (sub === 'audit')
+            return runAudit(args);
+        if (sub === 'plan')
+            return runPlan(args);
+        if (sub === 'report')
+            return runReport(args);
+        process.stderr.write('Usage: shrk audit project-coupling <audit|plan|report> --token <pat>\n');
+        return 2;
+    },
+};

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

@@ -0,0 +1,7 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const biomeScaffoldCommand: ICommandHandler;
+export declare const biomeReportCommand: ICommandHandler;
+export declare const biomeRulesCommand: ICommandHandler;
+export declare const biomeExplainLimitationsCommand: ICommandHandler;
+export declare const biomeCommand: ICommandHandler;
+//# sourceMappingURL=biome.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"biome.command.d.ts","sourceRoot":"","sources":["../../src/commands/biome.command.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAwChC,eAAO,MAAM,oBAAoB,EAAE,eAuDlC,CAAC;AA+BF,eAAO,MAAM,kBAAkB,EAAE,eAkEhC,CAAC;AAkGF,eAAO,MAAM,iBAAiB,EAAE,eA4C/B,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,eAwC5C,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,eAkC1B,CAAC"}