@shrkcrft/cli 0.1.0-alpha.7 → 0.1.0-alpha.8

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/help.command.d.ts

@@ -1,8 +1,9 @@
 import type { CommandRegistry } from '../command-registry.js';
 /**
- * Short product start screen for bare `shrk` / `shrk --help`. Pruned
- * to the core tier set; extended verbs live one link away via
- * `shrk surface list`.
+ * Product start screen for bare `shrk` / `shrk --help`. Shows the
+ * curated ~20-command "starter" surface organized by workflow phase.
+ * Everything else stays callable; users see the full ~70-verb catalog
+ * via `shrk --full-help` or browse it through `shrk surface list`.
  *
  * Returns the lines (without trailing newline). Pulled into a function
  * so tests can assert on the structure without grepping stdout.

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

@@ -1 +1 @@
-{"version":3,"file":"help.command.d.ts","sourceRoot":"","sources":["../../src/commands/help.command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAG9D;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAuB1C;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,eAAe;;;;cAK3C;QAAE,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAA;KAAE,GAAG,MAAM;EA2FpF"}
+{"version":3,"file":"help.command.d.ts","sourceRoot":"","sources":["../../src/commands/help.command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAI9D;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAiD1C;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,eAAe;;;;cAK3C;QAAE,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAA;KAAE,GAAG,MAAM;EAyHpF"}

package/dist/commands/help.command.js

@@ -1,8 +1,10 @@
 import { header } from "../output/format-output.js";
+import { COMMAND_CATALOG, defaultShowInHelp } from "./command-catalog.js";
 /**
- * Short product start screen for bare `shrk` / `shrk --help`. Pruned
- * to the core tier set; extended verbs live one link away via
- * `shrk surface list`.
+ * Product start screen for bare `shrk` / `shrk --help`. Shows the
+ * curated ~20-command "starter" surface organized by workflow phase.
+ * Everything else stays callable; users see the full ~70-verb catalog
+ * via `shrk --full-help` or browse it through `shrk surface list`.
  *
  * Returns the lines (without trailing newline). Pulled into a function
  * so tests can assert on the structure without grepping stdout.
@@ -12,20 +14,46 @@ export function renderStartScreen() {
     lines.push('SharkCraft CLI — deterministic, local-first project intelligence for AI coding agents.');
     lines.push('Usage: shrk [--cwd <dir>] <command> [...args]');
     lines.push('');
-    lines.push('Core (always on):');
-    lines.push('  $ shrk recommend "<task>"        — what should I do?');
+    lines.push('Bootstrap:');
+    lines.push('  $ shrk init --infer --write      — scan the repo + populate sharkcraft/ from real signals (recommended for new repos)');
+    lines.push('  $ shrk import claude-md ./CLAUDE.md --populate --write  — populate sharkcraft/ from existing CLAUDE.md / AGENTS.md / .cursor/rules');
+    lines.push('  $ shrk init --with-claude-skill --write  — scaffold sharkcraft/ AND inline rules into .claude/skills/ (one-step)');
+    lines.push('  $ shrk init                      — scaffold sharkcraft/ + config skeleton (preset defaults)');
     lines.push('  $ shrk doctor                    — is the workspace healthy?');
-    lines.push('  $ shrk context --task "<task>"   — focused context for a task');
-    lines.push('  $ shrk init                      — create sharkcraft/ + config skeleton');
-    lines.push('  $ shrk check boundaries          — boundary enforcement');
-    lines.push('  $ shrk surface list              — every command grouped by tier');
+    lines.push('  $ shrk inspect                   — detect frameworks, paths, package manager');
+    lines.push('  $ shrk onboard                   — analyze an existing repo (advisory)');
+    lines.push('');
+    lines.push('Use it for a task:');
+    lines.push('  $ shrk brief                     — single-page brief Claude reads first (project + rules + paths + verification)');
+    lines.push('  $ shrk recommend "<task>"        — what should I do?');
+    lines.push('  $ shrk context --task "<task>"   — token-budgeted relevant context');
+    lines.push('  $ shrk task "<task>"             — full AI-ready task packet (JSON)');
+    lines.push('  $ shrk coverage                  — what knowledge is missing');
+    lines.push('');
+    lines.push('Generate code safely:');
+    lines.push('  $ shrk gen <template> <name>     — generate from template (dry-run by default)');
+    lines.push('  $ shrk apply <plan.json>         — apply a reviewed plan (CLI is the only write path)');
+    lines.push('  $ shrk check boundaries          — enforce layer / import boundaries');
+    lines.push('  $ shrk quality                   — pre-PR gate (doctor + boundaries + coverage + drift)');
+    lines.push('');
+    lines.push('Browse what shrk knows:');
+    lines.push('  $ shrk knowledge list            — knowledge entries');
+    lines.push('  $ shrk rules list                — rules + conventions');
+    lines.push('  $ shrk templates list            — generator templates');
+    lines.push('  $ shrk import                    — parse AGENTS.md / CLAUDE.md / .cursor/rules');
+    lines.push('  $ shrk export                    — render to a flat agent-rule file');
+    lines.push('');
+    lines.push('Run shrk for an agent:');
+    lines.push('  $ shrk export claude-skill --write — generate .claude/skills/<name>/SKILL.md (rules INTO the prompt — no MCP roundtrip)');
+    lines.push('  $ shrk export agents-md --write  — generate AGENTS.md / CLAUDE.md / .cursor/rules / copilot-instructions');
+    lines.push('  $ shrk mcp serve                 — start the MCP server (stdio) for live queries');
+    lines.push('  $ shrk dashboard                 — start the local read-only dashboard');
     lines.push('');
-    lines.push('Discover the rest (extended tier — always callable):');
-    lines.push('  $ shrk surface list              — full surface, grouped by tier and profile');
+    lines.push('Discover the rest (always callable, hidden from this screen by default):');
+    lines.push('  $ shrk surface list              — full ~70-verb catalog by tier');
     lines.push('  $ shrk surface profiles          — named profiles (small-app / monorepo / ci / agent / pack-author)');
-    lines.push('  $ shrk surface explain <cmd>     — why a command has its current tier');
     lines.push('  $ shrk help <command>            — usage for a specific command');
-    lines.push('  $ shrk --full-help               — the long, exhaustive help');
+    lines.push('  $ shrk --full-help               — long, exhaustive help');
     lines.push('  $ shrk --about                   — what shrk is and is not');
     lines.push('');
     lines.push('Free-form input is fine — `shrk "<task>"` routes to `shrk recommend`.');
@@ -89,13 +117,41 @@ export function makeHelpCommand(registry) {
                 process.stdout.write(renderStartScreen());
                 return 0;
             }
+            const wantsAll = args.flags.get('all') === true;
             process.stdout.write(`SharkCraft CLI — structured project intelligence for AI coding agents\n`);
             process.stdout.write(`Usage: shrk [--cwd <dir>] <command> [...args]\n`);
+            // The catalog has ~360 entries; only ~30 top-level verbs pay
+            // rent (see PRIMARY_VERBS_ALLOWLIST in command-catalog.ts).
+            // Default --full-help filters to that set; `--full-help --all`
+            // dumps the entire catalog for power users.
+            const visibleVerbs = new Set();
+            if (!wantsAll) {
+                for (const entry of COMMAND_CATALOG) {
+                    if (defaultShowInHelp(entry)) {
+                        const verb = entry.command.split(/\s+/)[0] ?? '';
+                        if (verb)
+                            visibleVerbs.add(verb);
+                    }
+                }
+            }
+            const visibleTopLevel = registry.list().filter((c) => {
+                if (wantsAll)
+                    return true;
+                return visibleVerbs.has(c.name);
+            });
             process.stdout.write(header('Top-level commands'));
-            for (const c of registry.list()) {
+            for (const c of visibleTopLevel) {
                 process.stdout.write(`  ${c.name.padEnd(10)} — ${c.description}\n`);
             }
-            // Show each canonical group once.
+            if (!wantsAll) {
+                const hiddenCount = registry.list().length - visibleTopLevel.length;
+                if (hiddenCount > 0) {
+                    process.stdout.write(`\n  …and ${hiddenCount} more, hidden from default help. Run \`shrk --full-help --all\` to see them, ` +
+                        `or \`shrk surface list\` to browse by tier.\n`);
+                }
+            }
+            // Show each canonical group once — also filtered by the allowlist
+            // unless --all was passed.
             const canonicalGroups = [];
             const aliasMap = registry.listGroupAliases();
             const seen = new Set();
@@ -103,7 +159,9 @@ export function makeHelpCommand(registry) {
                 const canonical = aliasMap.get(g) ?? g;
                 if (!seen.has(canonical)) {
                     seen.add(canonical);
-                    canonicalGroups.push(canonical);
+                    if (wantsAll || visibleVerbs.has(canonical)) {
+                        canonicalGroups.push(canonical);
+                    }
                 }
             }
             const aliasesByCanonical = new Map();

package/dist/commands/helper.command.js

@@ -85,7 +85,7 @@ export const helperPlanCommand = {
         // profile is available. Today the helper-registry detects this inside
         // buildHelperPlan via requireProfile(); we surface a friendly message.
         if ('requiresProfile' in def && def.requiresProfile) {
-            process.stderr.write(`Helper "${id}" requires a plugin-lifecycle profile. Available:\n  $ shrk plugin lifecycle profiles\n`);
+            process.stderr.write(`Helper "${id}" requires a registered profile. Available:\n  $ shrk profiles list\n`);
             // Still try to build the plan; the registry throws with the same idea.
         }
         const cwd = resolveCwd(args);

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

@@ -1 +1 @@
-{"version":3,"file":"import.command.d.ts","sourceRoot":"","sources":["../../src/commands/import.command.ts"],"names":[],"mappings":"AASA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAyBhC,eAAO,MAAM,aAAa,EAAE,eA8G3B,CAAC"}
+{"version":3,"file":"import.command.d.ts","sourceRoot":"","sources":["../../src/commands/import.command.ts"],"names":[],"mappings":"AAUA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAyBhC,eAAO,MAAM,aAAa,EAAE,eA8H3B,CAAC"}

package/dist/commands/import.command.js

@@ -1,8 +1,8 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import * as nodePath from 'node:path';
-import { emitKnowledgeTs, importAgentsMd, importClaudeMd, importCursorRules, } from '@shrkcrft/importer';
+import { emitKnowledgeTs, importAgentsMd, importClaudeMd, importCursorRules, synthesizePopulatedFromImport, } from '@shrkcrft/importer';
 import { flagBool, flagString, flagList, resolveCwd, } from "../command-registry.js";
-import { asJson, header, kv } from "../output/format-output.js";
+import { asJson, bullet, header, kv } from "../output/format-output.js";
 function repeatedFlagList(args, name) {
     return flagList(args, name, { dedupe: true });
 }
@@ -22,8 +22,8 @@ function defaultOutput(format) {
 }
 export const importCommand = {
     name: 'import',
-    description: 'Parse existing agent rule files (AGENTS.md / CLAUDE.md / .cursor/rules) into a structured @shrkcrft/knowledge TypeScript draft. Dry-run by default; --write saves the draft to sharkcraft/imports/.',
-    usage: 'shrk [--cwd <dir>] import <format> [<path>] [--prefix <id>] [--tag <t>] [--scope <s>] [--output <file>] [--write] [--force] [--json]',
+    description: 'Parse existing agent rule files (AGENTS.md / CLAUDE.md / .cursor/rules) into shrk\'s structure. By default (`--write`), saves a single draft TS file under sharkcraft/imports/ for the user to adopt by hand. Pass `--populate` to route entries directly into sharkcraft/rules.ts + paths.ts + knowledge.ts (by type) with a confidence triage report — same shape as `shrk init --infer`. Both modes dry-run by default.',
+    usage: 'shrk [--cwd <dir>] import <format> [<path>] [--prefix <id>] [--tag <t>] [--scope <s>] [--output <file>] [--write] [--populate] [--force] [--json]',
     async run(args) {
         const format = args.positional[0];
         if (!format || !KNOWN_FORMATS.includes(format)) {
@@ -57,9 +57,24 @@ export const importCommand = {
         }
         const outPath = nodePath.resolve(cwd, flagString(args, 'output') ?? flagString(args, 'out') ?? defaultOutput(fmt));
         const write = flagBool(args, 'write');
+        const populate = flagBool(args, 'populate');
         const tsSource = emitKnowledgeTs(result.entries, {
             sourceLabel: `${fmt} (${result.sourceFiles.join(', ') || path})`,
         });
+        // ── `--populate` path: distribute entries into populated
+        //    sharkcraft/* files (rules.ts / paths.ts / knowledge.ts) with
+        //    confidence triage. Mirrors `shrk init --infer`'s contract.
+        if (populate) {
+            return runPopulateImport({
+                cwd,
+                fmt,
+                path,
+                result,
+                write,
+                force: flagBool(args, 'force'),
+                wantJson: flagBool(args, 'json'),
+            });
+        }
         if (flagBool(args, 'json')) {
             process.stdout.write(asJson({
                 format: fmt,
@@ -113,3 +128,104 @@ export const importCommand = {
         return 0;
     },
 };
+/**
+ * `shrk import <format> --populate` path. Routes parsed entries
+ * into populated `sharkcraft/*.ts` files by KnowledgeType, with
+ * confidence triage and a companion `.imported-report.md`. Same
+ * shape as `shrk init --infer`.
+ */
+function runPopulateImport(args) {
+    const { cwd, fmt, path, result, write, force, wantJson } = args;
+    const sharkcraftDir = nodePath.join(cwd, 'sharkcraft');
+    const projectName = readProjectName(cwd) ?? 'project';
+    const description = `Imported from ${fmt} (${path})`;
+    const populated = synthesizePopulatedFromImport(result.entries, {
+        projectName,
+        description,
+        sourceLabel: `${fmt} (${result.sourceFiles.join(', ') || path})`,
+    });
+    if (wantJson) {
+        process.stdout.write(asJson({
+            format: fmt,
+            source: path,
+            mode: write ? 'populate' : 'populate-dry-run',
+            sharkcraftDir,
+            entryCount: result.entries.length,
+            warnings: result.warnings,
+            files: populated.files.map((f) => ({ path: f.path, kind: f.kind })),
+            report: populated.report,
+        }) + '\n');
+        return 0;
+    }
+    process.stdout.write(header(`Import (${fmt}) — populate`));
+    process.stdout.write(kv('source', path) + '\n');
+    process.stdout.write(kv('files read', String(result.sourceFiles.length)) + '\n');
+    process.stdout.write(kv('entries parsed', String(result.entries.length)) + '\n');
+    process.stdout.write(kv('target', sharkcraftDir) + '\n');
+    process.stdout.write(kv('mode', write ? 'write' : 'dry-run (preview only)') + '\n\n');
+    process.stdout.write(`Triage: ${populated.report.adoptedHigh.length} adopted directly · ` +
+        `${populated.report.adoptedMedium.length} marked for review · ` +
+        `${populated.report.dropped.length} dropped (in report).\n\n`);
+    if (result.warnings.length > 0) {
+        process.stdout.write(header('Parser warnings'));
+        for (const w of result.warnings) {
+            process.stdout.write(`  ${w.origin}: ${w.message}\n`);
+        }
+        process.stdout.write('\n');
+    }
+    if (!write) {
+        process.stdout.write('Would write:\n');
+        for (const f of populated.files)
+            process.stdout.write(bullet(f.path) + '\n');
+        process.stdout.write('\nRe-run with --write to persist.\n');
+        return 0;
+    }
+    const written = [];
+    const skipped = [];
+    for (const file of populated.files) {
+        const fullPath = nodePath.join(sharkcraftDir, file.path);
+        mkdirSync(nodePath.dirname(fullPath), { recursive: true });
+        if (existsSync(fullPath) && !force) {
+            skipped.push(file.path);
+            continue;
+        }
+        writeFileSync(fullPath, file.content, 'utf8');
+        written.push(file.path);
+    }
+    if (written.length) {
+        process.stdout.write('Wrote:\n');
+        for (const p of written)
+            process.stdout.write(bullet(p) + '\n');
+    }
+    if (skipped.length) {
+        process.stdout.write('\nSkipped (already exist; use --force to overwrite):\n');
+        for (const p of skipped)
+            process.stdout.write(bullet(p) + '\n');
+    }
+    process.stdout.write(`\nRead the import report: \`${nodePath.join('sharkcraft', '.imported-report.md')}\`\n` +
+        `It lists what was adopted high-confidence, what's marked for your review, ` +
+        `and what \`shrk import\` deliberately doesn't recover from markdown.\n`);
+    process.stdout.write('\nNext:\n');
+    process.stdout.write(bullet('$ shrk doctor                            — verify the populated setup') + '\n');
+    process.stdout.write(bullet('$ shrk brief                             — single-page brief Claude reads first') + '\n');
+    process.stdout.write(bullet('$ shrk export claude-skill --write       — inline the rules into Claude\'s prompt') + '\n');
+    return 0;
+}
+/**
+ * Best-effort read of `package.json#name` for use as `projectName`
+ * in the generated config. Falls back to undefined; the synthesizer
+ * uses 'project' as a default.
+ */
+function readProjectName(cwd) {
+    const pkgPath = nodePath.join(cwd, 'package.json');
+    try {
+        if (!existsSync(pkgPath))
+            return undefined;
+        const raw = readFileSync(pkgPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return parsed.name ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"init.command.d.ts","sourceRoot":"","sources":["../../src/commands/init.command.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAwB,KAAK,eAAe,EAA+B,MAAM,wBAAwB,CAAC;AAmSjH,eAAO,MAAM,WAAW,EAAE,eA2FzB,CAAC"}
+{"version":3,"file":"init.command.d.ts","sourceRoot":"","sources":["../../src/commands/init.command.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAwB,KAAK,eAAe,EAA+B,MAAM,wBAAwB,CAAC;AAuSjH,eAAO,MAAM,WAAW,EAAE,eA2HzB,CAAC"}

package/dist/commands/init.command.js

@@ -179,10 +179,10 @@ async function applyPresetInit(cwd, mode) {
         renderPathsAdvisory(pathsAdvisory);
     }
     process.stdout.write('\nNext:\n');
-    for (const cmd of preset.recommendedNextCommands ?? [
-        'shrk doctor',
-        'shrk context --task "<task>"',
-    ]) {
+    process.stdout.write(bullet('$ shrk doctor                            — verify the setup (shape-aware verdict)') + '\n');
+    process.stdout.write(bullet('$ shrk brief                             — single-page brief Claude reads first') + '\n');
+    process.stdout.write(bullet('$ shrk export claude-skill --write       — inline the rules into Claude\'s prompt via .claude/skills/') + '\n');
+    for (const cmd of preset.recommendedNextCommands ?? []) {
         process.stdout.write(bullet(`$ ${cmd}`) + '\n');
     }
     process.stdout.write(bullet('Start the MCP server: `shrk mcp serve` (or run it via Claude Code)') + '\n');
@@ -243,13 +243,23 @@ function applyLegacyInit(cwd, force) {
 }
 export const initCommand = {
     name: 'init',
-    description: 'Initialize a sharkcraft/ folder in the current repository. Pass --preset <id> to apply a built-in preset (default: generic). Use --zero-config or --preset auto to detect the workspace and pick a preset automatically. Use --legacy for the full pre-preset seed.',
-    usage: 'shrk init [--preset <id|auto>] [--zero-config] [--dry-run] [--write] [--legacy] [--force] [--merge] [--suggest-only] [--no-gitignore] [--surface-profile <id>]',
+    description: 'Initialize a sharkcraft/ folder in the current repository. Pass --preset <id> to apply a built-in preset (default: generic). Use --zero-config or --preset auto to detect the workspace and pick a preset automatically. Use --legacy for the full pre-preset seed. Pass --infer to scan the repo and populate sharkcraft/* with the real signals it finds (paths from disk, rules from tsconfig/package.json, boundaries from layer structure) — combines with --preset to add inferred entries on top of the preset baseline. Pass --with-claude-skill to also generate .claude/skills/<name>/SKILL.md so Claude Code picks up the rules automatically.',
+    usage: 'shrk init [--preset <id|auto>] [--zero-config] [--infer] [--dry-run] [--write] [--with-claude-skill] [--legacy] [--force] [--merge] [--suggest-only] [--no-gitignore] [--surface-profile <id>]',
     async run(args) {
         const force = flagBool(args, 'force');
         const merge = flagBool(args, 'merge');
         const cwd = resolveCwd(args);
+        const wantInfer = flagBool(args, 'infer');
         const skipGitignore = flagBool(args, 'no-gitignore');
+        // `--infer` mode short-circuits the preset path entirely. The
+        // inferred output IS the populated sharkcraft/*, no preset
+        // baseline to merge against. This is the cleaner contract: the
+        // user opted into "scan my repo and tell me what's there", and
+        // adding a preset's static defaults on top would muddy the
+        // confidence reporting in .inferred-report.md.
+        if (wantInfer) {
+            return runInferInit(cwd, args, force);
+        }
         if (flagBool(args, 'legacy')) {
             const code = applyLegacyInit(cwd, force);
             if (code === 0 && !skipGitignore) {
@@ -310,7 +320,7 @@ export const initCommand = {
         if (dryRun) {
             process.stdout.write(`Surface profile: ${surfaceDecision.profile} (${surfaceDecision.source}) — ${surfaceDecision.reason}\n`);
         }
-        return applyPresetInit(cwd, {
+        const presetCode = await applyPresetInit(cwd, {
             presetId,
             dryRun,
             force,
@@ -320,5 +330,139 @@ export const initCommand = {
             surfaceProfile: surfaceDecision.profile,
             surfaceProfileReason: surfaceDecision.reason,
         });
+        // `--with-claude-skill` chains the claude-skill export onto the init
+        // so a fresh user goes from `npx shrk init --with-claude-skill --write`
+        // to a working .claude/skills/<name>/SKILL.md in one step. Skipped in
+        // dry-run + when init itself didn't succeed.
+        if (presetCode === 0 &&
+            !dryRun &&
+            (flagBool(args, 'with-claude-skill') || flagBool(args, 'with-skill'))) {
+            const skillCode = await runClaudeSkillExportAfterInit(cwd, force);
+            // Init success is what we report; skill failure is logged but
+            // doesn't fail the init exit code (otherwise users would see a
+            // half-applied repo with a non-zero exit and panic).
+            if (skillCode !== 0) {
+                process.stderr.write('\n(claude-skill export failed — re-run `shrk export claude-skill --write` to retry.)\n');
+            }
+        }
+        return presetCode;
     },
 };
+/**
+ * Chain the claude-skill export onto a successful init. Loads the
+ * exporter lazily (it depends on inspectSharkcraft which has its own
+ * caching) and writes the skill file using the same `--force` semantics
+ * as init itself.
+ */
+/**
+ * `shrk init --infer` — scan the repo and populate `sharkcraft/*`
+ * with the real signals it finds, instead of writing preset defaults.
+ *
+ * Pipeline:
+ *   1. `inspectSharkcraft({ cwd })` builds the full inspection.
+ *   2. `buildOnboardingPlan(inspection)` extracts inferred paths,
+ *      rules, boundaries, pipelines, verification commands.
+ *   3. `synthesizeFromOnboarding(plan)` triages each entry by
+ *      confidence and emits populated `sharkcraft/*.ts` files plus
+ *      a companion `.inferred-report.md` + `.inferred-report.json`.
+ *   4. Writer respects `--dry-run` / `--write` / `--force` /
+ *      `--with-claude-skill` semantics consistently with the
+ *      preset-init path.
+ *
+ * Honest-by-default: every adopted entry is tagged with its source
+ * signal; medium-confidence rows get a `// TODO: review` marker; low-
+ * confidence rows are dropped from the populated files and listed in
+ * the report so the user knows exactly what was inferred vs needs
+ * authoring.
+ */
+async function runInferInit(cwd, args, force) {
+    const { inspectSharkcraft, buildOnboardingPlan, synthesizeFromOnboarding } = await import('@shrkcrft/inspector');
+    const dryRun = !flagBool(args, 'write');
+    const sharkcraftDir = nodePath.join(cwd, 'sharkcraft');
+    process.stdout.write(header('SharkCraft init — infer'));
+    process.stdout.write(`Folder: ${sharkcraftDir}\n`);
+    const inspection = await inspectSharkcraft({ cwd });
+    const plan = buildOnboardingPlan(inspection);
+    const result = synthesizeFromOnboarding(plan);
+    // Summary block — print BEFORE writing so the user can ctrl-C if the
+    // confidence triage doesn't look right.
+    process.stdout.write(`\nDetected profiles: ${plan.projectSummary.profiles.join(', ') || '(none)'}\n`);
+    process.stdout.write(`Inference triage: ${result.report.adoptedHigh.length} adopted directly · ` +
+        `${result.report.adoptedMedium.length} marked for review · ` +
+        `${result.report.dropped.length} dropped (in report).\n\n`);
+    const written = [];
+    const skipped = [];
+    const wouldWrite = [];
+    for (const file of result.files) {
+        const fullPath = nodePath.join(sharkcraftDir, file.path);
+        if (dryRun) {
+            wouldWrite.push(file.path);
+            continue;
+        }
+        mkdirSync(nodePath.dirname(fullPath), { recursive: true });
+        if (existsSync(fullPath) && !force) {
+            skipped.push(file.path);
+            continue;
+        }
+        writeFileSync(fullPath, file.content, 'utf8');
+        written.push(file.path);
+    }
+    if (dryRun) {
+        process.stdout.write('Would write:\n');
+        for (const p of wouldWrite)
+            process.stdout.write(bullet(p) + '\n');
+        process.stdout.write('\nRe-run with --write to persist.\n');
+        return 0;
+    }
+    if (written.length) {
+        process.stdout.write('Wrote:\n');
+        for (const p of written)
+            process.stdout.write(bullet(p) + '\n');
+    }
+    if (skipped.length) {
+        process.stdout.write('\nSkipped (already exist; use --force to overwrite):\n');
+        for (const p of skipped)
+            process.stdout.write(bullet(p) + '\n');
+    }
+    process.stdout.write(`\nRead the confidence report: \`${nodePath.join('sharkcraft', '.inferred-report.md')}\`\n` +
+        `It lists what was adopted high-confidence, what's marked for your review, ` +
+        `and what shrk can't infer (project-specific decisions you should author by hand).\n`);
+    process.stdout.write('\nNext:\n');
+    process.stdout.write(bullet('$ shrk doctor                            — verify the setup (shape-aware verdict)') + '\n');
+    process.stdout.write(bullet('$ shrk brief                             — single-page brief Claude reads first') + '\n');
+    process.stdout.write(bullet('$ shrk export claude-skill --write       — inline the rules into Claude\'s prompt') + '\n');
+    // Chain claude-skill if requested.
+    if (flagBool(args, 'with-claude-skill') || flagBool(args, 'with-skill')) {
+        const skillCode = await runClaudeSkillExportAfterInit(cwd, force);
+        if (skillCode !== 0) {
+            process.stderr.write('\n(claude-skill export failed — re-run `shrk export claude-skill --write` to retry.)\n');
+        }
+    }
+    // Gitignore + paths advisory same as preset path.
+    const skipGitignore = flagBool(args, 'no-gitignore');
+    if (!skipGitignore) {
+        const patch = ensureSharkcraftGitignore({ cwd, dryRun: false });
+        if (patch.added.length > 0) {
+            process.stdout.write('\n' + renderGitignorePatch(patch, false));
+        }
+    }
+    return 0;
+}
+async function runClaudeSkillExportAfterInit(cwd, force) {
+    const { inspectSharkcraft } = await import('@shrkcrft/inspector');
+    const { renderExport } = await import("../export/export-formats.js");
+    const inspection = await inspectSharkcraft({ cwd });
+    const result = renderExport(inspection, { format: 'claude-skill' });
+    const outputPath = nodePath.join(cwd, result.suggestedPath);
+    mkdirSync(nodePath.dirname(outputPath), { recursive: true });
+    if (existsSync(outputPath) && !force) {
+        process.stdout.write(`\nSkipped claude-skill export — ${result.suggestedPath} already exists. Pass --force to overwrite, or run \`shrk export claude-skill --write --force\`.\n`);
+        return 0;
+    }
+    writeFileSync(outputPath, result.content, 'utf8');
+    process.stdout.write('\n');
+    process.stdout.write(header('Claude-skill exported'));
+    process.stdout.write(`Wrote ${result.suggestedPath}\n` +
+        `  → Claude Code will auto-load this skill in any session opened against this repo.\n`);
+    return 0;
+}

package/dist/commands/packs-new.d.ts

@@ -1,5 +1,5 @@
 import { type ICommandHandler } from '../command-registry.js';
-export type PackKind = 'generic' | 'framework' | 'architecture' | 'enterprise' | 'platform-adopter';
+export type PackKind = 'generic' | 'framework' | 'architecture' | 'enterprise';
 interface IScaffoldFile {
     /** Path relative to the new pack root. */
     relativePath: string;

package/dist/commands/packs-new.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"packs-new.d.ts","sourceRoot":"","sources":["../../src/commands/packs-new.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAIhC,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,cAAc,GAAG,YAAY,GAAG,kBAAkB,CAAC;AAUpG,UAAU,aAAa;IACrB,0CAA0C;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,kDAAkD;AAClD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,GAAG,mBAAmB,CA+G/E;AA4TD,eAAO,MAAM,eAAe,EAAE,eAoG7B,CAAC;AAUF,eAAO,MAAM,gBAAgB,EAAE,eAqI9B,CAAC"}
+{"version":3,"file":"packs-new.d.ts","sourceRoot":"","sources":["../../src/commands/packs-new.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAIhC,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,WAAW,GAAG,cAAc,GAAG,YAAY,CAAC;AAS/E,UAAU,aAAa;IACrB,0CAA0C;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,kDAAkD;AAClD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,GAAG,mBAAmB,CAyG/E;AA0SD,eAAO,MAAM,eAAe,EAAE,eAoG7B,CAAC;AAUF,eAAO,MAAM,gBAAgB,EAAE,eAqI9B,CAAC"}