@shrkcrft/cli 0.1.0-alpha.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"drift.command.d.ts","sourceRoot":"","sources":["../../src/commands/drift.command.ts"],"names":[],"mappings":"AAUA,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAOhC,eAAO,MAAM,YAAY,EAAE,eA4E1B,CAAC"}

package/dist/commands/drift.command.js

@@ -0,0 +1,124 @@
+import { buildDriftReport, classifyChangedScope, classifyRuleDrift, inspectSharkcraft, resolveChangedFiles, RuleEnforcementState, summariseChangedScope, } from '@shrkcrft/inspector';
+import { flagBool, flagString, flagList, resolveCwd, } from "../command-registry.js";
+import { asJson, header, kv } from "../output/format-output.js";
+// `drift baseline {create|compare|update}` removed.
+// The baseline machinery was hidden / unused; `drift rules` and the
+// core `drift` report cover the actionable cases.
+export const driftCommand = {
+    name: 'drift',
+    description: 'Detect architecture drift: boundary violations, broken preset references, pipeline/template links, missing pack assets. Also: `shrk drift rules` — classify each rule as ENFORCED/PARTIAL/MANUAL/ASPIRATIONAL/STALE.',
+    usage: 'shrk [--cwd <dir>] drift [--skip-boundaries] [--json] | shrk drift rules [--strict] [--json]',
+    async run(args) {
+        if (args.positional[0] === 'rules') {
+            const sub = { ...args, positional: args.positional.slice(1) };
+            return runDriftRules(sub);
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const report = buildDriftReport(inspection, {
+            runBoundaries: !flagBool(args, 'skip-boundaries'),
+        });
+        const changedOnly = flagBool(args, 'changed-only');
+        const since = flagString(args, 'since');
+        const staged = flagBool(args, 'staged');
+        const files = flagList(args, 'files');
+        const changedScopeOpts = changedOnly || since || staged || files.length > 0
+            ? {
+                projectRoot: cwd,
+                ...(since ? { since } : {}),
+                ...(staged ? { staged: true } : {}),
+                ...(files.length > 0 ? { files } : {}),
+                includeWorktree: changedOnly || !since,
+            }
+            : null;
+        const classification = changedScopeOpts
+            ? (() => {
+                const resolved = resolveChangedFiles(changedScopeOpts);
+                return classifyChangedScope({
+                    projectRoot: cwd,
+                    current: report.findings.map((f) => {
+                        const file = f.evidence?.file;
+                        return {
+                            key: `${f.category}:${f.message}:${file ?? ''}`,
+                            code: f.category,
+                            severity: f.severity,
+                            message: f.message,
+                            ...(file ? { file } : {}),
+                        };
+                    }),
+                    changedFiles: resolved.files,
+                });
+            })()
+            : null;
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({ ...report, ...(classification ? { changedScope: classification } : {}) }) + '\n');
+            return report.counts.error > 0 ? 1 : 0;
+        }
+        process.stdout.write(header('Drift report'));
+        process.stdout.write(kv('totals', `${report.counts.error} errors, ${report.counts.warning} warnings, ${report.counts.info} info`) + '\n\n');
+        if (classification) {
+            process.stdout.write(`changed-scope: ${summariseChangedScope(classification)}\n\n`);
+        }
+        if (report.findings.length === 0) {
+            process.stdout.write('No drift detected.\n');
+            return 0;
+        }
+        for (const f of report.findings) {
+            const tag = f.severity.toUpperCase().padEnd(8);
+            process.stdout.write(`  ${tag} ${f.category.padEnd(22)} ${f.message}\n`);
+            if (f.suggestedFix)
+                process.stdout.write(`           ↳ ${f.suggestedFix}\n`);
+        }
+        return report.counts.error > 0 ? 1 : 0;
+    },
+};
+/**
+ * `shrk drift rules`. Classifies every rule into ENFORCED /
+ * PARTIALLY_ENFORCED / MANUAL_ONLY / ASPIRATIONAL / STALE / UNKNOWN so a
+ * maintainer can see whether the rule system is real or ceremonial.
+ *
+ * `--strict` fails when ASPIRATIONAL or STALE rules exist.
+ * `--json` emits the structured report.
+ */
+async function runDriftRules(args) {
+    const cwd = resolveCwd(args);
+    const inspection = await inspectSharkcraft({ cwd });
+    const report = classifyRuleDrift(inspection);
+    const strict = flagBool(args, 'strict');
+    if (flagBool(args, 'json')) {
+        process.stdout.write(asJson(report) + '\n');
+        return strict &&
+            (report.summary[RuleEnforcementState.Aspirational] > 0 ||
+                report.summary[RuleEnforcementState.Stale] > 0)
+            ? 1
+            : 0;
+    }
+    process.stdout.write(header('Rule enforcement drift'));
+    process.stdout.write(kv('totals', Object.entries(report.summary)
+        .filter(([, n]) => n > 0)
+        .map(([k, n]) => `${k}: ${n}`)
+        .join(', ') || 'no rules') + '\n\n');
+    if (report.entries.length === 0) {
+        process.stdout.write('No rules registered.\n');
+        return 0;
+    }
+    for (const e of report.entries) {
+        const tag = e.state.toUpperCase().padEnd(20);
+        const src = e.source.type === 'pack' ? `[${e.source.packageName ?? 'pack'}]` : '[local]';
+        process.stdout.write(`  ${tag} ${e.id.padEnd(36)} ${src} — ${e.reason}\n`);
+    }
+    if (report.nextCommands.length > 0) {
+        process.stdout.write('\nNext:\n');
+        for (const c of report.nextCommands)
+            process.stdout.write(`  ${c}\n`);
+    }
+    if (strict) {
+        const failing = report.summary[RuleEnforcementState.Aspirational] +
+            report.summary[RuleEnforcementState.Stale];
+        if (failing > 0) {
+            process.stdout.write(`\nStrict mode: failing because ${failing} rule(s) are aspirational or stale.\n`);
+            return 1;
+        }
+    }
+    return 0;
+}

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

@@ -0,0 +1,7 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const eslintScaffoldCommand: ICommandHandler;
+export declare const eslintReportCommand: ICommandHandler;
+export declare const eslintRulesCommand: ICommandHandler;
+export declare const eslintExplainLimitationsCommand: ICommandHandler;
+export declare const eslintCommand: ICommandHandler;
+//# sourceMappingURL=eslint.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eslint.command.d.ts","sourceRoot":"","sources":["../../src/commands/eslint.command.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA2DhC,eAAO,MAAM,qBAAqB,EAAE,eA8DnC,CAAC;AAiCF,eAAO,MAAM,mBAAmB,EAAE,eAiFjC,CAAC;AAgFF,eAAO,MAAM,kBAAkB,EAAE,eAsDhC,CAAC;AAkCF,eAAO,MAAM,+BAA+B,EAAE,eAyC7C,CAAC;AAmBF,eAAO,MAAM,aAAa,EAAE,eAuC3B,CAAC"}

package/dist/commands/eslint.command.js

@@ -0,0 +1,423 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { inspectSharkcraft } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson, bullet, header } from "../output/format-output.js";
+/**
+ * ESLint bridge. NOT a full ESLint plugin: a thin adapter that
+ *  (a) scaffolds a minimal flat-config snippet for repos that want to
+ *      keep their existing ESLint setup but co-exist cleanly with
+ *      SharkCraft (mainly: don't lint the generated paths SharkCraft
+ *      tracks);
+ *  (b) re-emits `shrk check boundaries` JSON in the ESLint result format
+ *      so ESLint-result-consuming tooling (annotators, reviewdog,
+ *      etc.) can surface SharkCraft boundary violations on PRs without
+ *      adopting the SharkCraft CLI directly.
+ *
+ *  Both subcommands default to dry-run. The scaffold is intentionally
+ *  small — the goal is integration, not opinion imposition.
+ */
+const SCAFFOLD_BANNER = "// Generated by `shrk eslint scaffold`. Edit freely — re-running with --force overwrites.";
+const SCAFFOLD_DEFAULT_RELPATH = 'eslint.sharkcraft.config.mjs';
+function renderEslintFlatConfigSnippet(generatedPathGlobs, paths) {
+    const globs = generatedPathGlobs.length
+        ? generatedPathGlobs.map((g) => `      '${g}',`).join('\n')
+        : "      // No generated paths declared in sharkcraft/paths.ts — add globs here as you adopt SharkCraft path conventions.";
+    const pathDocs = paths.length
+        ? paths.map((p) => `// - ${p.id}${p.description ? ` — ${p.description}` : ''}`).join('\n')
+        : '// (no SharkCraft path conventions declared yet — run `shrk paths list` after `shrk init --zero-config`)';
+    return `${SCAFFOLD_BANNER}
+//
+// This file is a starter snippet — import or merge it from your top-level
+// eslint.config.mjs. It does NOT replace your existing rules. It adds:
+//   - "ignores" for paths SharkCraft tracks as generated.
+//   - a comment block linking to the SharkCraft boundary check, which
+//     enforces cross-layer / cross-package discipline that ESLint cannot
+//     express.
+//
+// Known SharkCraft path conventions:
+${pathDocs}
+//
+// For cross-layer boundary enforcement run:
+//   $ shrk check boundaries --changed-only --json
+//
+export default [
+  {
+    ignores: [
+${globs}
+    ],
+  },
+];
+`;
+}
+export const eslintScaffoldCommand = {
+    name: 'scaffold',
+    description: 'Scaffold a minimal ESLint flat-config snippet that co-exists with SharkCraft (ignores generated paths + links to `shrk check boundaries`). Dry-run by default; `--write` persists.',
+    usage: 'shrk eslint scaffold [--output <path>] [--preset auto] [--write] [--force] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const presetMode = flagString(args, 'preset');
+        if (presetMode && presetMode !== 'auto') {
+            process.stderr.write(`Unknown --preset value "${presetMode}" (only "auto" is supported).\n`);
+            return 2;
+        }
+        // Pull path conventions + generated-dir globs from the live SharkCraft
+        // inspection. We tolerate missing config — small repos may not have
+        // adopted sharkcraft/ yet.
+        let pathDescriptors = [];
+        let generatedGlobs = [];
+        try {
+            const inspection = await inspectSharkcraft({ cwd });
+            const pathList = inspection.pathService.list();
+            pathDescriptors = pathList.map((p) => ({
+                id: p.id,
+                description: typeof p.metadata?.description === 'string' ? p.metadata.description : undefined,
+            }));
+            generatedGlobs = pathList
+                .filter((p) => p.tags?.some((t) => /generated|build|dist|output/i.test(t)))
+                .map((p) => (typeof p.metadata?.path === 'string' ? p.metadata.path : null))
+                .filter((g) => typeof g === 'string' && g.length > 0);
+        }
+        catch {
+            // best-effort — the scaffold still works without sharkcraft/.
+        }
+        const body = renderEslintFlatConfigSnippet(generatedGlobs, pathDescriptors);
+        const outputRel = flagString(args, 'output') ?? SCAFFOLD_DEFAULT_RELPATH;
+        const outputAbs = nodePath.isAbsolute(outputRel) ? outputRel : nodePath.join(cwd, outputRel);
+        if (flagBool(args, 'json')) {
+            const mode = flagBool(args, 'write') ? 'write' : 'dry-run';
+            process.stdout.write(asJson({ mode, output: outputAbs, bytes: body.length, body }) + '\n');
+            if (mode !== 'write')
+                return 0;
+        }
+        if (!flagBool(args, 'write')) {
+            process.stdout.write(header('ESLint scaffold — dry-run'));
+            process.stdout.write(`output: ${outputAbs}\n`);
+            process.stdout.write(`bytes:  ${body.length}\n\n`);
+            process.stdout.write(body);
+            process.stdout.write('\nRun with --write to persist.\n');
+            return 0;
+        }
+        if (existsSync(outputAbs) && !flagBool(args, 'force')) {
+            process.stderr.write(`Refusing to overwrite existing file: ${outputAbs}. Pass --force.\n`);
+            return 1;
+        }
+        mkdirSync(nodePath.dirname(outputAbs), { recursive: true });
+        writeFileSync(outputAbs, body, 'utf8');
+        process.stdout.write(`Wrote ${outputAbs}\n`);
+        return 0;
+    },
+};
+export const eslintReportCommand = {
+    name: 'report',
+    description: 'Re-emit `shrk check boundaries --json` output in the ESLint result format (array of { filePath, messages[] }) so ESLint-aware tooling can consume SharkCraft boundary violations.',
+    usage: 'shrk eslint report [--from <path>] [--output <path>] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const from = flagString(args, 'from');
+        const fromAbs = from
+            ? nodePath.isAbsolute(from)
+                ? from
+                : nodePath.join(cwd, from)
+            : null;
+        if (fromAbs && !existsSync(fromAbs)) {
+            process.stderr.write(`--from file not found: ${fromAbs}\n`);
+            return 1;
+        }
+        let report;
+        if (fromAbs) {
+            const raw = readFileSync(fromAbs, 'utf8');
+            try {
+                report = JSON.parse(raw);
+            }
+            catch (e) {
+                process.stderr.write(`Failed to parse boundary report JSON: ${e.message}\n`);
+                return 1;
+            }
+        }
+        else {
+            // No --from: tell the user the canonical pipeline.
+            process.stderr.write('No --from <boundary-report.json> passed. Generate one first:\n' +
+                '  $ shrk check boundaries --json > boundaries.json\n' +
+                '  $ shrk eslint report --from boundaries.json > eslint-results.json\n');
+            return 2;
+        }
+        const byFile = new Map();
+        for (const v of report.violations ?? []) {
+            const file = v.file ?? '<unknown>';
+            if (!byFile.has(file)) {
+                byFile.set(file, {
+                    filePath: nodePath.isAbsolute(file) ? file : nodePath.join(cwd, file),
+                    messages: [],
+                    errorCount: 0,
+                    warningCount: 0,
+                    fixableErrorCount: 0,
+                    fixableWarningCount: 0,
+                });
+            }
+            const entry = byFile.get(file);
+            const msg = {
+                ruleId: 'sharkcraft/boundary-violation',
+                severity: 2,
+                message: (v.reason ?? 'SharkCraft boundary violation') +
+                    (v.source && v.target ? ` (${v.source} → ${v.target})` : ''),
+                line: v.line ?? 1,
+                column: v.column ?? 1,
+            };
+            entry.messages.push(msg);
+            entry.errorCount += 1;
+        }
+        const out = Array.from(byFile.values());
+        const wantJson = flagBool(args, 'json') || !!flagString(args, 'output');
+        const outputRel = flagString(args, 'output');
+        const text = wantJson ? asJson(out) + '\n' : renderEslintReportText(out);
+        if (outputRel) {
+            const outputAbs = nodePath.isAbsolute(outputRel) ? outputRel : nodePath.join(cwd, outputRel);
+            mkdirSync(nodePath.dirname(outputAbs), { recursive: true });
+            writeFileSync(outputAbs, text, 'utf8');
+            process.stdout.write(`Wrote ${outputAbs}\n`);
+        }
+        else {
+            process.stdout.write(text);
+        }
+        return out.length > 0 ? 1 : 0;
+    },
+};
+function buildBridgeInventory(rules, paths) {
+    const rows = [];
+    for (const r of rules) {
+        const tagText = (r.tags ?? []).join(' ').toLowerCase();
+        const id = r.id.toLowerCase();
+        let status = 'not-bridgeable';
+        let notes = 'SharkCraft-only enforcement.';
+        if (tagText.includes('import') || tagText.includes('boundary') || id.includes('layer') || id.includes('import')) {
+            status = 'bridgeable';
+            notes = 'Representable via no-restricted-imports / boundary plugin.';
+        }
+        else if (tagText.includes('naming') || tagText.includes('file-shape')) {
+            status = 'bridgeable';
+            notes = 'Representable via @typescript-eslint naming or filename plugin.';
+        }
+        else if (tagText.includes('safety') || tagText.includes('signing') || tagText.includes('plan')) {
+            status = 'not-bridgeable';
+            notes = 'Plan / signing / safety semantics — keep in `shrk safety audit`.';
+        }
+        else if (tagText.includes('pack')) {
+            status = 'not-bridgeable';
+            notes = 'Pack-level — enforce with `shrk packs doctor`.';
+        }
+        else {
+            status = 'adjacent';
+            notes = '`shrk eslint report` re-emits findings in the ESLint result format.';
+        }
+        rows.push({ kind: 'rule', id: r.id, status, notes });
+    }
+    for (const p of paths) {
+        const tagText = (p.tags ?? []).join(' ').toLowerCase();
+        const isGenerated = /generated|build|dist|output/.test(tagText);
+        rows.push({
+            kind: 'path',
+            id: p.id,
+            status: isGenerated ? 'bridgeable' : 'adjacent',
+            notes: isGenerated
+                ? 'Goes in ESLint `ignores`.'
+                : 'Adjacent: surfaced for context; not directly enforceable by ESLint.',
+        });
+    }
+    rows.push({
+        kind: 'boundary',
+        id: 'check-boundaries',
+        status: 'adjacent',
+        notes: '`shrk eslint report` emits boundary violations in ESLint result format.',
+    });
+    rows.push({
+        kind: 'check',
+        id: 'custom-checks (sharkcraft.custom-check/v1)',
+        status: 'adjacent',
+        notes: '`shrk checks convert eslint <file>` round-trips ESLint into the SharkCraft protocol.',
+    });
+    rows.push({
+        kind: 'safety',
+        id: 'plan-signing / pack-signatures / knowledge-stale / template-drift',
+        status: 'not-bridgeable',
+        notes: 'CI gate only. ESLint has no semantic for any of these.',
+    });
+    return rows;
+}
+export const eslintRulesCommand = {
+    name: 'rules',
+    description: 'Inventory which SharkCraft constructs can be bridged to ESLint (bridgeable / adjacent / not-bridgeable). Read-only.',
+    usage: 'shrk eslint rules [--json] [--filter bridgeable|adjacent|not-bridgeable]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        let rules = [];
+        let paths = [];
+        try {
+            const inspection = await inspectSharkcraft({ cwd });
+            rules = inspection.ruleService.list().map((r) => ({
+                id: r.id,
+                description: typeof r.metadata?.description === 'string' ? r.metadata.description : undefined,
+                tags: r.tags ?? [],
+            }));
+            paths = inspection.pathService.list().map((p) => ({
+                id: p.id,
+                description: typeof p.metadata?.description === 'string' ? p.metadata.description : undefined,
+                tags: p.tags ?? [],
+            }));
+        }
+        catch {
+            // best-effort
+        }
+        const inventory = buildBridgeInventory(rules, paths);
+        const filter = flagString(args, 'filter');
+        const filtered = filter
+            ? inventory.filter((r) => r.status === filter)
+            : inventory;
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({ total: inventory.length, rows: filtered }) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`ESLint bridge inventory (${filtered.length} of ${inventory.length})`));
+        const buckets = {
+            bridgeable: [],
+            adjacent: [],
+            'not-bridgeable': [],
+        };
+        for (const r of filtered)
+            buckets[r.status].push(r);
+        for (const status of ['bridgeable', 'adjacent', 'not-bridgeable']) {
+            const rows = buckets[status];
+            if (!rows.length)
+                continue;
+            process.stdout.write(`\n[${status}] ${rows.length}\n`);
+            for (const r of rows) {
+                process.stdout.write(`  ${r.kind.padEnd(9)} ${r.id}\n`);
+                process.stdout.write(`            ${r.notes}\n`);
+            }
+        }
+        process.stdout.write('\nKeep in CI: `shrk check boundaries`, `shrk safety audit`, `shrk packs doctor`, `shrk knowledge stale-check`, `shrk templates drift`.\n');
+        return 0;
+    },
+};
+const ESLINT_LIMITATIONS = `\
+# ESLint bridge — limitations
+
+What the bridge **can** do today:
+
+  • \`shrk eslint scaffold\` — emit a flat-config snippet that ignores
+    SharkCraft generated paths and points at \`shrk check boundaries\`.
+  • \`shrk eslint report\` — re-emit \`shrk check boundaries --json\` in
+    the ESLint result format so existing ESLint-aware tooling
+    (reviewdog, GitHub annotations, …) shows SharkCraft violations.
+  • \`shrk eslint rules\` — inventory which SharkCraft constructs are
+    bridgeable, which are adjacent, which are not.
+
+What the bridge **cannot** express in ESLint:
+
+  • Plan safety (signing, divergence, \`--verify-signature\`). These
+    are write-path checks and belong in the SharkCraft CLI / CI.
+  • Pack signatures and \`shrk packs signature-status\`. ESLint has
+    no notion of distributed signed assets.
+  • Knowledge stale-check and template drift. They depend on the
+    SharkCraft registry, not on the source tree alone.
+  • Self-config doctor and the deep safety audit. These reason over
+    the whole config tree, not single source files.
+
+Recommendation: keep \`shrk doctor\`, \`shrk check boundaries\`,
+\`shrk safety audit\`, and (if you ship packs) \`shrk packs doctor\`
+in CI. Use ESLint for source-file linting only.
+
+Integration over competition: SharkCraft does not aim to replace
+ESLint. It rides alongside.
+`;
+export const eslintExplainLimitationsCommand = {
+    name: 'explain-limitations',
+    description: 'Print the honest list of what cannot be bridged from SharkCraft to ESLint and what to keep in CI.',
+    usage: 'shrk eslint explain-limitations [--json]',
+    async run(args) {
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson({
+                bridgeable: [
+                    'no-restricted-imports (forbidden imports / layer boundaries)',
+                    'generated path ignores',
+                    'naming / file-shape rules (via @typescript-eslint)',
+                ],
+                adjacent: [
+                    'shrk check boundaries (re-emitted in ESLint result format)',
+                    'custom-check reports (round-trip via `shrk checks convert eslint`)',
+                ],
+                notBridgeable: [
+                    'plan signing / --verify-signature',
+                    'pack signatures',
+                    'knowledge stale-check',
+                    'template drift',
+                    'self-config doctor',
+                    'safety audit --deep',
+                ],
+                keepInCi: [
+                    'shrk doctor',
+                    'shrk check boundaries',
+                    'shrk safety audit',
+                    'shrk packs doctor',
+                    'shrk knowledge stale-check',
+                    'shrk templates drift',
+                ],
+            }) + '\n');
+            return 0;
+        }
+        process.stdout.write(ESLINT_LIMITATIONS);
+        return 0;
+    },
+};
+function renderEslintReportText(files) {
+    if (files.length === 0) {
+        return 'SharkCraft boundary report contained no violations.\n';
+    }
+    const lines = [];
+    lines.push(header('SharkCraft → ESLint result format'));
+    for (const f of files) {
+        lines.push(f.filePath);
+        for (const m of f.messages) {
+            lines.push(`  ${m.line}:${m.column} ${m.ruleId} ${m.message}`);
+        }
+    }
+    lines.push('');
+    lines.push(bullet(`${files.length} file(s) with violations`));
+    return lines.join('\n') + '\n';
+}
+export const eslintCommand = {
+    name: 'eslint',
+    description: 'ESLint bridge. `scaffold` emits a flat-config snippet that ignores SharkCraft generated paths; `report` re-emits boundary violations in the ESLint result format; `rules` inventories what is bridgeable; `explain-limitations` documents what cannot be bridged. `config` is an alias for `scaffold`.',
+    usage: 'shrk eslint <scaffold|config|report|rules|explain-limitations> [...flags]',
+    async run(args) {
+        const verb = args.positional[0];
+        if (verb === 'scaffold' || verb === 'config') {
+            // `eslint config --preset auto` is the preferred shape;
+            // it routes to `scaffold` which already accepts `--preset auto`.
+            return eslintScaffoldCommand.run({
+                ...args,
+                positional: args.positional.slice(1),
+            });
+        }
+        if (verb === 'report') {
+            return eslintReportCommand.run({
+                ...args,
+                positional: args.positional.slice(1),
+            });
+        }
+        if (verb === 'rules') {
+            return eslintRulesCommand.run({
+                ...args,
+                positional: args.positional.slice(1),
+            });
+        }
+        if (verb === 'explain-limitations') {
+            return eslintExplainLimitationsCommand.run({
+                ...args,
+                positional: args.positional.slice(1),
+            });
+        }
+        process.stderr.write('Usage: shrk eslint <scaffold|config|report|rules|explain-limitations> [...flags]\n');
+        return 2;
+    },
+};

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

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

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

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

package/dist/commands/explore.command.js

@@ -0,0 +1,65 @@
+import { exploreArea, inspectSharkcraft, renderAreaExploreMarkdown, renderAreaExploreText, } from '@shrkcrft/inspector';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+import { COMMAND_CATALOG } from "./command-catalog.js";
+const ALL_MCP_TOOL_NAMES = [];
+async function getMcpToolNames() {
+    if (ALL_MCP_TOOL_NAMES.length > 0)
+        return ALL_MCP_TOOL_NAMES;
+    try {
+        const mod = (await import('@shrkcrft/mcp-server'));
+        if (mod?.ALL_TOOLS) {
+            for (const t of mod.ALL_TOOLS)
+                ALL_MCP_TOOL_NAMES.push(t.name);
+        }
+    }
+    catch {
+        // mcp-server not loadable from this entry — leave the list empty.
+    }
+    return ALL_MCP_TOOL_NAMES;
+}
+export const exploreCommand = {
+    name: 'explore',
+    description: 'Explore a directory: area kind, key modules, related commands/MCP tools, tests, conventions, risks. Read-only.',
+    usage: 'shrk explore <path> [--format text|markdown|json] [--top N]',
+    async run(args) {
+        const rawPath = args.positional[0];
+        if (!rawPath) {
+            process.stderr.write('Usage: shrk explore <path> [--format text|markdown|json]\n');
+            return 2;
+        }
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const mcpToolNames = await getMcpToolNames();
+        const pathConventions = inspection.pathService.list().map((p) => ({
+            id: p.id,
+            pattern: p.metadata?.path,
+        }));
+        const top = (() => {
+            const n = flagString(args, 'top');
+            if (!n)
+                return undefined;
+            const v = Number(n);
+            return Number.isFinite(v) && v > 0 ? v : undefined;
+        })();
+        const report = exploreArea({
+            inspection,
+            path: rawPath,
+            commandCatalog: COMMAND_CATALOG,
+            mcpToolNames,
+            pathConventions,
+            ...(top ? { topFiles: top } : {}),
+        });
+        const format = flagString(args, 'format') ?? (flagBool(args, 'json') ? 'json' : 'text');
+        if (format === 'json') {
+            process.stdout.write(asJson(report) + '\n');
+            return report.exists ? 0 : 1;
+        }
+        if (format === 'markdown') {
+            process.stdout.write(renderAreaExploreMarkdown(report));
+            return report.exists ? 0 : 1;
+        }
+        process.stdout.write(renderAreaExploreText(report));
+        return report.exists ? 0 : 1;
+    },
+};

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

@@ -0,0 +1,6 @@
+import { type ICommandHandler } from '../command-registry.js';
+export declare const exportBundleCommand: ICommandHandler;
+export declare const exportSessionCommand: ICommandHandler;
+export declare const exportQualityCommand: ICommandHandler;
+export declare const exportReviewCommand: ICommandHandler;
+//# sourceMappingURL=export-bundle.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"export-bundle.command.d.ts","sourceRoot":"","sources":["../../src/commands/export-bundle.command.ts"],"names":[],"mappings":"AASA,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAOhC,eAAO,MAAM,mBAAmB,EAAE,eAqBjC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,eAqBlC,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,eAclC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,eAqBjC,CAAC"}