@shrkcrft/cli 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/commands/context.command.js

@@ -1,5 +1,8 @@
 import { entrypointBanner, inspectSharkcraft } from '@shrkcrft/inspector';
 import { buildContext } from '@shrkcrft/context';
+import { loadIntentBenchmark, runIntentBenchmark, STARTER_INTENT_BENCHMARK, writeBenchmarkRun, } from '@shrkcrft/context-planner';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
 import { buildUniversalSearch, explainTaskRouting, recommendCommands, renderOverviewText, buildProjectOverview, } from '@shrkcrft/inspector';
 import { flagBool, flagNumber, flagString, flagList, resolveCwd, } from "../command-registry.js";
 import { asJson, header } from "../output/format-output.js";
@@ -19,6 +22,10 @@ export const contextCommand = {
                 return contextRefreshCommand.run(sliced);
             return contextStatusCommand.run(sliced);
         }
+        if (sub === 'benchmark') {
+            const sliced = { ...args, positional: args.positional.slice(1) };
+            return runContextBenchmark(sliced);
+        }
         const task = flagString(args, 'task');
         if (!task) {
             process.stderr.write('Missing --task\n');
@@ -118,3 +125,85 @@ export const contextCommand = {
         return 0;
     },
 };
+async function runContextBenchmark(args) {
+    const cwd = resolveCwd(args);
+    const wantJson = flagBool(args, 'json');
+    // `shrk context benchmark seed` writes a starter fixture to
+    // sharkcraft/intent-benchmark.json. Useful first step for adopting
+    // the surface — fixture is opinionated but small and easy to prune.
+    if (args.positional[0] === 'seed') {
+        return runContextBenchmarkSeed(cwd, args);
+    }
+    const noPersist = flagBool(args, 'no-persist');
+    const benchmark = loadIntentBenchmark(cwd);
+    if (!benchmark) {
+        const msg = `No benchmark at sharkcraft/intent-benchmark.json. Create one with schema "sharkcraft.intent-benchmark/v1" and a "cases" array of { task, expected } entries.\n`;
+        if (wantJson) {
+            process.stdout.write(asJson({ ok: false, error: 'benchmark-missing' }) + '\n');
+            return 1;
+        }
+        process.stderr.write(msg);
+        return 1;
+    }
+    const run = runIntentBenchmark(benchmark);
+    if (!noPersist) {
+        try {
+            writeBenchmarkRun(cwd, run);
+        }
+        catch {
+            // best-effort
+        }
+    }
+    if (wantJson) {
+        process.stdout.write(asJson(run) + '\n');
+        return run.failed === 0 ? 0 : 1;
+    }
+    process.stdout.write(header('Intent classifier benchmark'));
+    process.stdout.write(`  total       ${run.total}\n`);
+    process.stdout.write(`  passed      ${run.passed}\n`);
+    process.stdout.write(`  failed      ${run.failed}\n`);
+    process.stdout.write(`  accuracy    ${Math.round(run.accuracy * 1000) / 10}%\n`);
+    const failures = run.cases.filter((c) => !c.passed);
+    if (failures.length > 0) {
+        process.stdout.write('\nFailures:\n');
+        for (const c of failures.slice(0, 20)) {
+            process.stdout.write(`  ✗ task="${truncateTask(c.task)}"  expected=${c.expected}  actual=${c.actual}\n`);
+        }
+        if (failures.length > 20) {
+            process.stdout.write(`  … (${failures.length - 20} more)\n`);
+        }
+    }
+    return run.failed === 0 ? 0 : 1;
+}
+function truncateTask(s) {
+    if (s.length <= 60)
+        return s;
+    return s.slice(0, 57) + '…';
+}
+function runContextBenchmarkSeed(cwd, args) {
+    const wantJson = flagBool(args, 'json');
+    const force = flagBool(args, 'force');
+    const target = nodePath.join(cwd, 'sharkcraft', 'intent-benchmark.json');
+    if (existsSync(target) && !force) {
+        const msg = `${target} already exists. Use --force to overwrite.\n`;
+        if (wantJson) {
+            process.stdout.write(asJson({ ok: false, error: 'exists', path: target }) + '\n');
+            return 1;
+        }
+        process.stderr.write(msg);
+        return 1;
+    }
+    mkdirSync(nodePath.dirname(target), { recursive: true });
+    writeFileSync(target, JSON.stringify(STARTER_INTENT_BENCHMARK, null, 2), 'utf8');
+    if (wantJson) {
+        process.stdout.write(asJson({
+            ok: true,
+            wrote: target,
+            cases: STARTER_INTENT_BENCHMARK.cases.length,
+        }) + '\n');
+        return 0;
+    }
+    process.stdout.write(`Seeded ${STARTER_INTENT_BENCHMARK.cases.length} starter intent case(s) → ${target}\n`);
+    process.stdout.write('Run `shrk context benchmark` to record accuracy.\n');
+    return 0;
+}

package/dist/commands/diff-check.command.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `shrk diff-check` — agent self-validation after edits.
+ *
+ * The story this command tells:
+ *   1. An AI agent (Claude Code, Cursor, etc.) makes some file changes.
+ *   2. Before declaring "done", the agent runs `shrk diff-check`.
+ *   3. The command scopes both the boundary check and the
+ *      import-hygiene check to only the files the agent touched in the
+ *      current git diff.
+ *   4. The output is a single agent-friendly JSON envelope with a
+ *      verdict (ok / warnings / errors) and a one-line next action.
+ *
+ * Why a new command instead of "just run `shrk check boundaries
+ * --changed-only` and `shrk check imports --changed-only`":
+ *
+ *   - One command instead of two — agents reliably run the *one* tool
+ *     they're told to run; chained-command workflows get skipped.
+ *   - One verdict — no need to OR two separate JSON outputs.
+ *   - Stable, narrow schema — designed for agent consumption, not
+ *     human terminals. Won't grow flags over time.
+ *   - Concrete `nextAction` line — the agent knows exactly what to do
+ *     next (declare done, fix N things, or re-run after a manual fix).
+ *
+ * This is a pure composer — all real logic stays in
+ * `@shrkcrft/inspector` and `@shrkcrft/boundaries`. We just stitch
+ * their outputs together with consistent scoping.
+ */
+import { type ICommandHandler } from '../command-registry.js';
+export declare const diffCheckCommand: ICommandHandler;
+//# sourceMappingURL=diff-check.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diff-check.command.d.ts","sourceRoot":"","sources":["../../src/commands/diff-check.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAcH,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA0GhC,eAAO,MAAM,gBAAgB,EAAE,eAiI9B,CAAC"}

package/dist/commands/diff-check.command.js

@@ -0,0 +1,210 @@
+/**
+ * `shrk diff-check` — agent self-validation after edits.
+ *
+ * The story this command tells:
+ *   1. An AI agent (Claude Code, Cursor, etc.) makes some file changes.
+ *   2. Before declaring "done", the agent runs `shrk diff-check`.
+ *   3. The command scopes both the boundary check and the
+ *      import-hygiene check to only the files the agent touched in the
+ *      current git diff.
+ *   4. The output is a single agent-friendly JSON envelope with a
+ *      verdict (ok / warnings / errors) and a one-line next action.
+ *
+ * Why a new command instead of "just run `shrk check boundaries
+ * --changed-only` and `shrk check imports --changed-only`":
+ *
+ *   - One command instead of two — agents reliably run the *one* tool
+ *     they're told to run; chained-command workflows get skipped.
+ *   - One verdict — no need to OR two separate JSON outputs.
+ *   - Stable, narrow schema — designed for agent consumption, not
+ *     human terminals. Won't grow flags over time.
+ *   - Concrete `nextAction` line — the agent knows exactly what to do
+ *     next (declare done, fix N things, or re-run after a manual fix).
+ *
+ * This is a pure composer — all real logic stays in
+ * `@shrkcrft/inspector` and `@shrkcrft/boundaries`. We just stitch
+ * their outputs together with consistent scoping.
+ */
+import { buildImportHygieneReport, filterViolationsToChangedScope, inspectSharkcraft, resolveChangedFiles, } from '@shrkcrft/inspector';
+import { evaluateBoundaries, loadTsconfigPaths, scanImports, } from '@shrkcrft/boundaries';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson, bullet, header, kv } from "../output/format-output.js";
+const SCHEMA = 'sharkcraft.diff-check/v1';
+function resolveScope(args, cwd) {
+    const staged = flagBool(args, 'staged');
+    const since = flagString(args, 'since');
+    const filesRaw = flagString(args, 'files');
+    const files = filesRaw
+        ? filesRaw.split(',').map((s) => s.trim()).filter((s) => s.length > 0)
+        : [];
+    if (files.length > 0) {
+        return { mode: 'files', options: { projectRoot: cwd, files } };
+    }
+    if (staged) {
+        return { mode: 'staged', options: { projectRoot: cwd, staged: true } };
+    }
+    if (since) {
+        return { mode: 'since', options: { projectRoot: cwd, since } };
+    }
+    // Default: worktree (== `--changed-only` from `shrk check boundaries`).
+    return {
+        mode: 'worktree',
+        options: { projectRoot: cwd, includeWorktree: true },
+    };
+}
+function deriveVerdict(env) {
+    const bErr = env.boundaries.counts.error;
+    const bWarn = env.boundaries.counts.warning;
+    const iErr = env.imports.verdict === 'errors' ? (env.imports.counts.error ?? env.imports.findings.length) : 0;
+    const iWarn = env.imports.verdict === 'warnings' ? (env.imports.counts.warning ?? env.imports.findings.length) : 0;
+    if (env.scope.fileCount === 0) {
+        return {
+            verdict: 'ok',
+            summary: 'No files changed in the current diff scope.',
+            nextAction: 'Nothing to check. If you expected changes, verify your `--staged` / `--since <ref>` flag or save your edits first.',
+        };
+    }
+    if (bErr > 0 || iErr > 0) {
+        const parts = [];
+        if (bErr > 0)
+            parts.push(`${bErr} boundary violation${bErr === 1 ? '' : 's'}`);
+        if (iErr > 0)
+            parts.push(`${iErr} import-hygiene error${iErr === 1 ? '' : 's'}`);
+        return {
+            verdict: 'errors',
+            summary: `Diff fails the gate: ${parts.join(', ')}.`,
+            nextAction: 'Fix every error in `boundaries.violations` and `imports.findings` (look at each entry\'s `suggestedFix` line), then re-run `shrk diff-check`.',
+        };
+    }
+    if (bWarn > 0 || iWarn > 0) {
+        const parts = [];
+        if (bWarn > 0)
+            parts.push(`${bWarn} boundary warning${bWarn === 1 ? '' : 's'}`);
+        if (iWarn > 0)
+            parts.push(`${iWarn} import-hygiene warning${iWarn === 1 ? '' : 's'}`);
+        return {
+            verdict: 'warnings',
+            summary: `Diff passes the gate with ${parts.join(', ')}.`,
+            nextAction: 'Safe to declare done. Review warnings if the diff touches a sensitive area; otherwise these are non-blocking.',
+        };
+    }
+    return {
+        verdict: 'ok',
+        summary: `Diff passes the gate (${env.scope.fileCount} file${env.scope.fileCount === 1 ? '' : 's'}, 0 violations).`,
+        nextAction: 'Safe to declare done.',
+    };
+}
+export const diffCheckCommand = {
+    name: 'diff-check',
+    description: 'Self-check the current git diff against this project\'s boundary + import-hygiene rules. Single-call composite of `shrk check boundaries --changed-only` + `shrk check imports --changed-only`, with one verdict and one nextAction line. Designed for AI agents to run after editing — pass --json for the structured envelope.',
+    usage: 'shrk [--cwd <dir>] diff-check [--staged | --since <ref> | --files a.ts,b.ts] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const wantJson = flagBool(args, 'json');
+        const { mode, options: scopeOptions } = resolveScope(args, cwd);
+        // 1. Resolve the changed file set once. Both engines re-use it.
+        const changed = resolveChangedFiles(scopeOptions);
+        const changedFiles = changed.files;
+        // 2. Boundary engine — only if rules exist.
+        const inspection = await inspectSharkcraft({ cwd });
+        const rules = inspection.boundaryRegistry.list();
+        let boundaryBlock = {
+            ran: false,
+            rulesEvaluated: 0,
+            counts: { error: 0, warning: 0, info: 0 },
+            violations: [],
+        };
+        if (rules.length > 0 && changedFiles.length > 0) {
+            const scan = scanImports({ projectRoot: cwd });
+            const tsconfigPaths = loadTsconfigPaths(cwd);
+            const evalResult = evaluateBoundaries(scan, rules, {
+                ...(tsconfigPaths.aliases.size > 0 ? { tsconfigPaths } : {}),
+            });
+            const filtered = filterViolationsToChangedScope(evalResult.violations, scopeOptions);
+            boundaryBlock = {
+                ran: true,
+                rulesEvaluated: evalResult.rulesEvaluated,
+                counts: {
+                    error: filtered.includedViolations.filter((v) => v.severity === 'error').length,
+                    warning: filtered.includedViolations.filter((v) => v.severity === 'warning').length,
+                    info: filtered.includedViolations.filter((v) => v.severity === 'info').length,
+                },
+                violations: filtered.includedViolations,
+            };
+        }
+        else if (rules.length > 0 && changedFiles.length === 0) {
+            boundaryBlock = { ...boundaryBlock, ran: true, rulesEvaluated: rules.length };
+        }
+        // 3. Import-hygiene engine — always runs, but scoped to changed files.
+        let importsBlock = {
+            ran: false,
+            verdict: 'skipped',
+            counts: {},
+            findings: [],
+        };
+        if (changedFiles.length > 0) {
+            const report = buildImportHygieneReport(cwd, { files: changedFiles });
+            importsBlock = {
+                ran: true,
+                verdict: report.verdict,
+                counts: report.counts ?? {},
+                findings: report.findings,
+            };
+        }
+        // 4. Build envelope + derive verdict.
+        const partial = {
+            schema: SCHEMA,
+            generatedAt: new Date().toISOString(),
+            scope: {
+                mode,
+                files: changedFiles,
+                fileCount: changedFiles.length,
+            },
+            boundaries: boundaryBlock,
+            imports: importsBlock,
+        };
+        const { verdict, summary, nextAction } = deriveVerdict(partial);
+        const envelope = { ...partial, verdict, summary, nextAction };
+        // 5. Render.
+        if (wantJson) {
+            process.stdout.write(asJson(envelope) + '\n');
+            return verdict === 'errors' ? 1 : 0;
+        }
+        process.stdout.write(header('Diff check'));
+        process.stdout.write(kv('scope', `${envelope.scope.mode} (${envelope.scope.fileCount} file${envelope.scope.fileCount === 1 ? '' : 's'})`) + '\n');
+        process.stdout.write(kv('boundaries', envelope.boundaries.ran
+            ? `${envelope.boundaries.counts.error} errors, ${envelope.boundaries.counts.warning} warnings`
+            : '(no rules configured or no scoped files)') + '\n');
+        process.stdout.write(kv('imports', envelope.imports.ran
+            ? `verdict=${envelope.imports.verdict} (${envelope.imports.findings.length} finding${envelope.imports.findings.length === 1 ? '' : 's'})`
+            : '(no scoped files)') + '\n');
+        process.stdout.write(kv('verdict', envelope.verdict) + '\n');
+        process.stdout.write('\n');
+        process.stdout.write(envelope.summary + '\n');
+        if (envelope.boundaries.violations.length > 0) {
+            process.stdout.write('\nBoundary violations:\n');
+            for (const v of envelope.boundaries.violations.slice(0, 10)) {
+                const file = String(v.file ?? '');
+                const rule = String(v.ruleId ?? '');
+                const fix = v.suggestedFix ? ` — ${String(v.suggestedFix)}` : '';
+                process.stdout.write(bullet(`${rule} in ${file}${fix}`) + '\n');
+            }
+            if (envelope.boundaries.violations.length > 10) {
+                process.stdout.write(`  … and ${envelope.boundaries.violations.length - 10} more (pass --json for full list).\n`);
+            }
+        }
+        if (envelope.imports.findings.length > 0) {
+            process.stdout.write('\nImport findings:\n');
+            for (const f of envelope.imports.findings.slice(0, 10)) {
+                const file = String(f.path ?? f.file ?? '');
+                const kind = String(f.kind ?? '');
+                process.stdout.write(bullet(`${kind} in ${file}`) + '\n');
+            }
+            if (envelope.imports.findings.length > 10) {
+                process.stdout.write(`  … and ${envelope.imports.findings.length - 10} more (pass --json for full list).\n`);
+            }
+        }
+        process.stdout.write(`\nNext: ${envelope.nextAction}\n`);
+        return verdict === 'errors' ? 1 : 0;
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"doctor.command.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.command.ts"],"names":[],"mappings":"AAqBA,OAAO,EAML,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAwJhC,eAAO,MAAM,aAAa,EAAE,eAW3B,CAAC;AA+ZF,eAAO,MAAM,qBAAqB,EAAE,eAmCnC,CAAC;AAuDF,eAAO,MAAM,yBAAyB,EAAE,eAavC,CAAC;AAIF,eAAO,MAAM,wBAAwB,EAAE,eA2CtC,CAAC;AAgCF,eAAO,MAAM,6BAA6B,EAAE,eAa3C,CAAC"}
+{"version":3,"file":"doctor.command.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.command.ts"],"names":[],"mappings":"AAqBA,OAAO,EAML,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA0JhC,eAAO,MAAM,aAAa,EAAE,eAW3B,CAAC;AA+bF,eAAO,MAAM,qBAAqB,EAAE,eAmCnC,CAAC;AAuDF,eAAO,MAAM,yBAAyB,EAAE,eAavC,CAAC;AAIF,eAAO,MAAM,wBAAwB,EAAE,eA2CtC,CAAC;AAgCF,eAAO,MAAM,6BAA6B,EAAE,eAa3C,CAAC"}

package/dist/commands/doctor.command.js

@@ -38,7 +38,7 @@ function describeStrictMode(mode) {
         case 'all':
             return 'strict=all (every warning fails)';
         case 'warnings':
-            return 'strict=warnings (structural warnings fail, hint-quality excluded)';
+            return 'strict=warnings (structural warnings fail, advisory excluded)';
         case 'errors':
             return 'strict=errors (only errors fail)';
         case 'off':
@@ -59,8 +59,10 @@ function evaluateStrict(mode, checks, errorCount) {
     for (const c of checks) {
         if (c.severity !== DoctorSeverity.Warning)
             continue;
-        const isHintQuality = c.id.startsWith('actionhints-');
-        if (mode === 'warnings' && isHintQuality) {
+        // `--strict=warnings` excludes anything the inspector flagged as
+        // advisory (action-hint quality today, any future advisory category
+        // tomorrow). `--strict=all` counts every warning, advisory or not.
+        if (mode === 'warnings' && c.advisory === true) {
             excludedWarnings += 1;
         }
         else {
@@ -74,7 +76,7 @@ function evaluateStrict(mode, checks, errorCount) {
         excludedWarnings,
         reason: mode === 'all'
             ? 'any warning'
-            : 'structural warnings only (hint-quality excluded)',
+            : 'structural warnings only (advisory excluded)',
     };
 }
 function buildFilterOptions(args, suppressions) {
@@ -420,7 +422,7 @@ async function doctorCommandImpl(args) {
     void saveDoctorSuppressions;
     void existsSync;
     if (strictMode === 'warnings' && strictEval.excludedWarnings > 0) {
-        process.stdout.write(`  (strict=warnings excluded ${strictEval.excludedWarnings} hint-quality warning(s); use --strict=all to include)\n`);
+        process.stdout.write(`  (strict=warnings excluded ${strictEval.excludedWarnings} advisory warning(s); use --strict=all to include)\n`);
     }
     // Surface acknowledgement state. Bare suppressions don't qualify as
     // acknowledgements; expiring/expired ones get a callout so authors don't
@@ -458,10 +460,27 @@ async function doctorCommandImpl(args) {
     if (!inspection.sharkcraftDir) {
         process.stdout.write('\nNothing here yet — try `shrk init --zero-config` to detect your stack and pick a preset.\n');
     }
-    process.stdout.write(`\nAI-readiness: ${report.score} / 100 (${report.grade})\n`);
+    // Honest binary verdicts come first — yes/no on the two questions
+    // users actually want answered (can I let an agent write here? can
+    // I let an agent read here?). The 0..100 score follows, scoped to
+    // the workspace shape so libraries don't get dinged for "no
+    // pipelines" and apps don't get dinged for "no published API".
+    process.stdout.write(`\nShape: ${report.workspaceShape.label}` +
+        ` (score counts ${report.dimensions.filter((d) => d.applies === 'core').length} of ${report.dimensions.length} dimensions)\n`);
+    process.stdout.write(`  ${report.verdicts.readyForAgentReads ? '✓' : '✗'} Ready for agent reads (context / task lookups)\n`);
+    process.stdout.write(`  ${report.verdicts.readyForAgentWrites ? '✓' : '✗'} Ready for agent writes (apply / generate)\n`);
+    if (report.verdicts.blockers.length > 0) {
+        process.stdout.write(`  Blockers:\n`);
+        for (const b of report.verdicts.blockers) {
+            process.stdout.write(`    • ${b}\n`);
+        }
+    }
+    process.stdout.write(`\nAI-readiness: ${report.score} / 100 (${report.grade}, shape-aware)\n`);
     if (report.topRecommendations.length) {
         // Keep the default doctor output short: top 3 recommendations,
-        // pass `--verbose` for the full list.
+        // pass `--verbose` for the full list. Recommendations only fire
+        // from `core` dimensions now — n/a-for-shape dimensions stop
+        // generating the misleading "add a pipeline" advice for libraries.
         const verbose = flagBool(args, 'verbose');
         const visible = verbose ? report.topRecommendations : report.topRecommendations.slice(0, 3);
         process.stdout.write(`Top recommendations${verbose ? '' : ` (top ${visible.length})`}:\n`);
@@ -471,6 +490,21 @@ async function doctorCommandImpl(args) {
             process.stdout.write(`  … (${report.topRecommendations.length - visible.length} more — pass --verbose to see all)\n`);
         }
     }
+    // Surface N/A dimensions when --show-na is passed, so users can see
+    // what was deliberately skipped and disagree if they want to.
+    if (flagBool(args, 'show-na')) {
+        const skipped = report.dimensions.filter((d) => d.applies !== 'core');
+        if (skipped.length > 0) {
+            process.stdout.write(`\nNot counted in score (${skipped.length} dimensions):\n`);
+            for (const d of skipped) {
+                const tag = d.applies === 'n/a-for-shape' ? 'n/a' : 'advisory';
+                process.stdout.write(`  [${tag}] ${d.title}: ${d.note}`);
+                if (d.appliesReason)
+                    process.stdout.write(` — ${d.appliesReason}`);
+                process.stdout.write('\n');
+            }
+        }
+    }
     if (strictEval.failed) {
         process.stdout.write(`\nStrict mode: failing because ${strictEval.countedWarnings} warning(s) + ${result.summary.errors} error(s) exist (${strictEval.reason}).\n`);
     }
@@ -479,8 +513,7 @@ async function doctorCommandImpl(args) {
     }
     // Failure-to-success hints surface only when something is wrong.
     if (overallExitCode !== 0 || result.summary.warnings > 0) {
-        const folderMissing = result.checks.some((c) => c.id === 'sharkcraft-folder' && (c.severity === 'error' || c.severity === 'warning'));
-        process.stdout.write(renderFailureHints(doctorHints({ sharkcraftFolderMissing: folderMissing })));
+        process.stdout.write(renderFailureHints(doctorHints()));
     }
     // When there are preview-eligible findings (action-hints,
     // knowledge-stale, template-drift, self-config, pack-conflict,

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

@@ -1 +1 @@
-{"version":3,"file":"export.command.d.ts","sourceRoot":"","sources":["../../src/commands/export.command.ts"],"names":[],"mappings":"AAQA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAgBhC,eAAO,MAAM,aAAa,EAAE,eAkF3B,CAAC"}
+{"version":3,"file":"export.command.d.ts","sourceRoot":"","sources":["../../src/commands/export.command.ts"],"names":[],"mappings":"AASA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAgBhC,eAAO,MAAM,aAAa,EAAE,eAuF3B,CAAC"}

package/dist/commands/export.command.js

@@ -2,8 +2,9 @@ import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { inspectSharkcraft } from '@shrkcrft/inspector';
 import { ALL_EXPORT_FORMATS, isExportFormat, renderExport, } from "../export/export-formats.js";
+import { buildClaudeCommands } from "../export/claude-commands-export.js";
 import { flagBool, flagNumber, flagString, resolveCwd, } from "../command-registry.js";
-import { asJson, header } from "../output/format-output.js";
+import { asJson, bullet, header } from "../output/format-output.js";
 import { exportBundleCommand, exportSessionCommand, exportQualityCommand, exportReviewCommand, } from "./export-bundle.command.js";
 const ARCHIVE_SUBCOMMANDS = {
     bundle: exportBundleCommand,
@@ -13,7 +14,7 @@ const ARCHIVE_SUBCOMMANDS = {
 };
 export const exportCommand = {
     name: 'export',
-    description: 'Render SharkCraft knowledge as a flat agent-rule file (AGENTS.md / CLAUDE.md / .cursor/rules / copilot-instructions). Dry-run by default; pass --write to save.',
+    description: 'Inversion — pull SharkCraft rules into the agent\'s prompt instead of the agent calling back to shrk. Single-file outputs: claude-skill (.claude/skills/<name>/SKILL.md, recommended), agents-md (AGENTS.md), claude-md (CLAUDE.md), cursor-rules (.cursor/rules/*.mdc), copilot-instructions. Multi-file output: claude-commands (.claude/commands/*.md — per-project slash commands like /new-service, /check-changes, /follow-shrk). Dry-run by default; pass --write to save.',
     usage: 'shrk [--cwd <dir>] export <format> [--write] [--output <path>] [--task "<task>"] [--max-rules N] [--max-paths N] [--json]',
     async run(args) {
         const format = args.positional[0];
@@ -27,8 +28,13 @@ export const exportCommand = {
             const sub = { ...args, positional: args.positional.slice(1) };
             return archive.run(sub);
         }
+        // Multi-file `claude-commands` dispatches separately — it emits
+        // one .md per slash command, not a single rendered file.
+        if (format === 'claude-commands') {
+            return runClaudeCommandsExport(args);
+        }
         if (!isExportFormat(format)) {
-            process.stderr.write(`Unknown export format "${format}".\nFormats: ${ALL_EXPORT_FORMATS.join(', ')}, bundle, session, quality, review\n`);
+            process.stderr.write(`Unknown export format "${format}".\nFormats: ${ALL_EXPORT_FORMATS.join(', ')}, claude-commands, bundle, session, quality, review\n`);
             return 2;
         }
         const cwd = resolveCwd(args);
@@ -81,3 +87,70 @@ export const exportCommand = {
         return 0;
     },
 };
+/**
+ * `shrk export claude-commands` — multi-file generator for Claude
+ * Code's native `.claude/commands/` slash-command primitive. Produces
+ * one .md per command (static + per-template).
+ *
+ * Unlike single-file exports (claude-skill / claude-md / etc.) this
+ * writes a SET of files. Each file is a complete recipe Claude Code
+ * loads when the user types the matching slash command.
+ */
+async function runClaudeCommandsExport(args) {
+    const cwd = resolveCwd(args);
+    const inspection = await inspectSharkcraft({ cwd });
+    const result = buildClaudeCommands(inspection);
+    const wantJson = flagBool(args, 'json');
+    const doWrite = flagBool(args, 'write');
+    const force = flagBool(args, 'force');
+    if (wantJson) {
+        process.stdout.write(asJson({
+            format: 'claude-commands',
+            write: doWrite,
+            files: result.files.map((f) => ({
+                path: f.path,
+                slash: f.slash,
+                source: f.source,
+            })),
+        }) + '\n');
+        return 0;
+    }
+    if (!doWrite) {
+        process.stdout.write(header('Export (claude-commands) — dry-run'));
+        process.stdout.write(`Would write ${result.files.length} command file(s):\n\n`);
+        for (const f of result.files) {
+            process.stdout.write(`  ${f.path}\n`);
+            process.stdout.write(`    → users type \`/${f.slash}\` in Claude Code (${f.source})\n`);
+        }
+        process.stdout.write('\nRe-run with --write to save.\n');
+        return 0;
+    }
+    const written = [];
+    const skipped = [];
+    for (const file of result.files) {
+        const fullPath = join(cwd, file.path);
+        mkdirSync(dirname(fullPath), { recursive: true });
+        if (existsSync(fullPath) && !force) {
+            skipped.push(file.path);
+            continue;
+        }
+        writeFileSync(fullPath, file.content, 'utf8');
+        written.push(file.path);
+    }
+    process.stdout.write(header('Claude commands exported'));
+    if (written.length) {
+        process.stdout.write(`Wrote ${written.length} command file(s):\n`);
+        for (const p of written) {
+            const f = result.files.find((x) => x.path === p);
+            process.stdout.write(bullet(`${p}  → \`/${f.slash}\``) + '\n');
+        }
+    }
+    if (skipped.length) {
+        process.stdout.write(`\nSkipped ${skipped.length} (already exist; use --force to overwrite):\n`);
+        for (const p of skipped)
+            process.stdout.write(bullet(p) + '\n');
+    }
+    process.stdout.write('\nClaude Code picks up `.claude/commands/*.md` automatically. ' +
+        'Open the project in Claude Code, type `/` — the slash commands are in the palette.\n');
+    return 0;
+}

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

@@ -0,0 +1,12 @@
+import { type ICommandHandler } from '../command-registry.js';
+/**
+ * `shrk framework` — run / inspect the framework-aware extractors.
+ *
+ * Sub-verbs:
+ *   - shrk framework index           run extractors over the project
+ *   - shrk framework status          report store health
+ *   - shrk framework list [filters]  list entities (--framework, --subtype, --file)
+ *   - shrk framework routes          NestJS route table (method, path, handler, file)
+ */
+export declare const frameworkCommand: ICommandHandler;
+//# sourceMappingURL=framework.command.d.ts.map

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

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