@shrkcrft/cli 0.1.0-alpha.2

package/dist/commands/recommend.command.js

@@ -0,0 +1,270 @@
+import { readFileSync } from 'node:fs';
+import { buildUniversalSearch, entrypointBanner, explainTaskRouting, inspectSharkcraft, recommendCommands, renderUncertaintyReportText, } from '@shrkcrft/inspector';
+import { flagBool, flagNumber, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+import { loadSurfaceContext } from "../surface/load-surface-context.js";
+import { buildSurfaceSummary, findCommandInSummary, } from "../surface/surface-summary.js";
+export const recommendCommand = {
+    name: 'recommend',
+    description: 'Recommend commands based on a free-form query, role, or stderr blob. Deterministic — no AI.',
+    usage: 'shrk recommend "<what I want to do>" [--from-error <stderr-file>] [--role developer|reviewer|architect|release-manager|security|ai-agent] [--json]',
+    async run(args) {
+        const query = args.positional.join(' ').trim();
+        const fromErrorFile = flagString(args, 'from-error');
+        let fromError = '';
+        if (fromErrorFile) {
+            try {
+                fromError = readFileSync(fromErrorFile, 'utf8');
+            }
+            catch (err) {
+                process.stderr.write(`Failed to read --from-error file: ${err instanceof Error ? err.message : String(err)}\n`);
+                return 1;
+            }
+        }
+        if (!query && !fromError) {
+            process.stderr.write('Usage: shrk recommend "<query>" or --from-error <file>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const role = flagString(args, 'role');
+        const reportRaw = await recommendCommands(inspection, query || fromError, {
+            ...(fromError ? { fromError } : {}),
+            ...(role ? { role } : {}),
+        });
+        // DX#2 — when the task text looks like a planning thread (planning
+        // verb at the start, or a "plan/design/review for X" shape), prepend
+        // `shrk grounding "<task>"` as the top recommendation. The existing
+        // recommender output slides down. Pure-text classifier; no LLM.
+        if (query.length > 0 && looksLikePlanning(query)) {
+            const groundingRec = {
+                command: `shrk grounding "${query.replace(/"/g, '\\"')}" --json`,
+                why: 'DX#2: query looks like planning — start with grounding (task-relevant rules / knowledge / templates / verification IDs) before picking a write verb.',
+                safetyLevel: 'read-only',
+            };
+            // Avoid duplicating if the recommender already surfaced grounding.
+            const alreadyHasGrounding = reportRaw.recommendations.some((r) => r.command.startsWith('shrk grounding') || r.command.startsWith('bun run shrk grounding'));
+            if (!alreadyHasGrounding) {
+                reportRaw.recommendations = [
+                    groundingRec,
+                    ...reportRaw.recommendations,
+                ];
+            }
+        }
+        // Gate by surface tier. Recommendations whose underlying command is
+        // experimental + not enabled get moved to a "gated" bucket with an
+        // enable hint. Callable ones stay in `recommendations`.
+        const { context: surfaceContext } = await loadSurfaceContext({ cwd, inspection });
+        const surface = buildSurfaceSummary(surfaceContext);
+        const includeGated = flagBool(args, 'include-gated');
+        const { keep, gated } = partitionByCallable(reportRaw.recommendations, surface, includeGated);
+        const report = { ...reportRaw, recommendations: keep };
+        // Combine recommender output with routing hints + universal search.
+        const wantsCommandsFirst = flagBool(args, 'commands-first');
+        const actionsOnly = flagBool(args, 'actions-only');
+        const machineJson = flagBool(args, 'json') || flagBool(args, 'machine-json');
+        let routingMatches = [];
+        let searchReport = null;
+        if (query.length > 0) {
+            try {
+                routingMatches = await explainTaskRouting(inspection, query);
+            }
+            catch {
+                // ignore
+            }
+            try {
+                searchReport = await buildUniversalSearch(inspection, query, {});
+            }
+            catch {
+                searchReport = null;
+            }
+        }
+        if (machineJson) {
+            process.stdout.write(asJson({
+                ...report,
+                routingMatches,
+                search: searchReport,
+                gated,
+            }) + '\n');
+            return 0;
+        }
+        // Default human output: verdict + top 3 commands + next command +
+        // details flag. `--verbose` / `--full` brings back the long form.
+        const verbose = flagBool(args, 'verbose') || flagBool(args, 'full');
+        const topN = flagNumber(args, 'top') ?? (verbose ? report.recommendations.length : 3);
+        const visibleRecs = report.recommendations.slice(0, topN);
+        if (!actionsOnly) {
+            // Entrypoint banner: promote shrk recommend as the human entrypoint.
+            process.stdout.write(`(${entrypointBanner('recommend')})\n\n`);
+            process.stdout.write(`=== Recommended commands (top ${visibleRecs.length}) ===\n`);
+            for (const r of visibleRecs) {
+                if (verbose) {
+                    process.stdout.write(`  $ ${r.command}\n    why: ${r.why}\n    safety: ${r.safetyLevel}\n`);
+                    if (r.docsLink)
+                        process.stdout.write(`    docs: ${r.docsLink}\n`);
+                }
+                else {
+                    process.stdout.write(`  $ ${r.command}  [${r.safetyLevel}] — ${r.why}\n`);
+                }
+            }
+            if (report.recommendations.length > visibleRecs.length) {
+                process.stdout.write(`  … (${report.recommendations.length - visibleRecs.length} more — pass --verbose to see all)\n`);
+            }
+        }
+        if (routingMatches.length > 0 && !actionsOnly && verbose) {
+            process.stdout.write('\nRouting hints:\n');
+            for (const m of routingMatches.slice(0, 5)) {
+                process.stdout.write(`  • ${m.hint.id}  (score=${m.score})  ${m.hint.title}\n`);
+            }
+        }
+        if (searchReport && !actionsOnly && verbose) {
+            const top = (searchReport.sections.bestActions ?? []).slice(0, 5);
+            if (top.length > 0) {
+                process.stdout.write('\nBest actions (from universal search):\n');
+                for (const a of top) {
+                    const action = a.action ?? a.command;
+                    if (action)
+                        process.stdout.write(`  • ${action}\n`);
+                }
+            }
+        }
+        // Coverage gap — explicit if recommendations look thin and no routing hint fired.
+        if (report.recommendations.length <= 1 &&
+            routingMatches.length === 0 &&
+            query.length > 0) {
+            process.stdout.write(`\n⚠ Coverage gap — no recipe, no routing hint, and no helper/template matched "${query}".\n` +
+                `  Suggest:\n` +
+                `    shrk coverage scaffolds --task "${query}"\n` +
+                `    shrk feedback actions\n` +
+                `    (or contribute a pack template / helper / routing hint)\n`);
+        }
+        if (gated.length > 0 && !actionsOnly) {
+            process.stdout.write(`\nGated (experimental, not enabled in this repo):\n`);
+            for (const g of gated.slice(0, 3)) {
+                process.stdout.write(`  $ ${g.command}  — ${g.why}\n`);
+                process.stdout.write(`      Enable: shrk surface enable ${g.viewCommand} --write\n`);
+            }
+            if (gated.length > 3) {
+                process.stdout.write(`  … (${gated.length - 3} more — pass --include-gated --json to inspect)\n`);
+            }
+        }
+        process.stdout.write(`\nNext command:\n  $ ${report.nextCommand}\n`);
+        if (!actionsOnly && verbose) {
+            process.stdout.write('\n' + renderUncertaintyReportText(report.uncertainty) + '\n');
+        }
+        else if (!actionsOnly) {
+            // Tighten the default — show count + one-liner pointer to detail.
+            const u = report.uncertainty;
+            const issues = u.missingSignals.length + u.conflictingSignals.length;
+            if (issues > 0) {
+                process.stdout.write(`\nUncertainty: ${u.confidence} confidence, ${issues} signal(s) — pass --verbose for the full report.\n`);
+            }
+        }
+        if (wantsCommandsFirst) {
+            // commands-first formatting was the default — nothing more to do.
+        }
+        return 0;
+    },
+};
+/**
+ * Partition recommender output by whether the underlying CLI command is
+ * callable in this project's surface. Gated commands (experimental +
+ * not in `surface.enabled[]`) are moved to a separate bucket the
+ * renderer surfaces with an enable hint. Callable commands (core,
+ * extended, or already-enabled experimental) stay in `keep`.
+ *
+ * The match strategy: extract the first 1-2 tokens after `shrk` from
+ * `command`. Try the full path then the top-level token (mirrors the
+ * resolver's behavior in main.ts).
+ */
+function partitionByCallable(recs, summary, includeGated) {
+    const keep = [];
+    const gated = [];
+    for (const r of recs) {
+        const view = resolveView(r.command, summary);
+        if (!view || view.callable) {
+            keep.push(r);
+            continue;
+        }
+        if (includeGated)
+            keep.push(r);
+        gated.push({
+            command: r.command,
+            viewCommand: view.command,
+            why: r.why ?? '',
+            enableHint: `shrk surface enable ${view.command} --write`,
+        });
+    }
+    return { keep, gated };
+}
+function resolveView(rawCommand, summary) {
+    const tokens = rawCommand.trim().split(/\s+/).filter(Boolean);
+    if (tokens.length === 0)
+        return undefined;
+    // Drop leading `shrk` / `bun run shrk` / `$`
+    let i = 0;
+    if (tokens[i] === '$')
+        i += 1;
+    if (tokens[i] === 'bun' && tokens[i + 1] === 'run')
+        i += 2;
+    if (tokens[i] === 'shrk')
+        i += 1;
+    const verbTokens = [];
+    for (let j = i; j < tokens.length; j += 1) {
+        const t = tokens[j];
+        if (t.startsWith('-') || t.startsWith('<') || t.startsWith('"'))
+            break;
+        verbTokens.push(t);
+        if (verbTokens.length >= 2)
+            break;
+    }
+    if (verbTokens.length === 0)
+        return undefined;
+    const fullPath = verbTokens.join(' ');
+    return findCommandInSummary(summary, fullPath) ?? findCommandInSummary(summary, verbTokens[0]);
+}
+/**
+ * DX#2 — detect "planning" intent in a task string.
+ *
+ * Triggers on:
+ *   - a leading verb from the planning set (plan/design/review/audit/…)
+ *   - the same verb appearing in "plan for X" / "design X" patterns
+ *
+ * Pure heuristic. No LLM. Conservative — false negatives are fine
+ * (the original ranker still fires); false positives just push an extra
+ * read-only suggestion that the user can ignore.
+ */
+const PLANNING_VERBS = new Set([
+    'plan',
+    'design',
+    'propose',
+    'review',
+    'audit',
+    'analyze',
+    'analyse',
+    'explore',
+    'consider',
+    'investigate',
+    'survey',
+    'compare',
+    'evaluate',
+    'assess',
+]);
+export function looksLikePlanning(query) {
+    const tokens = query
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, ' ')
+        .split(/\s+/)
+        .filter((t) => t.length > 0);
+    if (tokens.length === 0)
+        return false;
+    // Leading verb form: "plan a thing", "design the system".
+    if (PLANNING_VERBS.has(tokens[0]))
+        return true;
+    // "Help me plan X" / "I want to design Y" — verb in slots 1–3.
+    for (let i = 1; i < Math.min(4, tokens.length); i++) {
+        if (PLANNING_VERBS.has(tokens[i]))
+            return true;
+    }
+    return false;
+}

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

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

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

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

package/dist/commands/registrations.command.js

@@ -0,0 +1,300 @@
+/**
+ * `shrk registrations` subcommands.
+ *
+ * Pack-driven registration hints describe downstream registration steps that
+ * generated constructs typically need (e.g. composer wiring, route entries).
+ * The engine never auto-applies a hint; the human applies after preview.
+ *
+ *   shrk registrations list      [--source local|pack] [--json]
+ *   shrk registrations get <id>  [--json]
+ *   shrk registrations doctor    [--json]
+ *   shrk registrations preview <id> [--var key=value ...] [--json]
+ */
+import * as nodePath from 'node:path';
+import { inspectSharkcraft, listRegistrationHints, listRegistrationHintIssues, getRegistrationHint, previewRegistrationHint, } from '@shrkcrft/inspector';
+import { flagBool, flagString, flagVars, resolveCwd, } from "../command-registry.js";
+import { asJson, header } from "../output/format-output.js";
+import { savePlanToFile, signPlan } from '@shrkcrft/generator';
+const REGISTRATION_HINT_SYNTHETIC_TEMPLATE = '__registration-hint__';
+const registrationsListCommand = {
+    name: 'list',
+    description: 'List registered registration hints (local + pack).',
+    usage: 'shrk registrations list [--source local|pack] [--json]',
+    async run(args) {
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const source = flagString(args, 'source');
+        const all = await listRegistrationHints(inspection);
+        const filtered = source ? all.filter((e) => e.source === source) : all;
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(filtered) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Registration hints (${filtered.length})`));
+        for (const e of filtered) {
+            process.stdout.write(`  • ${e.hint.id.padEnd(36)} ${e.hint.title}${e.source === 'pack' && e.packageName ? `  [pack:${e.packageName}]` : ''}\n`);
+        }
+        if (filtered.length === 0) {
+            process.stdout.write('  (no registration hints contributed — packs add them via registrationHintFiles[])\n');
+        }
+        return 0;
+    },
+};
+const registrationsGetCommand = {
+    name: 'get',
+    description: 'Show a registration hint by id.',
+    usage: 'shrk registrations get <id> [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk registrations get <id>\n');
+            return 2;
+        }
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const entry = await getRegistrationHint(inspection, id);
+        if (!entry) {
+            process.stderr.write(`Registration hint "${id}" not found.\n`);
+            return 1;
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(entry) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Registration hint: ${entry.hint.id}`));
+        process.stdout.write(`  title         ${entry.hint.title}\n`);
+        if (entry.hint.description)
+            process.stdout.write(`  description   ${entry.hint.description}\n`);
+        process.stdout.write(`  source        ${entry.source}${entry.packageName ? ` (${entry.packageName})` : ''}\n`);
+        if (entry.hint.discovery.targetFile) {
+            process.stdout.write(`  target file   ${entry.hint.discovery.targetFile}\n`);
+        }
+        if (entry.hint.discovery.targetGlobs && entry.hint.discovery.targetGlobs.length > 0) {
+            process.stdout.write(`  target globs  ${entry.hint.discovery.targetGlobs.join(', ')}\n`);
+        }
+        if (entry.hint.requiresHumanReview) {
+            process.stdout.write(`  ⚠ requires human review\n`);
+        }
+        process.stdout.write('\nOperations:\n');
+        for (const op of entry.hint.operations) {
+            process.stdout.write(`  • ${op.kind}${op.anchor ? `  anchor="${op.anchor}"` : ''}\n`);
+        }
+        if (entry.hint.validationCommands && entry.hint.validationCommands.length > 0) {
+            process.stdout.write('\nValidation commands:\n');
+            for (const c of entry.hint.validationCommands)
+                process.stdout.write(`  $ ${c}\n`);
+        }
+        return 0;
+    },
+};
+const registrationsDoctorCommand = {
+    name: 'doctor',
+    description: 'Validate registration hint registries (local + pack).',
+    usage: 'shrk registrations doctor [--json]',
+    async run(args) {
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const issues = await listRegistrationHintIssues(inspection);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({ issues }) + '\n');
+            return issues.some((i) => i.severity === 'error') ? 1 : 0;
+        }
+        process.stdout.write(header(`Registration hint doctor (${issues.length} issue(s))`));
+        if (issues.length === 0) {
+            process.stdout.write('  OK\n');
+            return 0;
+        }
+        for (const i of issues) {
+            process.stdout.write(`  ${i.severity.toUpperCase().padEnd(7)} ${i.code.padEnd(28)} ${i.message}\n`);
+        }
+        return issues.some((i) => i.severity === 'error') ? 1 : 0;
+    },
+};
+const registrationsPreviewCommand = {
+    name: 'preview',
+    description: 'Preview a registration hint against the live file system. Read-only — no edits are made.',
+    usage: 'shrk registrations preview <id> [--var key=value ...] [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk registrations preview <id>\n');
+            return 2;
+        }
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const variables = flagVars(args);
+        const preview = await previewRegistrationHint(inspection, id, { variables });
+        if (!preview) {
+            process.stderr.write(`Registration hint "${id}" not found.\n`);
+            return 1;
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(preview) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Registration hint preview: ${preview.hintId}`));
+        process.stdout.write(`  title           ${preview.title}\n`);
+        process.stdout.write(`  target file     ${preview.targetFile ?? '(ambiguous — multiple candidates)'}\n`);
+        if (preview.candidates.length > 1) {
+            process.stdout.write(`  candidates      ${preview.candidates.length}\n`);
+            for (const c of preview.candidates)
+                process.stdout.write(`    • ${c}\n`);
+        }
+        process.stdout.write(`  ambiguous       ${preview.ambiguous ? 'YES' : 'no'}\n`);
+        process.stdout.write(`  human review    ${preview.requiresHumanReview ? 'required' : 'optional'}\n`);
+        if (preview.missingVariables.length > 0) {
+            process.stdout.write(`\n  ⚠ missing required variables: ${preview.missingVariables.join(', ')}\n`);
+        }
+        process.stdout.write('\nOperations:\n');
+        for (const op of preview.operations) {
+            process.stdout.write(`  • ${op.description}\n`);
+            if (op.snippet) {
+                const snippet = op.snippet.split('\n').map((l) => '      ' + l).join('\n');
+                process.stdout.write(snippet + '\n');
+            }
+        }
+        if (preview.safetyNotes.length > 0) {
+            process.stdout.write('\nSafety notes:\n');
+            for (const s of preview.safetyNotes)
+                process.stdout.write(`  • ${s}\n`);
+        }
+        if (preview.validationCommands.length > 0) {
+            process.stdout.write('\nValidation commands:\n');
+            for (const c of preview.validationCommands)
+                process.stdout.write(`  $ ${c}\n`);
+        }
+        process.stdout.write(`\n${preview.nextCommand}\n`);
+        return 0;
+    },
+};
+const registrationsPlanCommand = {
+    name: 'plan',
+    description: 'Emit a saved plan from a registration hint. Ambiguous targets must be resolved by passing --target <file>. Read-only at the inspector level; the resulting saved plan flows through `shrk apply --verify-signature` like any other plan.',
+    usage: 'shrk registrations plan <id> [--target <file>] [--var key=value ...] [--save-plan <file>] [--sign] [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk registrations plan <id> [--target <file>]\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const entry = await getRegistrationHint(inspection, id);
+        if (!entry) {
+            process.stderr.write(`Registration hint "${id}" not found.\n`);
+            return 1;
+        }
+        const target = flagString(args, 'target');
+        const variables = flagVars(args);
+        const preview = await previewRegistrationHint(inspection, id, { variables });
+        if (!preview) {
+            process.stderr.write(`Failed to build preview for "${id}".\n`);
+            return 1;
+        }
+        // Ambiguous target must be refused unless --target is given.
+        if (preview.ambiguous && !target) {
+            if (flagBool(args, 'json')) {
+                process.stdout.write(asJson({
+                    error: 'ambiguous-target',
+                    hintId: id,
+                    candidates: preview.candidates,
+                    suggestion: `Pass --target <file> to pick one of the ${preview.candidates.length} candidates.`,
+                }) + '\n');
+            }
+            else {
+                process.stderr.write(`Registration hint "${id}" has ${preview.candidates.length} candidate target files; pass --target <file>:\n`);
+                for (const c of preview.candidates)
+                    process.stderr.write(`  • ${c}\n`);
+            }
+            return 1;
+        }
+        // Missing target -> conflict.
+        const resolvedTarget = target ?? preview.targetFile;
+        if (!resolvedTarget) {
+            process.stderr.write(`Registration hint "${id}" has no resolvable target (no targetFile, no --target).\n`);
+            return 1;
+        }
+        if (preview.missingVariables.length > 0) {
+            process.stderr.write(`Missing required variables: ${preview.missingVariables.join(', ')}\n`);
+            return 1;
+        }
+        // Build the saved plan: each hint operation becomes an expectedChange
+        // against the resolved target file.
+        const expectedChanges = preview.operations.map((op) => {
+            const operation = { kind: op.kind };
+            if (op.anchor !== undefined)
+                operation['anchor'] = op.anchor;
+            if (op.snippet !== undefined)
+                operation['snippet'] = op.snippet;
+            const sizeBytes = op.snippet ? Buffer.byteLength(op.snippet, 'utf8') : 0;
+            return {
+                type: op.kind,
+                relativePath: resolvedTarget,
+                sizeBytes,
+                operation,
+            };
+        });
+        const saved = {
+            schema: 'sharkcraft.plan/v2',
+            templateId: REGISTRATION_HINT_SYNTHETIC_TEMPLATE,
+            variables: { hintId: id, target: resolvedTarget, ...variables },
+            projectRoot: cwd,
+            createdAt: new Date().toISOString(),
+            expectedChanges,
+            note: preview.requiresHumanReview ? 'Human review required before apply.' : undefined,
+        };
+        const savePlanPath = flagString(args, 'save-plan');
+        if (savePlanPath) {
+            let toWrite = saved;
+            if (flagBool(args, 'sign')) {
+                const signed = signPlan(toWrite);
+                if (signed.ok)
+                    toWrite = signed.value;
+            }
+            const abs = nodePath.isAbsolute(savePlanPath)
+                ? savePlanPath
+                : nodePath.resolve(cwd, savePlanPath);
+            const writeResult = savePlanToFile(toWrite, abs);
+            if (!writeResult.ok) {
+                process.stderr.write(`Failed to save plan: ${writeResult.error.message}\n`);
+                return 1;
+            }
+            if (!flagBool(args, 'json')) {
+                process.stdout.write(`Saved registration-hint plan to ${abs}\n`);
+                process.stdout.write(`Apply: shrk apply ${abs} --verify-signature\n`);
+            }
+            else {
+                process.stdout.write(asJson({ saved: abs, plan: saved }) + '\n');
+            }
+            return 0;
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(saved) + '\n');
+        }
+        else {
+            process.stdout.write(header(`Registration hint plan: ${id}`));
+            process.stdout.write(`  target file     ${resolvedTarget}\n`);
+            process.stdout.write(`  human review    ${preview.requiresHumanReview ? 'required' : 'optional'}\n`);
+            process.stdout.write(`  operations      ${expectedChanges.length}\n`);
+            process.stdout.write('\nPass --save-plan <file> to write the saved plan.\n');
+        }
+        return 0;
+    },
+};
+export const registrationsCommand = {
+    name: 'registrations',
+    description: 'Inspect/preview/plan pack-contributed registration hints (downstream registration steps for generated constructs).',
+    usage: 'shrk registrations <list|get|doctor|preview|plan> ...',
+    async run(args) {
+        const sub = args.positional[0];
+        const rest = { ...args, positional: args.positional.slice(1) };
+        if (sub === 'list')
+            return (await registrationsListCommand.run(rest));
+        if (sub === 'get')
+            return (await registrationsGetCommand.run(rest));
+        if (sub === 'doctor')
+            return (await registrationsDoctorCommand.run(rest));
+        if (sub === 'preview')
+            return (await registrationsPreviewCommand.run(rest));
+        if (sub === 'plan')
+            return (await registrationsPlanCommand.run(rest));
+        process.stderr.write('Usage: shrk registrations <list|get|doctor|preview|plan> ...\n');
+        return 2;
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.command.d.ts","sourceRoot":"","sources":["../../src/commands/registry.command.ts"],"names":[],"mappings":"AASA,OAAO,EAGL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAGhC,eAAO,MAAM,wBAAwB,EAAE,eActC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,eAa7B,CAAC"}

package/dist/commands/registry.command.js

@@ -0,0 +1,37 @@
+/**
+ * `shrk registry` commands.
+ *
+ *   shrk registry lifecycle [--json]
+ */
+import { buildRegistryLifecycleReport, renderRegistryLifecycleReportText, } from '@shrkcrft/inspector';
+import { flagBool, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+export const registryLifecycleCommand = {
+    name: 'lifecycle',
+    description: 'Scan the workspace for register*/remove* symmetry. Read-only.',
+    usage: 'shrk registry lifecycle [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const report = buildRegistryLifecycleReport({ projectRoot: cwd });
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(report) + '\n');
+            return report.missingRemovers.length === 0 ? 0 : 1;
+        }
+        process.stdout.write(renderRegistryLifecycleReportText(report));
+        return report.missingRemovers.length === 0 ? 0 : 1;
+    },
+};
+export const registryCommand = {
+    name: 'registry',
+    description: 'Registry inspections (lifecycle symmetry, etc.). Read-only.',
+    usage: 'shrk registry lifecycle',
+    async run(args) {
+        const sub = args.positional[0];
+        if (sub === 'lifecycle') {
+            args.positional = args.positional.slice(1);
+            return registryLifecycleCommand.run(args);
+        }
+        process.stderr.write('Usage: shrk registry lifecycle\n');
+        return 2;
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"release.command.d.ts","sourceRoot":"","sources":["../../src/commands/release.command.ts"],"names":[],"mappings":"AA2BA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA2pBhC,eAAO,MAAM,cAAc,EAAE,eAY5B,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eAKjC,CAAC"}