@shrkcrft/cli 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/commands/apply.command.js

@@ -179,7 +179,7 @@ async function runApplyBatchFromCli(args, batchPath) {
 export const applyCommand = {
     name: 'apply',
     description: 'Apply a previously-saved generation plan (sharkcraft.plan/v1 JSON). The CLI is the only write path; MCP never writes. Plans that live under .sharkcraft/sessions/<id>/plans/ automatically update the session metadata (signature + divergence + applied + validation).',
-    usage: 'shrk [--cwd <dir>] apply <plan.json> [--session <id>] [--force] [--allow-divergent] [--verify-signature] [--require-signature] [--dry-run] [--validate] [--report] [--json] [--trace] [--explain-dispatch] | shrk apply --asset-preview <draft.ts> --target <file> [--write] [--allow-unknown-target] [--reason <text>] | shrk apply --batch <plan.json> [--allow-divergent] [--dry-run] [--json]',
+    usage: 'shrk [--cwd <dir>] apply <plan.json> [--session <id>] [--force] [--allow-divergent] [--verify-signature] [--require-signature] [--no-verify-signature] [--dry-run] [--validate] [--report] [--json] [--trace] [--explain-dispatch] | shrk apply --asset-preview <draft.ts> --target <file> [--write] [--allow-unknown-target] [--reason <text>] | shrk apply --batch <plan.json> [--allow-divergent] [--dry-run] [--json]',
     async run(args) {
         // Asset-preview flow: paste-with-review for authoring drafts.
         // Distinct from the plan-based apply path: takes a TS draft and a
@@ -222,7 +222,15 @@ export const applyCommand = {
         const explainOnly = flagBool(args, 'explain-dispatch');
         let signatureStatus = DevSessionSignatureStatus.NotChecked;
         let signatureMessage;
-        if (verifySig) {
+        // A plan that CARRIES a signature self-enforces verification: the signature
+        // is the producer's tamper-evidence declaration, so a signed plan must not
+        // apply unverified just because the caller forgot --verify-signature
+        // (contract: "Apply requires --verify-signature for signed plans"). A
+        // tampered/invalid signature then refuses below. `--no-verify-signature` is
+        // the explicit escape hatch for sign-here / apply-there-without-the-secret.
+        const isSigned = Boolean(saved.signature);
+        const skipSig = flagBool(args, 'no-verify-signature') && !verifySig;
+        if (verifySig || (isSigned && !skipSig)) {
             const result = verifyPlan(saved);
             if (result.ok === true) {
                 signatureStatus = DevSessionSignatureStatus.Verified;

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

@@ -0,0 +1,9 @@
+import { type ICommandHandler } from '../command-registry.js';
+/**
+ * `shrk arch` — semantic architecture checks on top of the code graph.
+ * Sub-verbs:
+ *   - shrk arch check               run all enabled checks (auto-loads sharkcraft/arch.ts)
+ *   - shrk arch check --contract X  point at an explicit contract file
+ */
+export declare const archCommand: ICommandHandler;
+//# sourceMappingURL=arch.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arch.command.d.ts","sourceRoot":"","sources":["../../src/commands/arch.command.ts"],"names":[],"mappings":"AASA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAIhC;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,eAoBzB,CAAC"}

package/dist/commands/arch.command.js

@@ -0,0 +1,186 @@
+import { existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { ArchReportStore, diffSnapshots, runArchCheck, } from '@shrkcrft/architecture-guard';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { safeImport } from '@shrkcrft/core';
+import { asJson, header, kv } from "../output/format-output.js";
+/**
+ * `shrk arch` — semantic architecture checks on top of the code graph.
+ * Sub-verbs:
+ *   - shrk arch check               run all enabled checks (auto-loads sharkcraft/arch.ts)
+ *   - shrk arch check --contract X  point at an explicit contract file
+ */
+export const archCommand = {
+    name: 'arch',
+    description: 'Architecture-guard checks: public-API misuse, barrel risks, cycle severity, project-specific contracts (sharkcraft/arch.ts auto-loaded). `shrk arch baseline <write|show|clear>` to gate doctor on a frozen baseline.',
+    usage: 'shrk arch check [--contract <path>] [--no-cycles] [--no-barrels] [--no-public-api] [--no-persist] [--json]\n         shrk arch baseline <write|show|clear> [--contract <path>] [--json]',
+    async run(args) {
+        const sub = args.positional[0];
+        if (sub === 'baseline') {
+            return runArchBaseline({
+                ...args,
+                positional: args.positional.slice(1),
+            });
+        }
+        if (sub !== 'check') {
+            process.stderr.write(this.usage + '\n');
+            return 2;
+        }
+        return runArchCheckCommand(args);
+    },
+};
+async function runArchCheckCommand(args) {
+    const cwd = resolveCwd(args);
+    const wantJson = flagBool(args, 'json');
+    const noCycles = flagBool(args, 'no-cycles');
+    const noBarrels = flagBool(args, 'no-barrels');
+    const noPublicApi = flagBool(args, 'no-public-api');
+    const noPersist = flagBool(args, 'no-persist');
+    const contractPath = flagString(args, 'contract');
+    const contract = await loadContract(cwd, contractPath);
+    const report = runArchCheck({
+        projectRoot: cwd,
+        ...(contract ? { contract } : {}),
+        enable: {
+            publicApi: !noPublicApi,
+            barrels: !noBarrels,
+            cycles: !noCycles,
+            contract: !!contract,
+        },
+    });
+    // Persist a compact snapshot so `shrk doctor` can compare against
+    // baseline without re-running the full check. `--no-persist` opts out
+    // (useful when scripting against many trees).
+    if (!noPersist) {
+        try {
+            new ArchReportStore(cwd).writeLast(report);
+        }
+        catch {
+            // best-effort
+        }
+    }
+    if (wantJson) {
+        process.stdout.write(asJson(report) + '\n');
+        return report.countsBySeverity.error > 0 ? 1 : 0;
+    }
+    printArchReport(report);
+    return report.countsBySeverity.error > 0 ? 1 : 0;
+}
+async function runArchBaseline(args) {
+    const cwd = resolveCwd(args);
+    const verb = args.positional[0] ?? 'show';
+    const store = new ArchReportStore(cwd);
+    const wantJson = flagBool(args, 'json');
+    if (verb === 'write') {
+        const contractPath = flagString(args, 'contract');
+        const contract = await loadContract(cwd, contractPath);
+        const report = runArchCheck({
+            projectRoot: cwd,
+            ...(contract ? { contract } : {}),
+        });
+        const snap = store.writeBaseline(report);
+        // Update last.json too so doctor's first delta read is meaningful.
+        store.writeLast(report);
+        if (wantJson) {
+            process.stdout.write(asJson({ wrote: store.baselinePath, baseline: snap }) + '\n');
+            return 0;
+        }
+        process.stdout.write(`Architecture baseline written → ${store.baselinePath}\n`);
+        process.stdout.write(`  ${snap.violationIds.length} violations (` +
+            `${snap.countsBySeverity.error} error, ` +
+            `${snap.countsBySeverity.warning} warning, ` +
+            `${snap.countsBySeverity.info} info) ` +
+            `across ${snap.filesAnalyzed} files.\n`);
+        return 0;
+    }
+    if (verb === 'show') {
+        const baseline = store.readBaseline();
+        if (!baseline) {
+            const msg = `No baseline at ${store.baselinePath}. Run \`shrk arch baseline write\` to freeze one.\n`;
+            if (wantJson) {
+                process.stdout.write(asJson({ baseline: null, path: store.baselinePath }) + '\n');
+                return 1;
+            }
+            process.stdout.write(msg);
+            return 1;
+        }
+        if (wantJson) {
+            process.stdout.write(asJson({ path: store.baselinePath, baseline }) + '\n');
+            return 0;
+        }
+        process.stdout.write(header('Architecture baseline'));
+        process.stdout.write(kv('path', store.baselinePath) + '\n');
+        process.stdout.write(kv('generated at', baseline.generatedAt) + '\n');
+        process.stdout.write(kv('files analyzed', String(baseline.filesAnalyzed)) + '\n');
+        process.stdout.write(kv('counts', `${baseline.countsBySeverity.error} error, ${baseline.countsBySeverity.warning} warning, ${baseline.countsBySeverity.info} info`) + '\n');
+        const last = store.readLast();
+        if (last) {
+            const delta = diffSnapshots(baseline, last);
+            process.stdout.write('\nDelta (last − baseline): ' +
+                `${delta.newViolationIds.length} new, ${delta.fixedViolationIds.length} fixed ` +
+                `(error ${delta.errorDelta >= 0 ? '+' : ''}${delta.errorDelta}, warning ${delta.warningDelta >= 0 ? '+' : ''}${delta.warningDelta})\n`);
+        }
+        else {
+            process.stdout.write('\n(no `last.json` yet — run `shrk arch check`.)\n');
+        }
+        return 0;
+    }
+    if (verb === 'clear') {
+        const removed = store.clearBaseline();
+        if (wantJson) {
+            process.stdout.write(asJson({ removed, path: store.baselinePath }) + '\n');
+            return 0;
+        }
+        process.stdout.write(removed ? `Baseline removed: ${store.baselinePath}\n` : 'No baseline to remove.\n');
+        return 0;
+    }
+    process.stderr.write('Usage: shrk arch baseline <write|show|clear> [--json]\n');
+    return 2;
+}
+function printArchReport(report) {
+    process.stdout.write(header('Architecture guard'));
+    process.stdout.write(kv('schema', report.schema) + '\n');
+    process.stdout.write(kv('files analyzed', String(report.filesAnalyzed)) + '\n');
+    process.stdout.write(kv('errors', String(report.countsBySeverity.error)) + '\n');
+    process.stdout.write(kv('warnings', String(report.countsBySeverity.warning)) + '\n');
+    if (report.violations.length === 0) {
+        process.stdout.write('\nNo violations.\n');
+    }
+    else {
+        process.stdout.write('\nViolations:\n');
+        for (const v of report.violations.slice(0, 80)) {
+            const lineSuffix = v.line ? `:${v.line}` : '';
+            process.stdout.write(`  [${v.severity}] [${v.kind}] ${v.file}${lineSuffix}\n    ${v.message}\n`);
+            if (v.suggestedFix)
+                process.stdout.write(`    → ${v.suggestedFix}\n`);
+        }
+        if (report.violations.length > 80) {
+            process.stdout.write(`  … (${report.violations.length - 80} more)\n`);
+        }
+    }
+    for (const d of report.diagnostics.slice(0, 5))
+        process.stdout.write(`! ${d}\n`);
+}
+async function loadContract(cwd, explicit) {
+    const candidate = explicit
+        ? nodePath.isAbsolute(explicit) ? explicit : nodePath.resolve(cwd, explicit)
+        : nodePath.join(cwd, 'sharkcraft', 'arch.ts');
+    if (!existsSync(candidate)) {
+        if (explicit)
+            process.stderr.write(`! contract file not found: ${candidate}\n`);
+        return undefined;
+    }
+    const result = await safeImport(candidate);
+    if (!result.ok) {
+        process.stderr.write(`! failed to load arch contract: ${result.error.message}\n`);
+        return undefined;
+    }
+    const mod = result.module;
+    const exported = mod.default ??
+        mod.contract;
+    if (!exported) {
+        process.stderr.write(`! arch contract module ${candidate} does not export a contract\n`);
+        return undefined;
+    }
+    return exported;
+}

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

@@ -1 +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"}
+{"version":3,"file":"ask.command.d.ts","sourceRoot":"","sources":["../../src/commands/ask.command.ts"],"names":[],"mappings":"AAOA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAIhC,eAAO,MAAM,UAAU,EAAE,eA6DxB,CAAC"}

package/dist/commands/ask.command.js

@@ -1,13 +1,13 @@
 import { inspectSharkcraft, buildProjectOverview, renderOverviewText } from '@shrkcrft/inspector';
 import { buildContext } from '@shrkcrft/context';
-import { ClaudeProvider, AiMessageRole, buildPromptMessages } from '@shrkcrft/ai';
+import { AiMessageRole, buildPromptMessages, selectAiProvider, } 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]',
+    description: 'Ask a question. Builds repository context, sends prompt to the local LLM (Ollama / llama.cpp).',
+    usage: 'shrk ask "<question>" [--max-tokens 3000] [--provider auto|ollama|llamacpp] [--model <id>] [--dry-run]',
     async run(args) {
         const question = args.positional.join(' ').trim();
         if (!question) {
@@ -16,6 +16,7 @@ export const askCommand = {
         }
         const maxTokens = flagNumber(args, 'max-tokens') ?? 3000;
         const model = flagString(args, 'model');
+        const providerKind = flagString(args, 'provider');
         const dryRun = flagBool(args, 'dry-run');
         const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
         const overview = buildProjectOverview(inspection.workspace, inspection.config?.projectName);
@@ -36,14 +37,14 @@ export const askCommand = {
             }
             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');
+        const selection = selectAiProvider(providerKind);
+        if (!selection.provider) {
+            process.stderr.write('No local LLM is ready. Start Ollama (`ollama serve`) or set LLAMACPP_MODEL_PATH=/path/to/model.gguf in .env. Use --dry-run to print the prompt instead.\n');
             return 1;
         }
-        const res = await provider.send({
+        if (model)
+            selection.provider.configure({ model });
+        const res = await selection.provider.send({
             messages: [...messages, { role: AiMessageRole.User, content: question }],
             maxTokens: 1024,
             model,

package/dist/commands/cache-align.command.d.ts

@@ -0,0 +1,12 @@
+import { type ICommandHandler } from '../command-registry.js';
+/**
+ * `shrk align` — replace volatile tokens (UUIDs/JWTs/timestamps/hashes) with
+ * stable placeholders so a provider KV-cache prefix stays steady across turns.
+ * Aligned text → stdout; the reversible map is written to `--map <path>` (or
+ * `.sharkcraft/cache-align/align.json`). Pass an existing `--map` to carry
+ * ordinals forward. `shrk unalign` restores.
+ */
+export declare const alignCommand: ICommandHandler;
+/** `shrk unalign` — the restore half: turn placeholders back into originals. */
+export declare const unalignCommand: ICommandHandler;
+//# sourceMappingURL=cache-align.command.d.ts.map

package/dist/commands/cache-align.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-align.command.d.ts","sourceRoot":"","sources":["../../src/commands/cache-align.command.ts"],"names":[],"mappings":"AAOA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAkBhC;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,EAAE,eA4B1B,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,cAAc,EAAE,eAuB5B,CAAC"}

package/dist/commands/cache-align.command.js

@@ -0,0 +1,78 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { alignVolatileTokens, restoreVolatileTokens, } from '@shrkcrft/compress';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+function readInput(args) {
+    const positional = args.positional[0];
+    const useStdin = flagBool(args, 'stdin') || positional === undefined || positional === '-';
+    return useStdin ? readFileSync(0, 'utf8') : readFileSync(positional, 'utf8');
+}
+function loadMap(path) {
+    if (!path || !existsSync(path))
+        return undefined;
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (typeof parsed === 'object' && parsed !== null && Array.isArray(parsed.bindings)) {
+        return parsed;
+    }
+    return undefined;
+}
+/**
+ * `shrk align` — replace volatile tokens (UUIDs/JWTs/timestamps/hashes) with
+ * stable placeholders so a provider KV-cache prefix stays steady across turns.
+ * Aligned text → stdout; the reversible map is written to `--map <path>` (or
+ * `.sharkcraft/cache-align/align.json`). Pass an existing `--map` to carry
+ * ordinals forward. `shrk unalign` restores.
+ */
+export const alignCommand = {
+    name: 'align',
+    description: 'Replace volatile tokens with stable placeholders for KV-cache prefix stability; reversible via `shrk unalign`.',
+    usage: 'shrk [--cwd <dir>] align [<file>|-] [--stdin] [--map <path>] [--json]',
+    run(args) {
+        const cwd = resolveCwd(args);
+        let content;
+        try {
+            content = readInput(args);
+        }
+        catch (e) {
+            process.stderr.write(`align: cannot read input — ${e.message}\n`);
+            return 1;
+        }
+        const mapPath = flagString(args, 'map') ?? nodePath.join(cwd, '.sharkcraft', 'cache-align', 'align.json');
+        const result = alignVolatileTokens(content, loadMap(mapPath));
+        mkdirSync(nodePath.dirname(mapPath), { recursive: true });
+        writeFileSync(mapPath, JSON.stringify(result.map, null, 2), 'utf8');
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({ aligned: result.aligned, map: result.map, replaced: result.replaced }) + '\n');
+            return 0;
+        }
+        process.stdout.write(result.aligned + '\n');
+        process.stderr.write(`aligned: ${result.replaced} token(s) replaced · map → ${mapPath}\n`);
+        return 0;
+    },
+};
+/** `shrk unalign` — the restore half: turn placeholders back into originals. */
+export const unalignCommand = {
+    name: 'unalign',
+    description: 'Restore the original volatile tokens in aligned text using its `--map`.',
+    usage: 'shrk [--cwd <dir>] unalign [<file>|-] [--stdin] --map <path>',
+    run(args) {
+        const cwd = resolveCwd(args);
+        const mapPath = flagString(args, 'map') ?? nodePath.join(cwd, '.sharkcraft', 'cache-align', 'align.json');
+        const map = loadMap(mapPath);
+        if (!map) {
+            process.stderr.write(`unalign: no alignment map at "${mapPath}" (pass --map <path>).\n`);
+            return 1;
+        }
+        let content;
+        try {
+            content = readInput(args);
+        }
+        catch (e) {
+            process.stderr.write(`unalign: cannot read input — ${e.message}\n`);
+            return 1;
+        }
+        process.stdout.write(restoreVolatileTokens(content, map) + '\n');
+        return 0;
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"check.command.d.ts","sourceRoot":"","sources":["../../src/commands/check.command.ts"],"names":[],"mappings":"AAmBA,OAAO,EAML,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA+iBhC,eAAO,MAAM,YAAY,EAAE,eAmD1B,CAAC"}
+{"version":3,"file":"check.command.d.ts","sourceRoot":"","sources":["../../src/commands/check.command.ts"],"names":[],"mappings":"AAmBA,OAAO,EAML,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAikBhC,eAAO,MAAM,YAAY,EAAE,eA0D1B,CAAC"}

package/dist/commands/check.command.js

@@ -3,6 +3,7 @@ import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
 import * as nodePath from 'node:path';
 import { flagBool, flagNumber, flagString, flagVars, resolveCwd, } from "../command-registry.js";
 import { asJson, header, kv } from "../output/format-output.js";
+import { maybeRunInWatchMode } from "../output/watch-loop.js";
 import { validateTemplateVariables } from '@shrkcrft/templates';
 import { FileChangeType, planGeneration } from '@shrkcrft/generator';
 import { evaluateBoundaries, loadTsconfigPaths, scanImports, summarizeImports, } from '@shrkcrft/boundaries';
@@ -305,6 +306,22 @@ function readChangedScopeOptions(args, cwd) {
     return out;
 }
 async function checkBoundaries(args) {
+    const watchExit = await maybeRunInWatchMode(args, checkBoundariesOnce, {
+        defaultPaths: BOUNDARIES_DEFAULT_WATCH_PATHS,
+    });
+    if (watchExit !== null)
+        return watchExit;
+    return checkBoundariesOnce(args);
+}
+const BOUNDARIES_DEFAULT_WATCH_PATHS = [
+    'sharkcraft',
+    'packages',
+    'apps',
+    'libs',
+    'src',
+    'tools',
+];
+async function checkBoundariesOnce(args) {
     const cwd = resolveCwd(args);
     const inspection = await inspectSharkcraft({ cwd });
     const rules = inspection.boundaryRegistry.list();
@@ -504,8 +521,8 @@ async function checkBoundaries(args) {
 // ────────────────────────────────────────────────────────────────────────
 export const checkCommand = {
     name: 'check',
-    description: 'Run SharkCraft-level validation across knowledge / rules / templates / pipelines / packs / action hints / doctor.',
-    usage: 'shrk [--cwd <dir>] check [packs|pipelines|knowledge|generation] [--strict] [--min-score <0-100>] [--json]',
+    description: 'Run SharkCraft-level validation across knowledge / rules / templates / pipelines / packs / action hints / doctor. `check boundaries [--watch [--paths a,b] [--debounce N] [--once]]` re-runs the boundary scan on file changes.',
+    usage: 'shrk [--cwd <dir>] check [packs|pipelines|knowledge|generation|boundaries|imports] [--strict] [--min-score <0-100>] [--json] [--watch [--paths <list>] [--debounce N] [--once]]',
     async run(args) {
         const sub = args.positional[0];
         if (sub === 'generation')
@@ -517,6 +534,13 @@ export const checkCommand = {
         if (sub === 'registry-lifecycle') {
             const cwd = resolveCwd(args);
             const { buildRegistryLifecycleReport, renderRegistryLifecycleReportText } = await import('@shrkcrft/inspector');
+            // The scan is a single synchronous pass with no streamed output; on a
+            // large repo it can run for tens of seconds. Without a heartbeat that
+            // silence reads as a hang, so announce the work first (human path only —
+            // JSON consumers want a clean stdout).
+            if (!flagBool(args, 'json')) {
+                process.stderr.write('⏳ Scanning source + registries for lifecycle coverage (can take a while on large repos)…\n');
+            }
             const report = buildRegistryLifecycleReport({ projectRoot: cwd });
             if (flagBool(args, 'json')) {
                 process.stdout.write(asJson(report) + '\n');

package/dist/commands/code-intel.command.d.ts

@@ -0,0 +1,18 @@
+import { type ICommandHandler } from '../command-registry.js';
+/**
+ * `shrk code-intel` — one-shot view of the 14 code-intelligence
+ * doctor checks. Independent of `shrk doctor` so callers (agents,
+ * inner-loop scripts, the dashboard) can pull just this section
+ * without parsing through unrelated config / knowledge findings.
+ *
+ * Output modes:
+ *   - text (default): grouped by severity, one line per finding.
+ *   - --json: machine-readable, including the full check list.
+ *   - --markdown: PR-comment-ready rendering.
+ *
+ * Filters:
+ *   - --only ok,warning,error,info — restrict severities.
+ *   - --check <id>                 — show only one check id.
+ */
+export declare const codeIntelCommand: ICommandHandler;
+//# sourceMappingURL=code-intel.command.d.ts.map

package/dist/commands/code-intel.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-intel.command.d.ts","sourceRoot":"","sources":["../../src/commands/code-intel.command.ts"],"names":[],"mappings":"AAKA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAGhC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,EAAE,eAuE9B,CAAC"}

package/dist/commands/code-intel.command.js

@@ -0,0 +1,146 @@
+import { buildCodeIntelligenceChecks, DoctorSeverity, } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson, header, kv } from "../output/format-output.js";
+/**
+ * `shrk code-intel` — one-shot view of the 14 code-intelligence
+ * doctor checks. Independent of `shrk doctor` so callers (agents,
+ * inner-loop scripts, the dashboard) can pull just this section
+ * without parsing through unrelated config / knowledge findings.
+ *
+ * Output modes:
+ *   - text (default): grouped by severity, one line per finding.
+ *   - --json: machine-readable, including the full check list.
+ *   - --markdown: PR-comment-ready rendering.
+ *
+ * Filters:
+ *   - --only ok,warning,error,info — restrict severities.
+ *   - --check <id>                 — show only one check id.
+ */
+export const codeIntelCommand = {
+    name: 'code-intel',
+    description: 'One-shot view of code-intelligence doctor checks (graph, rule-graph, api-surface, quality-gate, migrations, architecture, impact, framework, structural-search, context-planner). Read-only.',
+    usage: 'shrk [--cwd <dir>] code-intel [--json] [--markdown] [--only ok,warning,error,info] [--check <id>] [--stale-days N]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const wantJson = flagBool(args, 'json');
+        const wantMarkdown = flagBool(args, 'markdown');
+        const onlyRaw = flagString(args, 'only');
+        const checkId = flagString(args, 'check');
+        const staleDaysRaw = flagString(args, 'stale-days');
+        const staleDays = staleDaysRaw ? Number.parseInt(staleDaysRaw, 10) : undefined;
+        const options = {};
+        if (typeof staleDays === 'number' && Number.isFinite(staleDays) && staleDays > 0) {
+            options.staleThresholdDays = staleDays;
+        }
+        let checks = buildCodeIntelligenceChecks(cwd, options);
+        if (checkId) {
+            checks = checks.filter((c) => c.id === checkId);
+        }
+        if (onlyRaw) {
+            const allowed = new Set(onlyRaw
+                .split(',')
+                .map((s) => s.trim().toLowerCase())
+                .filter((s) => s.length > 0));
+            checks = checks.filter((c) => allowed.has(severityKey(c.severity)));
+        }
+        const summary = summarize(checks);
+        if (wantJson) {
+            process.stdout.write(asJson({
+                schema: 'sharkcraft.code-intelligence-state/v1',
+                totalChecks: checks.length,
+                summary,
+                checks,
+            }) + '\n');
+            return exitCode(summary);
+        }
+        if (wantMarkdown) {
+            process.stdout.write(renderMarkdown(checks, summary));
+            return exitCode(summary);
+        }
+        process.stdout.write(header('Code-intelligence state'));
+        process.stdout.write(kv('summary', `ok=${summary.ok} info=${summary.info} warnings=${summary.warnings} errors=${summary.errors}`) + '\n');
+        if (checks.length === 0) {
+            process.stdout.write('\nNo code-intelligence state on disk yet — opt in by running `shrk graph index`.\n');
+            return 0;
+        }
+        process.stdout.write('\n');
+        for (const c of checks) {
+            const icon = severityIcon(c.severity);
+            const advisory = c.advisory ? ' (advisory)' : '';
+            process.stdout.write(`${icon} ${c.id}${advisory}\n`);
+            process.stdout.write(`   ${c.title}\n`);
+            process.stdout.write(`   ${c.message}\n`);
+            if (c.fix)
+                process.stdout.write(`   → ${c.fix}\n`);
+            if (c.whyThisMatters)
+                process.stdout.write(`   why: ${c.whyThisMatters}\n`);
+            process.stdout.write('\n');
+        }
+        return exitCode(summary);
+    },
+};
+function severityKey(severity) {
+    return severity;
+}
+function severityIcon(severity) {
+    switch (severity) {
+        case DoctorSeverity.Ok:
+            return '✓';
+        case DoctorSeverity.Info:
+            return 'ℹ';
+        case DoctorSeverity.Warning:
+            return '⚠';
+        case DoctorSeverity.Error:
+            return '✗';
+    }
+}
+function summarize(checks) {
+    const s = { ok: 0, info: 0, warnings: 0, errors: 0 };
+    for (const c of checks) {
+        if (c.severity === DoctorSeverity.Ok)
+            s.ok += 1;
+        else if (c.severity === DoctorSeverity.Info)
+            s.info += 1;
+        else if (c.severity === DoctorSeverity.Warning)
+            s.warnings += 1;
+        else if (c.severity === DoctorSeverity.Error)
+            s.errors += 1;
+    }
+    return s;
+}
+function exitCode(summary) {
+    // Exit 1 if any non-advisory warning or error remains. Advisory
+    // warnings are reported but never fail the command — they're hints,
+    // not blockers (same contract as `shrk doctor`).
+    return summary.errors > 0 ? 1 : 0;
+}
+function renderMarkdown(checks, summary) {
+    const lines = [];
+    lines.push('# SharkCraft code-intelligence state');
+    lines.push('');
+    lines.push('| ok | info | warnings | errors |');
+    lines.push('|---|---|---|---|');
+    lines.push(`| ${summary.ok} | ${summary.info} | ${summary.warnings} | ${summary.errors} |`);
+    lines.push('');
+    if (checks.length === 0) {
+        lines.push('_(no code-intelligence state on disk yet)_');
+        return lines.join('\n') + '\n';
+    }
+    for (const c of checks) {
+        const icon = severityIcon(c.severity);
+        const advisory = c.advisory ? ' _(advisory)_' : '';
+        lines.push(`### ${icon} \`${c.id}\` — ${c.title}${advisory}`);
+        lines.push('');
+        lines.push(c.message);
+        if (c.fix) {
+            lines.push('');
+            lines.push(`**Fix:** ${c.fix}`);
+        }
+        if (c.whyThisMatters) {
+            lines.push('');
+            lines.push(`**Why:** ${c.whyThisMatters}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n') + '\n';
+}

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

@@ -1 +1 @@
-{"version":3,"file":"codemod.command.d.ts","sourceRoot":"","sources":["../../src/commands/codemod.command.ts"],"names":[],"mappings":"AAgBA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAoDhC,eAAO,MAAM,cAAc,EAAE,eAoE5B,CAAC"}
+{"version":3,"file":"codemod.command.d.ts","sourceRoot":"","sources":["../../src/commands/codemod.command.ts"],"names":[],"mappings":"AAiBA,OAAO,EAML,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAuEhC,eAAO,MAAM,cAAc,EAAE,eAsE5B,CAAC"}