@shrkcrft/cli 0.1.0-alpha.1

package/dist/commands/export-bundle.command.js

@@ -0,0 +1,96 @@
+import * as nodePath from 'node:path';
+import { exportDevSession, exportFeatureBundle, exportQuality, exportReview, inspectSharkcraft, buildQualityReport, } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+function outputDir(args, cwd, fallback) {
+    return flagString(args, 'output') ?? nodePath.join(cwd, '.sharkcraft', 'exports', fallback);
+}
+export const exportBundleCommand = {
+    name: 'bundle',
+    description: 'Export a feature bundle to a folder.',
+    usage: 'shrk export bundle <id> [--output <dir>]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk export bundle <id>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const dir = outputDir(args, cwd, `bundle-${id}`);
+        const r = exportFeatureBundle(cwd, id, dir);
+        if (!r) {
+            process.stderr.write(`No bundle "${id}"\n`);
+            return 1;
+        }
+        if (flagBool(args, 'json'))
+            process.stdout.write(asJson(r) + '\n');
+        else
+            process.stdout.write(`Exported ${r.files.length} file(s) → ${r.outputDir}\n`);
+        return 0;
+    },
+};
+export const exportSessionCommand = {
+    name: 'session',
+    description: 'Export a dev session to a folder.',
+    usage: 'shrk export session <id> [--output <dir>]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk export session <id>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const dir = outputDir(args, cwd, `session-${id}`);
+        const r = exportDevSession(cwd, id, dir);
+        if (!r) {
+            process.stderr.write(`No session "${id}"\n`);
+            return 1;
+        }
+        if (flagBool(args, 'json'))
+            process.stdout.write(asJson(r) + '\n');
+        else
+            process.stdout.write(`Exported ${r.files.length} file(s) → ${r.outputDir}\n`);
+        return 0;
+    },
+};
+export const exportQualityCommand = {
+    name: 'quality',
+    description: 'Export current quality report to a folder.',
+    usage: 'shrk export quality [--output <dir>]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const report = await buildQualityReport({ inspection, config: {} });
+        const dir = outputDir(args, cwd, `quality-${new Date().toISOString().slice(0, 10)}`);
+        const r = exportQuality(cwd, dir, report);
+        if (flagBool(args, 'json'))
+            process.stdout.write(asJson(r) + '\n');
+        else
+            process.stdout.write(`Exported quality → ${r.outputDir}\n`);
+        return 0;
+    },
+};
+export const exportReviewCommand = {
+    name: 'review',
+    description: 'Export a review packet to a folder.',
+    usage: 'shrk export review <packet.json> [--output <dir>]',
+    async run(args) {
+        const file = args.positional[0];
+        if (!file) {
+            process.stderr.write('Usage: shrk export review <packet.json>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const dir = outputDir(args, cwd, `review-${new Date().toISOString().slice(0, 10)}`);
+        const r = exportReview(cwd, file, dir);
+        if (!r) {
+            process.stderr.write(`Packet not found: ${file}\n`);
+            return 1;
+        }
+        if (flagBool(args, 'json'))
+            process.stdout.write(asJson(r) + '\n');
+        else
+            process.stdout.write(`Exported review → ${r.outputDir}\n`);
+        return 0;
+    },
+};

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

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

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

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

package/dist/commands/export.command.js

@@ -0,0 +1,83 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { inspectSharkcraft } from '@shrkcrft/inspector';
+import { ALL_EXPORT_FORMATS, isExportFormat, renderExport, } from "../export/export-formats.js";
+import { flagBool, flagNumber, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson, header } from "../output/format-output.js";
+import { exportBundleCommand, exportSessionCommand, exportQualityCommand, exportReviewCommand, } from "./export-bundle.command.js";
+const ARCHIVE_SUBCOMMANDS = {
+    bundle: exportBundleCommand,
+    session: exportSessionCommand,
+    quality: exportQualityCommand,
+    review: exportReviewCommand,
+};
+export const exportCommand = {
+    name: 'export',
+    description: 'Render SharkCraft knowledge as a flat agent-rule file (AGENTS.md / CLAUDE.md / .cursor/rules / copilot-instructions). Dry-run by default; pass --write to save.',
+    usage: 'shrk [--cwd <dir>] export <format> [--write] [--output <path>] [--task "<task>"] [--max-rules N] [--max-paths N] [--json]',
+    async run(args) {
+        const format = args.positional[0];
+        if (!format) {
+            process.stderr.write(`Usage: shrk export <format>\nFormats: ${ALL_EXPORT_FORMATS.join(', ')}\n`);
+            return 2;
+        }
+        // Archive subcommands intercepted here so `shrk export bundle <id>` still works.
+        const archive = ARCHIVE_SUBCOMMANDS[format];
+        if (archive) {
+            const sub = { ...args, positional: args.positional.slice(1) };
+            return archive.run(sub);
+        }
+        if (!isExportFormat(format)) {
+            process.stderr.write(`Unknown export format "${format}".\nFormats: ${ALL_EXPORT_FORMATS.join(', ')}, bundle, session, quality, review\n`);
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const result = renderExport(inspection, {
+            format,
+            task: flagString(args, 'task'),
+            maxRules: flagNumber(args, 'max-rules'),
+            maxPaths: flagNumber(args, 'max-paths'),
+        });
+        const wantJson = flagBool(args, 'json');
+        const doWrite = flagBool(args, 'write');
+        const outputFlag = flagString(args, 'output');
+        const outputPath = outputFlag
+            ? (outputFlag.startsWith('/') ? outputFlag : join(cwd, outputFlag))
+            : join(cwd, result.suggestedPath);
+        if (doWrite) {
+            mkdirSync(dirname(outputPath), { recursive: true });
+            if (existsSync(outputPath) && !flagBool(args, 'force')) {
+                process.stderr.write(`Refusing to overwrite existing ${outputPath}. Pass --force to allow.\n`);
+                return 1;
+            }
+            writeFileSync(outputPath, result.content, 'utf8');
+            if (wantJson) {
+                process.stdout.write(asJson({ written: true, path: outputPath, format }) + '\n');
+            }
+            else {
+                process.stdout.write(`Wrote ${outputPath}\n`);
+            }
+            return 0;
+        }
+        if (wantJson) {
+            process.stdout.write(asJson({
+                format,
+                suggestedPath: result.suggestedPath,
+                targetPath: outputPath,
+                content: result.content,
+            }) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Export (${format}) — dry-run`));
+        process.stdout.write(`Would write to: ${outputPath}\n`);
+        process.stdout.write(`Suggested default path: ${result.suggestedPath}\n\n`);
+        process.stdout.write('--- preview ---\n');
+        process.stdout.write(result.content);
+        if (!result.content.endsWith('\n'))
+            process.stdout.write('\n');
+        process.stdout.write('--- end preview ---\n');
+        process.stdout.write('\nRe-run with --write to save.\n');
+        return 0;
+    },
+};

package/dist/commands/feedback-dispatch.command.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Top-level `shrk feedback` dispatcher, plus the `feedback rules
+ * list|doctor` family.
+ *
+ * The registry routes subcommands when the second positional is a real
+ * verb. This file maps `shrk feedback <verb>` → the verb-specific
+ * handler, while also accepting `shrk feedback <file>` (defaults to
+ * `ingest`).
+ */
+import type { ICommandHandler } from '../command-registry.js';
+export declare const feedbackCommand: ICommandHandler;
+//# sourceMappingURL=feedback-dispatch.command.d.ts.map

package/dist/commands/feedback-dispatch.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedback-dispatch.command.d.ts","sourceRoot":"","sources":["../../src/commands/feedback-dispatch.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,eAAe,EAAc,MAAM,wBAAwB,CAAC;AA6B1E,eAAO,MAAM,eAAe,EAAE,eAmD7B,CAAC"}

package/dist/commands/feedback-dispatch.command.js

@@ -0,0 +1,63 @@
+import { feedbackActionsCommand, feedbackBacklogCommand, feedbackConvertToBacklogCommand, feedbackIngestCommand, feedbackPlanCommand, feedbackPromptCommand, feedbackRulesDoctorCommand, feedbackRulesListCommand, feedbackSummarizeCommand, } from "./feedback.command.js";
+const VERBS = {
+    ingest: feedbackIngestCommand,
+    summarize: feedbackSummarizeCommand,
+    actions: feedbackActionsCommand,
+    'convert-to-backlog': feedbackConvertToBacklogCommand,
+    // v2
+    backlog: feedbackBacklogCommand,
+    prompt: feedbackPromptCommand,
+    plan: feedbackPlanCommand,
+};
+const RULES_VERBS = {
+    list: feedbackRulesListCommand,
+    doctor: feedbackRulesDoctorCommand,
+};
+export const feedbackCommand = {
+    name: 'feedback',
+    description: 'Parse freeform feedback markdown into structured findings. Subcommands: ingest|summarize|actions|convert-to-backlog|rules. Read-only.',
+    usage: 'shrk feedback <ingest|summarize|actions|convert-to-backlog> <file> [--with-pack-rules] [--json]\n  shrk feedback rules <list|doctor> [--json]',
+    async run(args) {
+        const verb = args.positional[0];
+        if (verb === 'rules') {
+            const sub = args.positional[1];
+            const next = { ...args, positional: args.positional.slice(2) };
+            if (sub && RULES_VERBS[sub]) {
+                return RULES_VERBS[sub].run(next);
+            }
+            // Default rules verb is list.
+            return feedbackRulesListCommand.run(next);
+        }
+        if (verb && VERBS[verb]) {
+            const sub = { ...args, positional: args.positional.slice(1) };
+            return VERBS[verb].run(sub);
+        }
+        // If `verb` looks like a known SharkCraft verb (e.g. "list" / "rules")
+        // but the user typed it in the wrong position, surface a did-you-mean
+        // hint rather than silently trying to read the verb as a file.
+        if (verb && !verb.includes('/') && !verb.includes('.')) {
+            const { existsSync } = await import('node:fs');
+            const isFile = existsSync(verb);
+            if (!isFile) {
+                const known = [...Object.keys(VERBS), 'rules list', 'rules doctor'];
+                const closest = known.find((k) => k === verb || k.startsWith(verb + ' '));
+                if (closest) {
+                    process.stderr.write(`Unknown subcommand: feedback ${verb}\n`);
+                    process.stderr.write(`Did you mean: shrk feedback ${closest}?\n`);
+                    return 2;
+                }
+                if (verb === 'list') {
+                    process.stderr.write(`Unknown subcommand: feedback ${verb}\n`);
+                    process.stderr.write('Did you mean: shrk feedback rules list?\n');
+                    return 2;
+                }
+            }
+        }
+        // Default: treat first positional as a file → ingest.
+        if (verb) {
+            return feedbackIngestCommand.run(args);
+        }
+        process.stderr.write('Usage: shrk feedback <ingest|summarize|actions|convert-to-backlog|rules> ...\n');
+        return 2;
+    },
+};

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

@@ -0,0 +1,11 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const feedbackIngestCommand: ICommandHandler;
+export declare const feedbackSummarizeCommand: ICommandHandler;
+export declare const feedbackActionsCommand: ICommandHandler;
+export declare const feedbackConvertToBacklogCommand: ICommandHandler;
+export declare const feedbackRulesListCommand: ICommandHandler;
+export declare const feedbackRulesDoctorCommand: ICommandHandler;
+export declare const feedbackBacklogCommand: ICommandHandler;
+export declare const feedbackPromptCommand: ICommandHandler;
+export declare const feedbackPlanCommand: ICommandHandler;
+//# sourceMappingURL=feedback.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feedback.command.d.ts","sourceRoot":"","sources":["../../src/commands/feedback.command.ts"],"names":[],"mappings":"AAiBA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAgBhC,eAAO,MAAM,qBAAqB,EAAE,eAiCnC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,eA0CtC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,eAyDpC,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,eAwB7C,CAAC;AAIF,eAAO,MAAM,wBAAwB,EAAE,eAqBtC,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,eAiDxC,CAAC;AAGF,eAAO,MAAM,sBAAsB,EAAE,eAqBpC,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eAqBnC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eA6BjC,CAAC"}

package/dist/commands/feedback.command.js

@@ -0,0 +1,336 @@
+/**
+ * `shrk feedback` family (ingest|summarize|actions|convert-to-backlog),
+ * plus pack-contributed rules and `feedback rules list|doctor`.
+ *
+ * Deterministic — no AI. Reads freeform feedback markdown/text and emits
+ * structured findings.
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { FeedbackBucket, ingestFeedbackFile, inspectSharkcraft, loadFeedbackRules, renderFeedbackBacklog, } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson, header } from "../output/format-output.js";
+function ingestPositional(args) {
+    return args.positional[0];
+}
+async function loadRulesIfRequested(args, cwd) {
+    if (!flagBool(args, 'with-pack-rules'))
+        return [];
+    const inspection = await inspectSharkcraft({ cwd });
+    return loadFeedbackRules(inspection);
+}
+export const feedbackIngestCommand = {
+    name: 'ingest',
+    description: 'Parse a feedback file into structured findings. Supports pack rules. Read-only.',
+    usage: 'shrk feedback ingest <file> [--with-pack-rules] [--json]',
+    async run(args) {
+        const file = ingestPositional(args);
+        if (!file) {
+            process.stderr.write('Usage: shrk feedback ingest <file>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        try {
+            const rules = await loadRulesIfRequested(args, cwd);
+            const report = ingestFeedbackFile(cwd, file, { rules });
+            if (flagBool(args, 'json')) {
+                process.stdout.write(asJson(report) + '\n');
+                return 0;
+            }
+            process.stdout.write(header(`Feedback ingestion (${report.totalFindings})`));
+            for (const b of Object.values(FeedbackBucket)) {
+                process.stdout.write(`  ${b}: ${report.counts[b] ?? 0}\n`);
+            }
+            process.stdout.write('\nFindings:\n');
+            for (const f of report.findings) {
+                process.stdout.write(`  • [${f.bucket}/${f.severity}] ${f.text}\n`);
+                if (f.targetArea)
+                    process.stdout.write(`        target: ${f.targetArea}\n`);
+            }
+            return 0;
+        }
+        catch (e) {
+            process.stderr.write(`Failed to ingest: ${e.message}\n`);
+            return 1;
+        }
+    },
+};
+export const feedbackSummarizeCommand = {
+    name: 'summarize',
+    description: 'Produce a short summary of a feedback file (counts + top tags). Read-only.',
+    usage: 'shrk feedback summarize <file> [--json]',
+    async run(args) {
+        const file = ingestPositional(args);
+        if (!file) {
+            process.stderr.write('Usage: shrk feedback summarize <file>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const report = ingestFeedbackFile(cwd, file);
+        const tagCounts = new Map();
+        for (const f of report.findings) {
+            for (const t of f.tags)
+                tagCounts.set(t, (tagCounts.get(t) ?? 0) + 1);
+        }
+        const sortedTags = [...tagCounts.entries()].sort((a, b) => b[1] - a[1]);
+        const summary = {
+            schema: 'sharkcraft.feedback-summary/v1',
+            sourceFile: file,
+            totals: report.counts,
+            topTags: sortedTags.slice(0, 10).map(([tag, count]) => ({ tag, count })),
+            nextRound: report.suggestedNextRound,
+        };
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(summary) + '\n');
+            return 0;
+        }
+        process.stdout.write(header('Feedback summary'));
+        for (const [k, v] of Object.entries(summary.totals)) {
+            process.stdout.write(`  ${k}: ${v}\n`);
+        }
+        if (summary.topTags.length > 0) {
+            process.stdout.write('\nTop tags:\n');
+            for (const t of summary.topTags)
+                process.stdout.write(`  ${t.tag}: ${t.count}\n`);
+        }
+        if (summary.nextRound.length > 0) {
+            process.stdout.write('\nSuggested next round:\n');
+            for (const n of summary.nextRound)
+                process.stdout.write(`  • ${n}\n`);
+        }
+        return 0;
+    },
+};
+export const feedbackActionsCommand = {
+    name: 'actions',
+    description: 'Render the suggested follow-up commands extracted from a feedback file. Default emits the richer v2 schema; pass --legacy for the v1 output.',
+    usage: 'shrk feedback actions <file> [--with-pack-rules] [--legacy] [--json]',
+    async run(args) {
+        const file = ingestPositional(args);
+        if (!file) {
+            process.stderr.write('Usage: shrk feedback actions <file>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        // Default to v2 shape.
+        if (!flagBool(args, 'legacy')) {
+            const { buildFeedbackActionsReport, inspectSharkcraft } = await import('@shrkcrft/inspector');
+            const inspection = await inspectSharkcraft({ cwd });
+            const v2 = buildFeedbackActionsReport(inspection, file);
+            if (flagBool(args, 'json')) {
+                process.stdout.write(asJson(v2) + '\n');
+                return 0;
+            }
+            process.stdout.write(header(`Feedback actions v2 (${v2.actions.length})`));
+            for (const a of v2.actions) {
+                process.stdout.write(`• [${a.priority}] [${a.category}] (${a.origin}) ${a.targetArea} — ${a.paraphrase ?? ''}\n`);
+                for (const c of a.recommendedCommands)
+                    process.stdout.write(`    $ ${c}\n`);
+            }
+            return 0;
+        }
+        const rules = await loadRulesIfRequested(args, cwd);
+        const report = ingestFeedbackFile(cwd, file, { rules });
+        const seen = new Set();
+        const actions = [];
+        for (const f of report.findings) {
+            const key = f.text + '|' + f.suggestedCommands.join(',');
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            if (f.suggestedCommands.length > 0) {
+                actions.push({
+                    text: f.text,
+                    commands: f.suggestedCommands,
+                    ...(f.targetArea ? { target: f.targetArea } : {}),
+                });
+            }
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({ schema: 'sharkcraft.feedback-actions/v1', actions }) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Feedback actions (${actions.length})`));
+        for (const a of actions) {
+            process.stdout.write(`• ${a.text}\n`);
+            for (const c of a.commands)
+                process.stdout.write(`    $ ${c}\n`);
+        }
+        return 0;
+    },
+};
+export const feedbackConvertToBacklogCommand = {
+    name: 'convert-to-backlog',
+    description: 'Render a feedback file as a markdown backlog under .sharkcraft/reports/.',
+    usage: 'shrk feedback convert-to-backlog <file> --output <path>',
+    async run(args) {
+        const file = ingestPositional(args);
+        const out = flagString(args, 'output');
+        if (!file) {
+            process.stderr.write('Usage: shrk feedback convert-to-backlog <file> [--output <path>]\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const report = ingestFeedbackFile(cwd, file);
+        const md = renderFeedbackBacklog(report);
+        if (!out) {
+            process.stdout.write(md);
+            return 0;
+        }
+        const abs = nodePath.isAbsolute(out) ? out : nodePath.join(cwd, out);
+        mkdirSync(nodePath.dirname(abs), { recursive: true });
+        writeFileSync(abs, md, 'utf8');
+        process.stdout.write(`Backlog written → ${abs}\n`);
+        return 0;
+    },
+};
+// `feedback rules` subcommands.
+export const feedbackRulesListCommand = {
+    name: 'list',
+    description: 'List local + pack-contributed feedback rules. Read-only.',
+    usage: 'shrk feedback rules list [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const rules = await loadFeedbackRules(inspection);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({ count: rules.length, rules }) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Feedback rules (${rules.length})`));
+        for (const r of rules) {
+            process.stdout.write(`  ${r.id.padEnd(40)} ${r.title}\n`);
+            const kws = [...(r.keywords ?? []), ...(r.phrases ?? [])].slice(0, 5).join(', ');
+            if (kws)
+                process.stdout.write(`       keywords: ${kws}\n`);
+            if (r.targetArea)
+                process.stdout.write(`       target:   ${r.targetArea}\n`);
+        }
+        return 0;
+    },
+};
+export const feedbackRulesDoctorCommand = {
+    name: 'doctor',
+    description: 'Validate local + pack feedback rules. Read-only.',
+    usage: 'shrk feedback rules doctor [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const rules = await loadFeedbackRules(inspection);
+        const errors = [];
+        const warnings = [];
+        const ids = new Set();
+        for (const r of rules) {
+            if (!r.id || ids.has(r.id)) {
+                errors.push({ id: r.id ?? '?', message: r.id ? 'duplicate id' : 'missing id' });
+            }
+            else {
+                ids.add(r.id);
+            }
+            const fragments = (r.keywords?.length ?? 0) + (r.phrases?.length ?? 0) + (r.regexes?.length ?? 0);
+            if (fragments === 0) {
+                errors.push({ id: r.id, message: 'rule has no keywords/phrases/regexes — will never match' });
+            }
+            if (!r.title)
+                warnings.push({ id: r.id, message: 'no title' });
+            if (!r.targetArea)
+                warnings.push({ id: r.id, message: 'no targetArea — uses rule id as fallback' });
+            if ((!r.suggestedActions || r.suggestedActions.length === 0) &&
+                (!r.relatedCommands || r.relatedCommands.length === 0)) {
+                warnings.push({ id: r.id, message: 'no suggestedActions / relatedCommands' });
+            }
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({
+                schema: 'sharkcraft.feedback-rule-doctor/v1',
+                total: rules.length,
+                errors,
+                warnings,
+                passed: errors.length === 0,
+            }) + '\n');
+            return errors.length > 0 ? 1 : 0;
+        }
+        process.stdout.write(header(`Feedback rule doctor (${rules.length} rules)`));
+        process.stdout.write(`errors: ${errors.length}\nwarnings: ${warnings.length}\n`);
+        for (const e of errors)
+            process.stdout.write(`  ERROR   ${e.id}: ${e.message}\n`);
+        for (const w of warnings)
+            process.stdout.write(`  WARN    ${w.id}: ${w.message}\n`);
+        return errors.length > 0 ? 1 : 0;
+    },
+};
+// Feedback v2 outputs: backlog, prompt, plan.
+export const feedbackBacklogCommand = {
+    name: 'backlog',
+    description: 'Render a feedback file as a priority-grouped markdown backlog (v2).',
+    usage: 'shrk feedback backlog <file> [--json] [--output <path>]',
+    async run(args) {
+        const file = ingestPositional(args);
+        if (!file) {
+            process.stderr.write('Usage: shrk feedback backlog <file>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const { buildFeedbackBacklogReport, inspectSharkcraft } = await import('@shrkcrft/inspector');
+        const inspection = await inspectSharkcraft({ cwd });
+        const report = buildFeedbackBacklogReport(inspection, file);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(report) + '\n');
+            return 0;
+        }
+        process.stdout.write(report.markdown);
+        return 0;
+    },
+};
+export const feedbackPromptCommand = {
+    name: 'prompt',
+    description: 'Render a feedback file as a Markdown implementation prompt (v2).',
+    usage: 'shrk feedback prompt <file> [--json]',
+    async run(args) {
+        const file = ingestPositional(args);
+        if (!file) {
+            process.stderr.write('Usage: shrk feedback prompt <file>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const { buildFeedbackPromptReport, inspectSharkcraft } = await import('@shrkcrft/inspector');
+        const inspection = await inspectSharkcraft({ cwd });
+        const report = buildFeedbackPromptReport(inspection, file);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(report) + '\n');
+            return 0;
+        }
+        process.stdout.write(report.markdown);
+        return 0;
+    },
+};
+export const feedbackPlanCommand = {
+    name: 'plan',
+    description: 'Render a feedback file as an ordered implementation plan with validation gates (v2).',
+    usage: 'shrk feedback plan <file> [--json]',
+    async run(args) {
+        const file = ingestPositional(args);
+        if (!file) {
+            process.stderr.write('Usage: shrk feedback plan <file>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const { buildFeedbackPlanReport, inspectSharkcraft } = await import('@shrkcrft/inspector');
+        const inspection = await inspectSharkcraft({ cwd });
+        const report = buildFeedbackPlanReport(inspection, file);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(report) + '\n');
+            return 0;
+        }
+        process.stdout.write(`=== Feedback plan ===\n`);
+        for (const a of report.orderedActions) {
+            process.stdout.write(`  [${a.priority}] ${a.targetArea} — ${a.paraphrase ?? a.originalExcerpt.slice(0, 80)}…\n`);
+            for (const c of a.recommendedCommands)
+                process.stdout.write(`      $ ${c}\n`);
+        }
+        process.stdout.write('\nValidation gates:\n');
+        for (const g of report.validationGates)
+            process.stdout.write(`  $ ${g}\n`);
+        return 0;
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"fix.command.d.ts","sourceRoot":"","sources":["../../src/commands/fix.command.ts"],"names":[],"mappings":"AAwBA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA0PhC,eAAO,MAAM,UAAU,EAAE,eAwBxB,CAAC"}