@shrkcrft/cli 0.1.0-alpha.2

package/dist/commands/orchestrate.command.js

@@ -0,0 +1,49 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildAgentOrchestrationPlan, inspectSharkcraft, OrchestrationMode, renderOrchestrationMarkdown, renderOrchestrationText, } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+export const orchestrateCommand = {
+    name: 'orchestrate',
+    description: 'Produce a read-only agent orchestration plan (discovery / plan / review / apply / validate). No execution; no writes.',
+    usage: 'shrk orchestrate "<task>" [--mode conservative|balanced|aggressive] [--bundle] [--session] [--json] [--output <file.md>]',
+    async run(args) {
+        const task = args.positional.join(' ').trim();
+        if (!task) {
+            process.stderr.write('Usage: shrk orchestrate "<task>"\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const modeRaw = (flagString(args, 'mode') ?? '').toLowerCase();
+        const mode = modeRaw === 'conservative'
+            ? OrchestrationMode.Conservative
+            : modeRaw === 'aggressive'
+                ? OrchestrationMode.Aggressive
+                : OrchestrationMode.Balanced;
+        const riskAware = flagBool(args, 'risk-aware');
+        const plan = await buildAgentOrchestrationPlan(task, inspection, { mode, riskAware });
+        const output = flagString(args, 'output');
+        if (flagBool(args, 'json')) {
+            const body = asJson(plan) + '\n';
+            if (output) {
+                const abs = nodePath.isAbsolute(output) ? output : nodePath.resolve(cwd, output);
+                mkdirSync(nodePath.dirname(abs), { recursive: true });
+                writeFileSync(abs, body, 'utf8');
+                process.stdout.write(`Wrote ${abs}\n`);
+                return 0;
+            }
+            process.stdout.write(body);
+            return 0;
+        }
+        if (output) {
+            const abs = nodePath.isAbsolute(output) ? output : nodePath.resolve(cwd, output);
+            mkdirSync(nodePath.dirname(abs), { recursive: true });
+            writeFileSync(abs, renderOrchestrationMarkdown(plan), 'utf8');
+            process.stdout.write(`Wrote ${abs}\n`);
+            return 0;
+        }
+        process.stdout.write(renderOrchestrationText(plan));
+        return 0;
+    },
+};

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

@@ -0,0 +1,5 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const ownersListCommand: ICommandHandler;
+export declare const ownersMatchCommand: ICommandHandler;
+export declare const ownersImpactCommand: ICommandHandler;
+//# sourceMappingURL=owners.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"owners.command.d.ts","sourceRoot":"","sources":["../../src/commands/owners.command.ts"],"names":[],"mappings":"AASA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAQhC,eAAO,MAAM,iBAAiB,EAAE,eAoB/B,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,eAyBhC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eAmDjC,CAAC"}

package/dist/commands/owners.command.js

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { impactFor, inspectSharkcraft, loadOwnershipRules, matchFile, readFeatureBundle, } from '@shrkcrft/inspector';
+import { flagBool, flagString, flagList, resolveCwd, } from "../command-registry.js";
+import { asJson, header } from "../output/format-output.js";
+function readOwnershipFiles(args) {
+    const list = flagList(args, 'files');
+    return list.length > 0 ? list : undefined;
+}
+export const ownersListCommand = {
+    name: 'list',
+    description: 'List ownership rules.',
+    usage: 'shrk owners list [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const cfg = inspection.config?.ownershipFiles;
+        const { rules, sources, warnings } = await loadOwnershipRules(cwd, cfg);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({ rules, sources, warnings }) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Ownership rules (${rules.length})`));
+        for (const w of warnings)
+            process.stdout.write(`  ! ${w}\n`);
+        for (const r of rules) {
+            process.stdout.write(`  ${r.id}  paths=${r.paths.join(',')}  owners=${r.owners.join(',')}\n`);
+        }
+        return 0;
+    },
+};
+export const ownersMatchCommand = {
+    name: 'match',
+    description: 'Show ownership match for a file.',
+    usage: 'shrk owners match <file>',
+    async run(args) {
+        const file = args.positional[0];
+        if (!file) {
+            process.stderr.write('Usage: shrk owners match <file>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const cfg = inspection.config?.ownershipFiles;
+        const { rules } = await loadOwnershipRules(cwd, cfg);
+        const m = matchFile(file, rules);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(m) + '\n');
+            return 0;
+        }
+        process.stdout.write(`file: ${m.file}\n`);
+        process.stdout.write(`owners: ${m.owners.join(', ') || '(none)'}\n`);
+        process.stdout.write(`reviewers: ${m.reviewers.join(', ') || '(none)'}\n`);
+        process.stdout.write(`requiredReview: ${m.requiredReview}\n`);
+        return 0;
+    },
+};
+export const ownersImpactCommand = {
+    name: 'impact',
+    description: 'Ownership impact for files / plan / bundle.',
+    usage: 'shrk owners impact --files a,b | --plan <plan.json> | --bundle <id>',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const planFile = flagString(args, 'plan');
+        const bundleId = flagString(args, 'bundle');
+        const files = flagList(args, 'files');
+        const all = [...files];
+        if (planFile) {
+            const path = nodePath.isAbsolute(planFile) ? planFile : nodePath.join(cwd, planFile);
+            if (existsSync(path)) {
+                try {
+                    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+                    const changes = parsed.changes ?? parsed.plan?.changes ?? [];
+                    for (const c of changes)
+                        if (c.relativePath)
+                            all.push(c.relativePath);
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        }
+        if (bundleId) {
+            const b = readFeatureBundle(cwd, bundleId);
+            if (b) {
+                for (const f of b.affectedFiles)
+                    all.push(f);
+                for (const p of b.plans)
+                    for (const t of p.expectedTargets)
+                        all.push(t);
+            }
+        }
+        const cfg = inspection.config?.ownershipFiles;
+        const { rules } = await loadOwnershipRules(cwd, cfg);
+        const impact = impactFor([...new Set(all)], rules);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(impact) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Ownership impact (${impact.files.length} files)`));
+        process.stdout.write(`owners: ${impact.owners.join(', ') || '(none)'}\n`);
+        process.stdout.write(`reviewers: ${impact.reviewers.join(', ') || '(none)'}\n`);
+        if (impact.requiredReviewFiles.length > 0) {
+            process.stdout.write(`requiredReview files:\n`);
+            for (const f of impact.requiredReviewFiles)
+                process.stdout.write(`  - ${f}\n`);
+        }
+        // Silence unused-var lint for readOwnershipFiles
+        void readOwnershipFiles;
+        return 0;
+    },
+};

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

@@ -0,0 +1,5 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const ownershipListCommand: ICommandHandler;
+export declare const ownershipForCommand: ICommandHandler;
+export declare const ownershipAffectedCommand: ICommandHandler;
+//# sourceMappingURL=ownership.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ownership.command.d.ts","sourceRoot":"","sources":["../../src/commands/ownership.command.ts"],"names":[],"mappings":"AAQA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAehC,eAAO,MAAM,oBAAoB,EAAE,eAyBlC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eA2BjC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eA4CtC,CAAC"}

package/dist/commands/ownership.command.js

@@ -0,0 +1,117 @@
+import { getChangedFiles, impactFor, inspectSharkcraft, loadOwnershipRules, matchFile, readFeatureBundle, } from '@shrkcrft/inspector';
+import { flagBool, flagString, flagList, resolveCwd, } from "../command-registry.js";
+import { asJson, header } from "../output/format-output.js";
+const DEFAULT_OWNERSHIP_FILES = [
+    'CODEOWNERS',
+    '.github/CODEOWNERS',
+    'docs/CODEOWNERS',
+    'sharkcraft/ownership.ts',
+];
+function configuredFiles(args) {
+    const list = flagList(args, 'files');
+    return list.length > 0 ? list : undefined;
+}
+export const ownershipListCommand = {
+    name: 'list',
+    description: 'List ownership rules from CODEOWNERS / sharkcraft/ownership.ts.',
+    usage: 'shrk ownership list [--json] [--files a,b]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const cfg = inspection.config?.ownershipFiles;
+        const fromArgs = configuredFiles(args);
+        const files = fromArgs ?? cfg ?? DEFAULT_OWNERSHIP_FILES;
+        const r = await loadOwnershipRules(cwd, files);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(r) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Ownership rules (${r.rules.length})`));
+        for (const s of r.sources)
+            process.stdout.write(`  source: ${s}\n`);
+        for (const w of r.warnings)
+            process.stdout.write(`  ! ${w}\n`);
+        for (const rule of r.rules) {
+            process.stdout.write(`  ${rule.id.padEnd(36)}  paths=${rule.paths.join(',')}  owners=${rule.owners.join(',')}\n`);
+        }
+        return 0;
+    },
+};
+export const ownershipForCommand = {
+    name: 'for',
+    description: 'Show ownership match for a single file.',
+    usage: 'shrk ownership for <file> [--json]',
+    async run(args) {
+        const file = args.positional[0];
+        if (!file) {
+            process.stderr.write('Usage: shrk ownership for <file>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const cfg = inspection.config?.ownershipFiles;
+        const fromArgs = configuredFiles(args);
+        const files = fromArgs ?? cfg ?? DEFAULT_OWNERSHIP_FILES;
+        const { rules } = await loadOwnershipRules(cwd, files);
+        const m = matchFile(file, rules);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(m) + '\n');
+            return 0;
+        }
+        process.stdout.write(`file: ${m.file}\n`);
+        process.stdout.write(`owners: ${m.owners.join(', ') || '(none)'}\n`);
+        process.stdout.write(`reviewers: ${m.reviewers.join(', ') || '(none)'}\n`);
+        process.stdout.write(`requiredReview: ${m.requiredReview}\n`);
+        return 0;
+    },
+};
+export const ownershipAffectedCommand = {
+    name: 'affected',
+    description: 'Show owners affected by --since <ref>, --bundle <id>, or --files a,b.',
+    usage: 'shrk ownership affected [--since <ref>] [--bundle <id>] [--files a,b] [--staged] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const since = flagString(args, 'since');
+        const bundleId = flagString(args, 'bundle');
+        const explicit = flagList(args, 'files');
+        const all = [...explicit];
+        if (since) {
+            const opts = { since };
+            if (flagBool(args, 'staged'))
+                opts.staged = true;
+            all.push(...getChangedFiles(cwd, opts));
+        }
+        else if (flagBool(args, 'staged')) {
+            all.push(...getChangedFiles(cwd, { staged: true }));
+        }
+        if (bundleId) {
+            const b = readFeatureBundle(cwd, bundleId);
+            if (b) {
+                for (const f of b.affectedFiles)
+                    all.push(f);
+                for (const p of b.plans)
+                    for (const t of p.expectedTargets)
+                        all.push(t);
+            }
+        }
+        const cfg = inspection.config?.ownershipFiles;
+        const fromArgs = configuredFiles(args);
+        const files = fromArgs ?? cfg ?? DEFAULT_OWNERSHIP_FILES;
+        const { rules } = await loadOwnershipRules(cwd, files);
+        const impact = impactFor([...new Set(all)], rules);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(impact) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Ownership affected (${impact.files.length} files)`));
+        process.stdout.write(`owners: ${impact.owners.join(', ') || '(none)'}\n`);
+        process.stdout.write(`reviewers: ${impact.reviewers.join(', ') || '(none)'}\n`);
+        if (impact.requiredReviewFiles.length > 0) {
+            process.stdout.write(`requiredReview files:\n`);
+            for (const f of impact.requiredReviewFiles)
+                process.stdout.write(`  - ${f}\n`);
+        }
+        return 0;
+    },
+};

package/dist/commands/pack-author.command.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pack asset authoring + pending CLI surface.
+ *
+ *   - `shrk pack author status`
+ *   - `shrk pack author preview --kind <kind> --id <id>`
+ *   - `shrk pack author pending` (alias: `shrk packs pending`)
+ *   - `shrk pack author validate`
+ *
+ * Knowledge supports a full preview; rule and template forward to the
+ * dedicated scaffolders; the remaining kinds return an honest deferral.
+ */
+import { type ICommandHandler } from '../command-registry.js';
+export declare const packAuthorStatusCommand: ICommandHandler;
+export declare const packAuthorPreviewCommand: ICommandHandler;
+export declare const packAuthorPendingCommand: ICommandHandler;
+export declare const packAuthorValidateCommand: ICommandHandler;
+/**
+ * Group dispatcher for `shrk pack author <verb>` — the registry only
+ * supports 2-level commands (group + sub), so we expose `pack author` as
+ * a top-level group whose sub is the verb. The wiring lives in main.ts:
+ *   registerSubcommand('pack-author', packAuthorStatusCommand);
+ * and we alias group: `aliasGroup('pack', 'pack-author')` does not work
+ * because `pack` is already aliased to `packs`. We therefore expose:
+ *   `shrk packs pending` → packAuthorPendingCommand (registered under packs)
+ *   `shrk pack-author <verb>` → registered as the canonical group
+ *   `shrk pack author <verb>` → also a top-level command that internally
+ *     dispatches based on positional[0].
+ */
+export declare const packAuthorTopCommand: ICommandHandler;
+//# sourceMappingURL=pack-author.command.d.ts.map

package/dist/commands/pack-author.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-author.command.d.ts","sourceRoot":"","sources":["../../src/commands/pack-author.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAaH,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAuChC,eAAO,MAAM,uBAAuB,EAAE,eA2BrC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eAoFtC,CAAC;AAKF,eAAO,MAAM,wBAAwB,EAAE,eAgCtC,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,eAgBvC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,EAAE,eA2BlC,CAAC"}

package/dist/commands/pack-author.command.js

@@ -0,0 +1,242 @@
+/**
+ * Pack asset authoring + pending CLI surface.
+ *
+ *   - `shrk pack author status`
+ *   - `shrk pack author preview --kind <kind> --id <id>`
+ *   - `shrk pack author pending` (alias: `shrk packs pending`)
+ *   - `shrk pack author validate`
+ *
+ * Knowledge supports a full preview; rule and template forward to the
+ * dedicated scaffolders; the remaining kinds return an honest deferral.
+ */
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildPackAuthorPreview, buildPackAuthorStatus, buildPackAuthorValidatePlan, buildPackPendingReport, inspectSharkcraft, PackAuthorKind, renderPackPendingMarkdown, } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson, header } from "../output/format-output.js";
+import { rulesScaffoldCommand } from "./rules.command.js";
+import { templatesScaffoldCommand } from "./templates.command.js";
+function parseAuthorKind(value) {
+    switch ((value ?? '').toLowerCase()) {
+        case 'knowledge':
+            return PackAuthorKind.Knowledge;
+        case 'search-tuning':
+            return PackAuthorKind.SearchTuning;
+        case 'feedback-rule':
+            return PackAuthorKind.FeedbackRule;
+        case 'agent-test':
+            return PackAuthorKind.AgentTest;
+        case 'convention':
+            return PackAuthorKind.Convention;
+        case 'task-routing-hint':
+            return PackAuthorKind.TaskRoutingHint;
+        case 'registration-hint':
+            return PackAuthorKind.RegistrationHint;
+        case 'scaffold-pattern':
+            return PackAuthorKind.ScaffoldPattern;
+        default:
+            return null;
+    }
+}
+function isDelegatedKind(value) {
+    return value === 'rule' || value === 'template';
+}
+export const packAuthorStatusCommand = {
+    name: 'status',
+    description: 'Pack author status — kind-by-kind inventory of contributions, pending drafts, and signature state.',
+    usage: 'shrk pack author status [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const status = buildPackAuthorStatus(inspection);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(status) + '\n');
+            return 0;
+        }
+        process.stdout.write(header('Pack author status'));
+        process.stdout.write(`  generated: ${status.generatedAt}\n`);
+        process.stdout.write(`  provenance ledger: ${status.provenanceExists ? 'present' : 'missing'}\n`);
+        process.stdout.write(`  pack secret: ${status.secretAvailable ? 'available' : 'missing'}\n`);
+        process.stdout.write(`  pending drafts: ${status.pendingDrafts}\n`);
+        for (const f of status.pendingDraftFiles)
+            process.stdout.write(`    - ${f}\n`);
+        process.stdout.write('  contribution counts:\n');
+        for (const [k, n] of Object.entries(status.contributionCounts)) {
+            const support = status.authoringSupport[k] ?? 'deferred';
+            process.stdout.write(`    ${k.padEnd(22)} ${String(n).padStart(3)}  (authoring: ${support})\n`);
+        }
+        process.stdout.write('  next commands:\n');
+        for (const c of status.nextCommands)
+            process.stdout.write(`    $ ${c}\n`);
+        return 0;
+    },
+};
+export const packAuthorPreviewCommand = {
+    name: 'preview',
+    description: 'Pack author preview. Rule and template kinds forward to `rules scaffold` / `templates scaffold` (no deferred stub). Knowledge uses the dedicated preview path.',
+    usage: 'shrk pack author preview --kind <kind> --id <id> [--title <t>] [--reason <text>] [--write-preview] [--json]',
+    async run(args) {
+        const rawKind = (flagString(args, 'kind') ?? '').toLowerCase();
+        const id = flagString(args, 'id') ?? args.positional[0];
+        if (!id) {
+            process.stderr.write('Missing --id <id>.\n');
+            return 2;
+        }
+        // Rule kind: forward to `shrk rules scaffold`.
+        if (rawKind === 'rule') {
+            const forwarded = {
+                positional: [],
+                flags: new Map(args.flags),
+                multiFlags: new Map(args.multiFlags),
+                ...(args.globalCwd ? { globalCwd: args.globalCwd } : {}),
+            };
+            forwarded.flags.set('id', id);
+            // `rules scaffold` accepts the same `--title`/`--reason`/`--write-preview` flags.
+            const exit = await rulesScaffoldCommand.run(forwarded);
+            if (!flagBool(args, 'json')) {
+                process.stdout.write('\nNext (post-scaffold):\n');
+                process.stdout.write(`  $ shrk apply --asset-preview .sharkcraft/fixes/rule-add-${id.replace(/[^a-z0-9.-]/gi, '-').toLowerCase()}.draft.ts --target sharkcraft/rules.ts\n`);
+                process.stdout.write('  $ shrk packs signature-status\n');
+                process.stdout.write('  $ shrk provenance show ' + id + '\n');
+            }
+            return exit;
+        }
+        // Template kind: forward to `shrk templates scaffold`.
+        if (rawKind === 'template') {
+            const forwarded = {
+                positional: [],
+                flags: new Map(args.flags),
+                multiFlags: new Map(args.multiFlags),
+                ...(args.globalCwd ? { globalCwd: args.globalCwd } : {}),
+            };
+            forwarded.flags.set('id', id);
+            const exit = await templatesScaffoldCommand.run(forwarded);
+            if (!flagBool(args, 'json')) {
+                const slug = id.replace(/[^a-z0-9.-]/gi, '-').toLowerCase();
+                process.stdout.write('\nNext (post-scaffold):\n');
+                process.stdout.write(`  $ shrk apply --asset-preview .sharkcraft/authoring/templates/${slug}.draft.ts --target sharkcraft/templates.ts\n`);
+                process.stdout.write('  $ shrk packs signature-status\n');
+                process.stdout.write('  $ shrk provenance show ' + id + '\n');
+            }
+            return exit;
+        }
+        // Knowledge + remaining kinds keep the existing dispatcher.
+        const kind = parseAuthorKind(rawKind);
+        if (!kind) {
+            process.stderr.write('Missing or unknown --kind. Use one of: knowledge, rule, template, search-tuning, feedback-rule, agent-test, convention, task-routing-hint, registration-hint, scaffold-pattern.\n');
+            return 2;
+        }
+        const preview = buildPackAuthorPreview({
+            kind,
+            assetId: id,
+            ...(flagString(args, 'reason') ? { reason: flagString(args, 'reason') ?? undefined } : {}),
+        });
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(preview) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Pack author preview: ${kind} ${id}`));
+        process.stdout.write(`  implemented: ${preview.implemented}\n`);
+        if (!preview.implemented && preview.deferralNote) {
+            process.stdout.write(`  note: ${preview.deferralNote}\n`);
+        }
+        process.stdout.write('\n  next commands:\n');
+        for (const c of preview.nextCommands)
+            process.stdout.write(`    $ ${c}\n`);
+        return 0;
+    },
+};
+// Silence the unused import when isDelegatedKind is the only public use.
+void isDelegatedKind;
+export const packAuthorPendingCommand = {
+    name: 'pending',
+    description: 'Pack pending state — modified files, pending drafts, stale signatures, pending provenance, missing-secret guidance.',
+    usage: 'shrk pack author pending [--write-todo] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const report = buildPackPendingReport(inspection);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(report) + '\n');
+        }
+        else {
+            process.stdout.write(renderPackPendingMarkdown(report));
+        }
+        if (flagBool(args, 'write-todo') && report.secretMissingHint) {
+            const reportsDir = nodePath.join(cwd, '.sharkcraft', 'reports');
+            if (!existsSync(reportsDir))
+                mkdirSync(reportsDir, { recursive: true });
+            const todoPath = nodePath.join(reportsDir, 'pack-signing-todo.md');
+            const lines = [];
+            lines.push('# Pack signing TODO');
+            lines.push('');
+            lines.push(report.secretMissingHint);
+            lines.push('');
+            lines.push('## Next commands');
+            lines.push('');
+            for (const c of report.nextCommands)
+                lines.push(`- \`${c}\``);
+            lines.push('');
+            writeFileSync(todoPath, lines.join('\n'), 'utf8');
+            process.stdout.write(`\nWrote signing TODO at ${nodePath.relative(cwd, todoPath)}\n`);
+        }
+        return 0;
+    },
+};
+export const packAuthorValidateCommand = {
+    name: 'validate',
+    description: 'Recommended validation commands after authoring. Read-only — does not execute commands.',
+    usage: 'shrk pack author validate [--json]',
+    async run(args) {
+        const plan = buildPackAuthorValidatePlan();
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(plan) + '\n');
+            return 0;
+        }
+        process.stdout.write(header('Pack author validate plan'));
+        process.stdout.write(`  ok: ${plan.ok}\n`);
+        process.stdout.write('  recommended commands:\n');
+        for (const c of plan.recommendedCommands)
+            process.stdout.write(`    $ ${c}\n`);
+        return 0;
+    },
+};
+/**
+ * Group dispatcher for `shrk pack author <verb>` — the registry only
+ * supports 2-level commands (group + sub), so we expose `pack author` as
+ * a top-level group whose sub is the verb. The wiring lives in main.ts:
+ *   registerSubcommand('pack-author', packAuthorStatusCommand);
+ * and we alias group: `aliasGroup('pack', 'pack-author')` does not work
+ * because `pack` is already aliased to `packs`. We therefore expose:
+ *   `shrk packs pending` → packAuthorPendingCommand (registered under packs)
+ *   `shrk pack-author <verb>` → registered as the canonical group
+ *   `shrk pack author <verb>` → also a top-level command that internally
+ *     dispatches based on positional[0].
+ */
+export const packAuthorTopCommand = {
+    name: 'pack',
+    description: 'Alias: dispatches `pack author <verb>` to the pack-author commands.',
+    usage: 'shrk pack author <status|preview|pending|validate> [...]',
+    async run(args) {
+        if (args.positional[0] !== 'author') {
+            process.stderr.write('Usage: shrk pack author <status|preview|pending|validate>\n');
+            return 2;
+        }
+        const verb = args.positional[1];
+        args.positional = args.positional.slice(2);
+        switch (verb) {
+            case 'status':
+                return packAuthorStatusCommand.run(args);
+            case 'preview':
+                return packAuthorPreviewCommand.run(args);
+            case 'pending':
+                return packAuthorPendingCommand.run(args);
+            case 'validate':
+                return packAuthorValidateCommand.run(args);
+            default:
+                process.stderr.write(`Unknown pack author verb: ${verb ?? '(missing)'}\n`);
+                process.stderr.write('Valid verbs: status, preview, pending, validate.\n');
+                return 2;
+        }
+    },
+};

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

@@ -0,0 +1,27 @@
+import { type ICommandHandler } from '../command-registry.js';
+export type PackKind = 'generic' | 'framework' | 'architecture' | 'enterprise' | 'platform-adopter';
+interface IScaffoldFile {
+    /** Path relative to the new pack root. */
+    relativePath: string;
+    body: string;
+}
+export interface IScaffoldPackInput {
+    name: string;
+    outDir: string;
+    scope?: string;
+    kind: PackKind;
+    preset?: string;
+    withExamples?: boolean;
+    force?: boolean;
+}
+export interface IScaffoldPackResult {
+    files: IScaffoldFile[];
+    packageJson: Record<string, unknown>;
+    packRoot: string;
+}
+/** Pure: compute the file set to write. No IO. */
+export declare function planPackScaffold(input: IScaffoldPackInput): IScaffoldPackResult;
+export declare const packsNewCommand: ICommandHandler;
+export declare const packsTestCommand: ICommandHandler;
+export {};
+//# sourceMappingURL=packs-new.d.ts.map

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

@@ -0,0 +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;AAGhC,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"}