@shrkcrft/cli 0.1.0-alpha.2

package/dist/commands/conventions.command.js

@@ -0,0 +1,169 @@
+/**
+ * `shrk conventions ...` — pack/local conventions surface.
+ *
+ * Read-only listing + doctor + check. `check` runs the loaded conventions
+ * against caller-supplied files (or git diff). Never writes.
+ */
+import { checkConventionsAgainstFiles, findConvention, getChangedFiles, inspectSharkcraft, listConventions, listConventionIssues, } from '@shrkcrft/inspector';
+import { flagBool, flagString, flagList, resolveCwd, } from "../command-registry.js";
+import { asJson, header } from "../output/format-output.js";
+export const conventionsListCommand = {
+    name: 'list',
+    description: 'List registered conventions. Read-only.',
+    usage: 'shrk conventions list [--kind <kind>] [--source local|pack] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const entries = await listConventions(inspection);
+        const kind = flagString(args, 'kind');
+        const source = flagString(args, 'source');
+        let filtered = entries;
+        if (kind)
+            filtered = filtered.filter((e) => e.convention.kind === kind);
+        if (source)
+            filtered = filtered.filter((e) => e.source === source);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(filtered) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Conventions (${filtered.length})`));
+        if (filtered.length === 0) {
+            process.stdout.write('  (none — contribute via a pack manifest "conventionFiles" entry or sharkcraft/conventions.ts)\n');
+            return 0;
+        }
+        for (const e of filtered) {
+            const src = e.source === 'pack' ? `pack:${e.packageName ?? '?'}` : e.source;
+            process.stdout.write(`  • ${e.convention.kind.padEnd(12)} ${e.convention.id.padEnd(28)} ${e.convention.title}  [${src}]\n`);
+        }
+        return 0;
+    },
+};
+export const conventionsGetCommand = {
+    name: 'get',
+    description: 'Show a single convention by id.',
+    usage: 'shrk conventions get <id> [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk conventions get <id>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const entry = await findConvention(inspection, id);
+        if (!entry) {
+            process.stderr.write(`Unknown convention "${id}".\n`);
+            return 2;
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(entry) + '\n');
+            return 0;
+        }
+        const c = entry.convention;
+        process.stdout.write(header(`Convention ${c.id} (${c.kind})`));
+        process.stdout.write(`  title         ${c.title}\n`);
+        if (c.description)
+            process.stdout.write(`  description   ${c.description}\n`);
+        process.stdout.write(`  severity      ${c.severity}\n`);
+        process.stdout.write(`  source        ${entry.source}${entry.packageName ? ' (' + entry.packageName + ')' : ''}\n`);
+        process.stdout.write(`  sourceFile    ${entry.sourceFile}\n`);
+        process.stdout.write(`  rules (${c.rules.length}):\n`);
+        for (const r of c.rules) {
+            process.stdout.write(`    • ${r.id}  ${r.description}\n`);
+        }
+        if (c.examples && c.examples.length > 0) {
+            process.stdout.write(`  examples (${c.examples.length}):\n`);
+            for (const e of c.examples)
+                process.stdout.write(`    • ${e.description}\n`);
+        }
+        return 0;
+    },
+};
+export const conventionsDoctorCommand = {
+    name: 'doctor',
+    description: 'Surface load/validation issues for conventions.',
+    usage: 'shrk conventions doctor [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const issues = await listConventionIssues(inspection);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({ issues }) + '\n');
+            return issues.some((i) => i.severity === 'error') ? 1 : 0;
+        }
+        process.stdout.write(header('Conventions doctor'));
+        if (issues.length === 0) {
+            process.stdout.write('  ok — no load/validation issues.\n');
+            return 0;
+        }
+        for (const i of issues) {
+            process.stdout.write(`  ${i.severity.padEnd(7)} [${i.code}] ${i.message}\n`);
+        }
+        return issues.some((i) => i.severity === 'error') ? 1 : 0;
+    },
+};
+export const conventionsCheckCommand = {
+    name: 'check',
+    description: 'Run loaded conventions against files (--files / --since / --staged).',
+    usage: 'shrk conventions check [--files a,b,c] [--since <ref>] [--staged] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        let files = [];
+        const explicit = flagList(args, 'files');
+        if (explicit.length > 0) {
+            files = explicit;
+        }
+        else if (flagBool(args, 'staged')) {
+            files = getChangedFiles(cwd, { staged: true });
+        }
+        else {
+            const since = flagString(args, 'since');
+            files = since ? getChangedFiles(cwd, { since }) : getChangedFiles(cwd, {});
+        }
+        const report = await checkConventionsAgainstFiles(inspection, files);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(report) + '\n');
+            return report.verdict === 'clean' ? 0 : 1;
+        }
+        process.stdout.write(header(`Convention check (${report.filesScanned} files, ${report.hits.length} hits)`));
+        if (report.hits.length === 0) {
+            process.stdout.write('  ok — no violations.\n');
+            return 0;
+        }
+        for (const h of report.hits.slice(0, 200)) {
+            process.stdout.write(`  ${h.severity.padEnd(7)} ${h.conventionId}/${h.ruleId} — ${h.file}\n`);
+            process.stdout.write(`           ${h.message}\n`);
+        }
+        return report.verdict === 'clean' ? 0 : 1;
+    },
+};
+export const conventionsExplainCommand = {
+    name: 'explain',
+    description: 'Explain a convention (description + rules + examples + references).',
+    usage: 'shrk conventions explain <id>',
+    async run(args) {
+        return conventionsGetCommand.run(args);
+    },
+};
+export const conventionsCommand = {
+    name: 'conventions',
+    description: 'Generic conventions registry (naming / path / barrel / layout / command / validation / ownership / testing / release / safety). Read-only.',
+    usage: 'shrk conventions list|get|doctor|check|explain ...',
+    async run(args) {
+        const sub = args.positional[0];
+        args.positional = args.positional.slice(1);
+        if (sub === 'list')
+            return conventionsListCommand.run(args);
+        if (sub === 'get')
+            return conventionsGetCommand.run(args);
+        if (sub === 'doctor')
+            return conventionsDoctorCommand.run(args);
+        if (sub === 'check')
+            return conventionsCheckCommand.run(args);
+        if (sub === 'explain')
+            return conventionsExplainCommand.run(args);
+        process.stderr.write('Usage: shrk conventions list|get|doctor|check|explain ...\n');
+        return 2;
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.command.d.ts","sourceRoot":"","sources":["../../src/commands/coverage.command.ts"],"names":[],"mappings":"AAMA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAGhC,eAAO,MAAM,eAAe,EAAE,eAkC7B,CAAC"}

package/dist/commands/coverage.command.js

@@ -0,0 +1,56 @@
+import { buildCoverageReport, buildScaffoldCoverageReport, inspectSharkcraft, renderScaffoldCoverageMarkdown, } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson, header, kv } from "../output/format-output.js";
+export const coverageCommand = {
+    name: 'coverage',
+    description: 'Report relationship/coverage quality across registries + scaffold coverage (`shrk coverage scaffolds --task "<task>"`).',
+    usage: 'shrk [--cwd <dir>] coverage [--json]\n  shrk [--cwd <dir>] coverage scaffolds [--task "<task>"|--domain <domain>] [--json]',
+    async run(args) {
+        if (args.positional[0] === 'scaffolds') {
+            const sliced = { ...args, positional: args.positional.slice(1) };
+            return runCoverageScaffolds(sliced);
+        }
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const report = buildCoverageReport(inspection);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(report) + '\n');
+            return 0;
+        }
+        process.stdout.write(header('Coverage report'));
+        process.stdout.write(kv('overall', `${report.overall}/100`) + '\n\n');
+        for (const c of report.categories) {
+            process.stdout.write(`  ${c.score.toString().padStart(3)}/100  ${c.title.padEnd(48)} (${c.covered}/${c.total})\n`);
+            for (const m of c.missing.slice(0, 5))
+                process.stdout.write(`           - ${m}\n`);
+            if (c.missing.length > 5) {
+                process.stdout.write(`           - … (${c.missing.length - 5} more)\n`);
+            }
+        }
+        if (report.suggestions.length) {
+            process.stdout.write('\nSuggestions:\n');
+            for (const s of report.suggestions)
+                process.stdout.write(`  • ${s}\n`);
+        }
+        return 0;
+    },
+};
+async function runCoverageScaffolds(args) {
+    const cwd = resolveCwd(args);
+    const task = flagString(args, 'task');
+    const domain = flagString(args, 'domain');
+    if (!task && !domain) {
+        process.stderr.write('Usage: shrk coverage scaffolds --task "<task>" | --domain <domain> [--json]\n');
+        return 2;
+    }
+    const inspection = await inspectSharkcraft({ cwd });
+    const report = await buildScaffoldCoverageReport(inspection, {
+        ...(task ? { task } : {}),
+        ...(domain ? { domain } : {}),
+    });
+    if (flagBool(args, 'json')) {
+        process.stdout.write(asJson(report) + '\n');
+        return report.grade === 'missing' ? 1 : 0;
+    }
+    process.stdout.write(renderScaffoldCoverageMarkdown(report));
+    return report.grade === 'missing' ? 1 : 0;
+}

package/dist/commands/daily.commands.d.ts

@@ -0,0 +1,5 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const nextCommand: ICommandHandler;
+export declare const findCommand: ICommandHandler;
+export declare const explainCommand: ICommandHandler;
+//# sourceMappingURL=daily.commands.d.ts.map

package/dist/commands/daily.commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daily.commands.d.ts","sourceRoot":"","sources":["../../src/commands/daily.commands.ts"],"names":[],"mappings":"AAOA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAMhC,eAAO,MAAM,WAAW,EAAE,eAsFzB,CAAC;AAcF,eAAO,MAAM,WAAW,EAAE,eAoGzB,CAAC;AAKF,eAAO,MAAM,cAAc,EAAE,eA6D5B,CAAC"}

package/dist/commands/daily.commands.js

@@ -0,0 +1,224 @@
+import { buildAiReadinessReport, buildTaskPacket, inspectSharkcraft, runDoctor, } from '@shrkcrft/inspector';
+import { recommendPresets } from '@shrkcrft/presets';
+import { flagBool, flagNumber, resolveCwd, } from "../command-registry.js";
+import { asJson, header, kv } from "../output/format-output.js";
+// ────────────────────────────────────────────────────────────────────────
+// shrk next — "what should I do right now in this repo?"
+// ────────────────────────────────────────────────────────────────────────
+export const nextCommand = {
+    name: 'next',
+    description: 'Recommend next actions for the current repo: doctor status, readiness, suggested presets/pipelines, missing setup.',
+    usage: 'shrk [--cwd <dir>] next [--json]',
+    async run(args) {
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const doctor = runDoctor(inspection);
+        const readiness = buildAiReadinessReport(inspection);
+        const presetRecs = recommendPresets(inspection.presetRegistry.list(), {
+            profiles: inspection.workspace.profiles,
+            limit: 3,
+        });
+        const pipelineIds = inspection.pipelineRegistry.list().map((p) => p.id);
+        const actions = [];
+        if (!inspection.hasSharkcraftFolder) {
+            actions.push('Run `shrk init --preset generic` to scaffold sharkcraft/.');
+        }
+        if (!doctor.passed) {
+            actions.push('Run `shrk doctor` to fix the errors above.');
+        }
+        if (readiness.score < 70) {
+            actions.push(`Improve readiness (current ${readiness.score}/100) — see recommendations below.`);
+        }
+        if (inspection.templates.length === 0) {
+            actions.push('Add at least one template via `shrk presets apply <id> --merge --write`.');
+        }
+        if (inspection.pipelines.length === 0) {
+            actions.push('Add a pipeline (feature-dev, context-only) — see suggested presets below.');
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({
+                doctorPassed: doctor.passed,
+                readiness: { score: readiness.score, grade: readiness.grade },
+                detectedProfiles: inspection.workspace.profiles,
+                presetRecommendations: presetRecs.map((r) => ({
+                    id: r.preset.id,
+                    confidence: r.confidence,
+                    score: r.score,
+                })),
+                pipelines: pipelineIds,
+                actions,
+                topRecommendations: readiness.topRecommendations,
+            }) + '\n');
+            return 0;
+        }
+        process.stdout.write(header('Next actions'));
+        process.stdout.write(kv('doctor', doctor.passed ? 'pass' : `${doctor.summary.errors} errors`) + '\n');
+        process.stdout.write(kv('readiness', `${readiness.score}/100 (${readiness.grade})`) + '\n');
+        process.stdout.write(kv('profiles', inspection.workspace.profiles.join(', ') || '(none)') + '\n');
+        if (presetRecs.length) {
+            process.stdout.write('\nSuggested presets:\n');
+            for (const r of presetRecs) {
+                process.stdout.write(`  • ${r.preset.id} (${r.confidence}) — ${r.preset.title}\n`);
+            }
+        }
+        if (pipelineIds.length) {
+            process.stdout.write('\nKnown pipelines:\n');
+            for (const id of pipelineIds.slice(0, 6))
+                process.stdout.write(`  • ${id}\n`);
+        }
+        if (actions.length) {
+            process.stdout.write('\nDo next:\n');
+            for (const a of actions)
+                process.stdout.write(`  $ ${a}\n`);
+        }
+        if (readiness.topRecommendations.length) {
+            process.stdout.write('\nReadiness recommendations:\n');
+            for (const r of readiness.topRecommendations) {
+                process.stdout.write(`  • ${r}\n`);
+            }
+        }
+        if (actions.length === 0 && doctor.passed && readiness.score >= 70) {
+            process.stdout.write('\nNothing urgent. Try `shrk task "<task>"` when you have something to ship.\n');
+        }
+        return 0;
+    },
+};
+// ────────────────────────────────────────────────────────────────────────
+// shrk find — grouped search across all SharkCraft kinds.
+// ────────────────────────────────────────────────────────────────────────
+function lc(s) {
+    return s.toLowerCase();
+}
+function matches(query, ...texts) {
+    const q = lc(query);
+    return texts.some((t) => typeof t === 'string' && lc(t).includes(q));
+}
+export const findCommand = {
+    name: 'find',
+    description: 'Search across knowledge / rules / paths / templates / pipelines / packs / presets in one place.',
+    usage: 'shrk [--cwd <dir>] find "<query>" [--limit N] [--json]',
+    async run(args) {
+        const query = args.positional.join(' ').trim();
+        if (!query) {
+            process.stderr.write('Usage: shrk find "<query>"\n');
+            return 2;
+        }
+        const limit = flagNumber(args, 'limit') ?? 8;
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const knowledge = inspection.knowledgeEntries
+            .filter((e) => matches(query, e.id, e.title, e.content, e.tags.join(' ')))
+            .slice(0, limit);
+        const rules = inspection.ruleService.list()
+            .filter((r) => matches(query, r.id, r.title, r.content))
+            .slice(0, limit);
+        const paths = inspection.pathService.list()
+            .filter((p) => matches(query, p.id, p.title, p.content))
+            .slice(0, limit);
+        const templates = inspection.templates
+            .filter((t) => matches(query, t.id, t.name, t.description))
+            .slice(0, limit);
+        const pipelines = inspection.pipelines
+            .filter((p) => matches(query, p.id, p.title, p.description))
+            .slice(0, limit);
+        const packs = inspection.packs.discoveredPacks
+            .filter((p) => matches(query, p.packageName, p.manifest?.info.description))
+            .slice(0, limit);
+        const presets = inspection.presetRegistry
+            .list()
+            .filter((p) => matches(query, p.id, p.title, p.description, (p.tags ?? []).join(' ')))
+            .slice(0, limit);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({
+                query,
+                knowledge: knowledge.map((e) => ({ id: e.id, title: e.title, type: e.type })),
+                rules: rules.map((r) => ({ id: r.id, title: r.title })),
+                paths: paths.map((p) => ({ id: p.id, title: p.title })),
+                templates: templates.map((t) => ({ id: t.id, name: t.name })),
+                pipelines: pipelines.map((p) => ({ id: p.id, title: p.title })),
+                packs: packs.map((p) => ({ name: p.packageName, version: p.packageVersion })),
+                presets: presets.map((p) => ({ id: p.id, title: p.title })),
+            }) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`find: ${query}`));
+        function group(title, items) {
+            if (items.length === 0)
+                return;
+            process.stdout.write(`\n${title} (${items.length}):\n`);
+            for (const it of items)
+                process.stdout.write(`  ${it.line}\n`);
+        }
+        group('Knowledge', knowledge.map((e) => ({ line: `${e.id.padEnd(30)} ${e.title}` })));
+        group('Rules', rules.map((r) => ({ line: `${r.id.padEnd(30)} ${r.title}` })));
+        group('Paths', paths.map((p) => ({ line: `${p.id.padEnd(30)} ${p.title}` })));
+        group('Templates', templates.map((t) => ({ line: `${t.id.padEnd(30)} ${t.name}` })));
+        group('Pipelines', pipelines.map((p) => ({ line: `${p.id.padEnd(30)} ${p.title}` })));
+        group('Packs', packs.map((p) => ({ line: `${p.packageName}@${p.packageVersion}` })));
+        group('Presets', presets.map((p) => ({ line: `${p.id.padEnd(22)} ${p.title}` })));
+        const total = knowledge.length +
+            rules.length +
+            paths.length +
+            templates.length +
+            pipelines.length +
+            packs.length +
+            presets.length;
+        if (total === 0) {
+            process.stdout.write('\n(no matches)\n');
+        }
+        return 0;
+    },
+};
+// ────────────────────────────────────────────────────────────────────────
+// shrk explain <topic> — compact local explanation, no AI.
+// ────────────────────────────────────────────────────────────────────────
+export const explainCommand = {
+    name: 'explain',
+    description: 'Search the project knowledge / rules / paths / templates / pipelines for a topic and print a compact explanation. No AI required.',
+    usage: 'shrk [--cwd <dir>] explain "<topic>" [--max-entries N] [--json]',
+    async run(args) {
+        const topic = args.positional.join(' ').trim();
+        if (!topic) {
+            process.stderr.write('Usage: shrk explain "<topic>"\n');
+            return 2;
+        }
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const maxEntries = flagNumber(args, 'max-entries') ?? 6;
+        const packet = buildTaskPacket(inspection, topic, { maxTokens: 2500 });
+        const top = inspection.knowledgeEntries
+            .filter((e) => matches(topic, e.id, e.title, e.content, e.tags.join(' ')))
+            .slice(0, maxEntries);
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({
+                topic,
+                summary: {
+                    relevantRules: packet.relevantRules.length,
+                    relevantPaths: packet.relevantPaths.length,
+                    relevantTemplates: packet.relevantTemplates.length,
+                },
+                entries: top.map((e) => ({
+                    id: e.id,
+                    title: e.title,
+                    type: e.type,
+                    priority: e.priority,
+                    content: e.content,
+                })),
+            }) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`explain: ${topic}`));
+        process.stdout.write(kv('matches', `rules=${packet.relevantRules.length} paths=${packet.relevantPaths.length} templates=${packet.relevantTemplates.length}`) + '\n\n');
+        if (top.length === 0) {
+            process.stdout.write('(no matching knowledge entries)\n');
+            return 0;
+        }
+        for (const e of top) {
+            process.stdout.write(`• [${e.priority}] ${e.id} — ${e.title}\n`);
+            const body = e.content
+                .split('\n')
+                .filter((l) => l.trim().length > 0)
+                .slice(0, 3)
+                .join('\n  ');
+            process.stdout.write(`  ${body}\n\n`);
+        }
+        return 0;
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"dashboard-export.command.d.ts","sourceRoot":"","sources":["../../src/commands/dashboard-export.command.ts"],"names":[],"mappings":"AASA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAGhC,eAAO,MAAM,sBAAsB,EAAE,eAmDpC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,eAqClC,CAAC"}

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

@@ -0,0 +1,86 @@
+import * as nodePath from 'node:path';
+import { buildDashboardExport, diffDashboardExports, inspectSharkcraft, renderDashboardExportDiffHtml, renderDashboardExportDiffMarkdown, } from '@shrkcrft/inspector';
+import { flagBool, flagList, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+export const dashboardExportCommand = {
+    name: 'export',
+    description: 'Export dashboard-ready JSON files (repository-map, architecture, intelligence, packs, role-views, ...). Writes only into the supplied output dir. R20: `--compare-with <oldDir>` produces a diff.',
+    usage: 'shrk dashboard export [--output .sharkcraft/dashboard-data] [--include repository-map,architecture,...] [--compare-with <oldDir>] [--format text|markdown|html|json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const output = flagString(args, 'output') ?? '.sharkcraft/dashboard-data';
+        const includeRaw = flagList(args, 'include');
+        const report = await buildDashboardExport(inspection, {
+            outputDir: output,
+            ...(includeRaw.length > 0 ? { include: includeRaw } : {}),
+        });
+        const compareWith = flagString(args, 'compare-with');
+        if (compareWith) {
+            const oldDir = nodePath.isAbsolute(compareWith) ? compareWith : nodePath.resolve(cwd, compareWith);
+            const diff = diffDashboardExports(oldDir, report.outputDir);
+            const format = (flagString(args, 'format') ?? '').toLowerCase();
+            if (format === 'json' || flagBool(args, 'json')) {
+                process.stdout.write(asJson(diff) + '\n');
+                return 0;
+            }
+            if (format === 'html') {
+                process.stdout.write(renderDashboardExportDiffHtml(diff));
+                return 0;
+            }
+            if (format === 'markdown') {
+                process.stdout.write(renderDashboardExportDiffMarkdown(diff));
+                return 0;
+            }
+            process.stdout.write(`Dashboard diff: ${diff.oldDir} → ${diff.newDir}\n` +
+                `  packs: ${diff.metrics.packs.old} → ${diff.metrics.packs.new}\n` +
+                `  graph nodes: ${diff.metrics.graphNodes.old} → ${diff.metrics.graphNodes.new}\n` +
+                `  graph edges: ${diff.metrics.graphEdges.old} → ${diff.metrics.graphEdges.new}\n` +
+                `  architecture risks: ${diff.metrics.architectureRisks.old} → ${diff.metrics.architectureRisks.new}\n` +
+                `  boundary violations: ${diff.metrics.boundaryViolations.old} → ${diff.metrics.boundaryViolations.new}\n`);
+            return 0;
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(report) + '\n');
+            return 0;
+        }
+        process.stdout.write(`Wrote ${report.entries.length} dashboard data file(s) to ${report.outputDir}\n`);
+        return 0;
+    },
+};
+export const dashboardDiffCommand = {
+    name: 'diff',
+    description: 'Diff two dashboard exports (by directory).',
+    usage: 'shrk dashboard diff <oldDir> <newDir> [--format text|markdown|html|json]',
+    async run(args) {
+        const [oldArg, newArg] = args.positional;
+        if (!oldArg || !newArg) {
+            process.stderr.write('Usage: shrk dashboard diff <oldDir> <newDir>\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const oldAbs = nodePath.isAbsolute(oldArg) ? oldArg : nodePath.resolve(cwd, oldArg);
+        const newAbs = nodePath.isAbsolute(newArg) ? newArg : nodePath.resolve(cwd, newArg);
+        const diff = diffDashboardExports(oldAbs, newAbs);
+        const format = (flagString(args, 'format') ?? 'text').toLowerCase();
+        if (format === 'json' || flagBool(args, 'json')) {
+            process.stdout.write(asJson(diff) + '\n');
+            return 0;
+        }
+        if (format === 'html') {
+            process.stdout.write(renderDashboardExportDiffHtml(diff));
+            return 0;
+        }
+        if (format === 'markdown') {
+            process.stdout.write(renderDashboardExportDiffMarkdown(diff));
+            return 0;
+        }
+        process.stdout.write(`Dashboard diff: ${diff.oldDir} → ${diff.newDir}\n` +
+            `  packs: ${diff.metrics.packs.old} → ${diff.metrics.packs.new}\n` +
+            `  graph nodes: ${diff.metrics.graphNodes.old} → ${diff.metrics.graphNodes.new}\n` +
+            `  graph edges: ${diff.metrics.graphEdges.old} → ${diff.metrics.graphEdges.new}\n` +
+            `  architecture risks: ${diff.metrics.architectureRisks.old} → ${diff.metrics.architectureRisks.new}\n` +
+            `  boundary violations: ${diff.metrics.boundaryViolations.old} → ${diff.metrics.boundaryViolations.new}\n`);
+        return 0;
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"dashboard.command.d.ts","sourceRoot":"","sources":["../../src/commands/dashboard.command.ts"],"names":[],"mappings":"AAgBA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAMhC,eAAO,MAAM,gBAAgB,EAAE,eAY9B,CAAC"}