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

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

@@ -1 +1 @@
-{"version":3,"file":"graph.command.d.ts","sourceRoot":"","sources":["../../src/commands/graph.command.ts"],"names":[],"mappings":"AAUA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAehC,eAAO,MAAM,YAAY,EAAE,eA6L1B,CAAC"}
+{"version":3,"file":"graph.command.d.ts","sourceRoot":"","sources":["../../src/commands/graph.command.ts"],"names":[],"mappings":"AAUA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA0BhC,eAAO,MAAM,YAAY,EAAE,eA0M1B,CAAC"}

package/dist/commands/graph.command.js

@@ -3,6 +3,7 @@ import * as nodePath from 'node:path';
 import { analyzeImportGraph, buildKnowledgeGraph, findGraphPath, getGraphNode, inspectSharkcraft, } from '@shrkcrft/inspector';
 import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
 import { asJson, header, kv } from "../output/format-output.js";
+import { runGraphCallers, runGraphContext, runGraphCycles, runGraphDeps, runGraphImpact, runGraphIndex, runGraphSearch, runGraphStatus, runGraphUnresolved, } from "./graph-code-subverbs.js";
 const KNOWN_KINDS = [
     'knowledge',
     'rule',
@@ -19,6 +20,27 @@ export const graphCommand = {
     description: 'Show the SharkCraft knowledge graph: nodes (knowledge/rules/paths/templates/pipelines/presets/packs/boundaries) and edges (related-template, preset-references, pipeline-step-references, …). Supports text|json|dot|mermaid output and an `export` subcommand for writing to file.',
     usage: 'shrk [--cwd <dir>] graph [<id>] [--type <kind>] [--format text|json|dot|mermaid] [--output <file>] [--json] | shrk graph export --format dot|mermaid --output <file>',
     async run(args) {
+        // Code-intelligence subverbs (R65) don't need the knowledge graph —
+        // dispatch them before the expensive inspection so they stay fast.
+        const earlySub = args.positional[0];
+        if (earlySub === 'index')
+            return runGraphIndex(args);
+        if (earlySub === 'status')
+            return runGraphStatus(args);
+        if (earlySub === 'search')
+            return runGraphSearch(args);
+        if (earlySub === 'context')
+            return runGraphContext(args);
+        if (earlySub === 'impact')
+            return runGraphImpact(args);
+        if (earlySub === 'callers')
+            return runGraphCallers(args);
+        if (earlySub === 'cycles')
+            return runGraphCycles(args);
+        if (earlySub === 'unresolved')
+            return runGraphUnresolved(args);
+        if (earlySub === 'deps')
+            return runGraphDeps({ ...args, positional: args.positional.slice(1) });
         const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
         const graph = buildKnowledgeGraph(inspection);
         const sub = args.positional[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,CAyB1C;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,33 +1,59 @@
 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.
  */
 export function renderStartScreen() {
     const lines = [];
-    lines.push('SharkCraft CLI — the safety layer beneath your AI coding agent.');
+    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('Prove it in 60 seconds:');
-    lines.push('  $ shrk check boundaries --changed-only --since main');
-    lines.push('  $ shrk review packet --v3 --since main');
-    lines.push('  $ shrk mcp install claude-code   — copy-paste the MCP entry');
-    lines.push('');
-    lines.push('Core (always on):');
+    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 recommend "<task>"        — what command should I reach for?');
-    lines.push('  $ shrk init                      — create sharkcraft/ + config skeleton');
-    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('Discover the rest (extended tier — always callable):');
-    lines.push('  $ shrk surface list              — full surface, grouped by tier and profile');
-    lines.push('  $ shrk surface explain <cmd>     — why a command has its current tier');
+    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 (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 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`.');
@@ -91,13 +117,41 @@ export function makeHelpCommand(registry) {
                 process.stdout.write(renderStartScreen());
                 return 0;
             }
-            process.stdout.write(`SharkCraft CLI — the safety layer beneath your AI coding agent.\n`);
+            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();
@@ -105,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/impact.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"impact.command.d.ts","sourceRoot":"","sources":["../../src/commands/impact.command.ts"],"names":[],"mappings":"AAsBA,OAAO,EAML,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA0QhC,eAAO,MAAM,aAAa,EAAE,eAoV3B,CAAC"}
+{"version":3,"file":"impact.command.d.ts","sourceRoot":"","sources":["../../src/commands/impact.command.ts"],"names":[],"mappings":"AAsBA,OAAO,EAML,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAyVhC,eAAO,MAAM,aAAa,EAAE,eA8V3B,CAAC"}

package/dist/commands/impact.command.js

@@ -2,7 +2,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import * as nodePath from 'node:path';
 import { analyzeImpact, analyzeTestImpact, findSymbolInProject, FuzzyImpactSourceKind, getChangedFiles, ImpactInputKind, inspectSharkcraft, QueryMatchKind, readFeatureBundle, renderImpactGraph, renderImpactHtml, renderImpactMarkdown, renderImpactText, resolveFuzzyImpact, warmConstructCache, } from '@shrkcrft/inspector';
 import { flagBool, flagNumber, flagString, flagList, resolveCwd, } from "../command-registry.js";
-import { asJson, header } from "../output/format-output.js";
+import { asJson, header, kv } from "../output/format-output.js";
 function collectFiles(args, cwd) {
     const diagnostics = [];
     const explicitFiles = flagList(args, 'files');
@@ -199,6 +199,84 @@ async function emitCodemodPlan(opts) {
     }
     return 0;
 }
+/**
+ * --via-graph adapter: takes the same input flags as `shrk impact` and
+ * routes through `@shrkcrft/impact-engine` for the v3 graph-backed
+ * payload. Defers to that engine; emits a clean error when the graph
+ * isn't indexed yet.
+ */
+async function runViaGraph(args) {
+    const cwd = resolveCwd(args);
+    const wantJson = flagBool(args, 'json') || flagString(args, 'format') === 'json';
+    const positional = args.positional[0];
+    const files = flagList(args, 'files');
+    const since = flagString(args, 'since');
+    const symbol = flagString(args, 'symbol');
+    const fileFlag = flagString(args, 'file');
+    const limit = flagNumber(args, 'limit') ?? 200;
+    const maxDepth = flagNumber(args, 'max-depth') ?? 5;
+    const target = positional ?? fileFlag;
+    const inputs = files.length > 0
+        ? { kind: 'files', files }
+        : symbol
+            ? { kind: 'symbol', symbolId: symbol }
+            : since
+                ? { kind: 'gitref', ref: since }
+                : target
+                    ? { kind: 'files', files: [target] }
+                    : undefined;
+    if (!inputs) {
+        process.stderr.write('Usage: shrk impact --via-graph <fileOrQuery> | --symbol <name> | --files a,b | --since <ref>\n');
+        return 2;
+    }
+    const { analyzeGraphImpact, ImpactReportStore, snapshotImpactAnalysis } = await import('@shrkcrft/impact-engine');
+    const analysis = analyzeGraphImpact(inputs, { projectRoot: cwd, limit, maxDepth });
+    // Persist a compact snapshot for the doctor + dashboard to read.
+    // `--no-persist` opts out (useful when scripting against many trees
+    // or when stdout is the only sink the caller cares about).
+    const noPersist = flagBool(args, 'no-persist');
+    if (!noPersist) {
+        try {
+            const summary = inputs.kind === 'files'
+                ? inputs.files.slice(0, 3).join(', ') + (inputs.files.length > 3 ? '…' : '')
+                : inputs.kind === 'symbol'
+                    ? `symbol:${inputs.symbolId}`
+                    : `gitref:${inputs.ref}`;
+            new ImpactReportStore(cwd).write(snapshotImpactAnalysis(analysis, summary));
+        }
+        catch {
+            // best-effort — never fail the command on a persistence error
+        }
+    }
+    if (wantJson) {
+        process.stdout.write(asJson(analysis) + '\n');
+        return 0;
+    }
+    process.stdout.write(header(`Impact (graph): ${target ?? symbol ?? files.join(',') ?? since}`));
+    process.stdout.write(`  risk: ${analysis.risk}\n`);
+    process.stdout.write(`  direct dependents: ${analysis.directDependents.length}\n`);
+    process.stdout.write(`  transitive dependents: ${analysis.transitiveDependents.length}\n`);
+    process.stdout.write(`  affected symbols: ${analysis.affectedSymbols.length}\n`);
+    process.stdout.write(`  caller files: ${analysis.affectedCallerFiles.length}\n`);
+    process.stdout.write(`  affected packages: ${analysis.affectedPackages.length}\n`);
+    process.stdout.write(`  affected rules: ${analysis.affectedRules.length}\n`);
+    process.stdout.write(`  affected templates: ${analysis.affectedTemplates.length}\n`);
+    process.stdout.write(`  likely tests: ${analysis.likelyTests.length}\n`);
+    process.stdout.write(`  public API touched: ${analysis.publicApiTouched ? 'yes' : 'no'}\n`);
+    if (analysis.riskReasons.length > 0) {
+        process.stdout.write('\nRisk reasons:\n');
+        for (const r of analysis.riskReasons)
+            process.stdout.write(`  • ${r}\n`);
+    }
+    if (analysis.validationScope.length > 0) {
+        process.stdout.write('\nRun before merging:\n');
+        for (const c of analysis.validationScope)
+            process.stdout.write(`  $ ${c}\n`);
+    }
+    for (const d of analysis.diagnostics.slice(0, 5))
+        process.stdout.write(`! ${d}\n`);
+    return 0;
+}
 export const impactCommand = {
     name: 'impact',
     description: 'Architecture impact analysis: direct + transitive dependents, risk + suggested commands. Supports fuzzy <query> resolution. Read-only.',
@@ -210,6 +288,16 @@ export const impactCommand = {
         if (args.positional[0] === 'graph') {
             return runImpactGraph({ ...args, positional: args.positional.slice(1) });
         }
+        if (args.positional[0] === 'baseline') {
+            return runImpactBaseline({ ...args, positional: args.positional.slice(1) });
+        }
+        // --via-graph: route through @shrkcrft/impact-engine for the v3
+        // graph-backed payload (sharkcraft.graph-impact-analysis/v3). Keeps
+        // the legacy v2 inspector path as the default so existing
+        // consumers don't shift.
+        if (flagBool(args, 'via-graph')) {
+            return runViaGraph(args);
+        }
         const cwd = resolveCwd(args);
         const inspection = await inspectSharkcraft({ cwd });
         // Warm construct cache so fuzzy resolution can map plugin keys / events /
@@ -817,3 +905,84 @@ function renderResolutionMd(r) {
 }
 // Sentinel — keep `QueryMatchKind` import alive for tooling. Used inside fuzzy-impact.ts.
 void QueryMatchKind;
+async function runImpactBaseline(args) {
+    const cwd = resolveCwd(args);
+    const wantJson = flagBool(args, 'json');
+    const verb = args.positional[0] ?? 'show';
+    const { ImpactReportStore, diffImpactReports } = await import('@shrkcrft/impact-engine');
+    const store = new ImpactReportStore(cwd);
+    if (verb === 'write') {
+        const last = store.read();
+        if (!last) {
+            const msg = `No recent impact run at ${store.absPath}. Run \`shrk impact --via-graph <target>\` first.\n`;
+            if (wantJson) {
+                process.stdout.write(asJson({ ok: false, error: 'no-last-run' }) + '\n');
+                return 1;
+            }
+            process.stderr.write(msg);
+            return 1;
+        }
+        store.writeBaseline(last);
+        if (wantJson) {
+            process.stdout.write(asJson({ wrote: store.baselinePath, baseline: last }) + '\n');
+            return 0;
+        }
+        process.stdout.write(`Impact baseline written → ${store.baselinePath}\n`);
+        process.stdout.write(`  Input: ${last.inputSummary}\n` +
+            `  Risk:  ${last.risk}\n` +
+            `  Dependents: ${last.directDependentCount} direct, ${last.transitiveDependentCount} transitive\n` +
+            `  Packages:   ${last.affectedPackageCount}\n`);
+        return 0;
+    }
+    if (verb === 'show') {
+        const baseline = store.readBaseline();
+        if (!baseline) {
+            const msg = `No baseline at ${store.baselinePath}. Run \`shrk impact baseline write\` to freeze the current run.\n`;
+            if (wantJson) {
+                process.stdout.write(asJson({ baseline: null, path: store.baselinePath }) + '\n');
+                return 1;
+            }
+            process.stderr.write(msg);
+            return 1;
+        }
+        const last = store.read();
+        if (wantJson) {
+            process.stdout.write(asJson({
+                path: store.baselinePath,
+                baseline,
+                ...(last ? { last, delta: diffImpactReports(baseline, last) } : {}),
+            }) + '\n');
+            return 0;
+        }
+        process.stdout.write(header('Impact baseline'));
+        process.stdout.write(kv('path', store.baselinePath) + '\n');
+        process.stdout.write(kv('input', baseline.inputSummary) + '\n');
+        process.stdout.write(kv('risk', baseline.risk) + '\n');
+        process.stdout.write(kv('dependents', `${baseline.directDependentCount} direct, ${baseline.transitiveDependentCount} transitive`) + '\n');
+        process.stdout.write(kv('packages', String(baseline.affectedPackageCount)) + '\n');
+        if (last) {
+            const d = diffImpactReports(baseline, last);
+            process.stdout.write('\nDelta (last − baseline): ' +
+                `dependents ${d.dependentDelta >= 0 ? '+' : ''}${d.dependentDelta}, ` +
+                `packages ${d.packageDelta >= 0 ? '+' : ''}${d.packageDelta}` +
+                (d.riskDrift ? `, risk ${d.riskDrift}` : '') +
+                (d.worsened ? '  ✗ worsened' : '  ✓ within baseline') +
+                '\n');
+        }
+        else {
+            process.stdout.write('\n(no recent `last.json` — run `shrk impact --via-graph` to populate it.)\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 impact baseline <write|show|clear> [--json]\n');
+    return 2;
+}

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":"AAeA,OAAO,EAAwB,KAAK,eAAe,EAA+B,MAAM,wBAAwB,CAAC;AA4QjH,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"}