@shrkcrft/cli 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/commands/deps-audit.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps-audit.command.d.ts","sourceRoot":"","sources":["../../src/commands/deps-audit.command.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAmBhC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,gBAAgB,EAAE,eAmE9B,CAAC"}

package/dist/commands/deps-audit.command.js

@@ -0,0 +1,270 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { GraphQueryApi, GraphStore, NodeKind } from '@shrkcrft/graph';
+import { flagBool, resolveCwd, } from "../command-registry.js";
+import { asJson, header } from "../output/format-output.js";
+/**
+ * `shrk deps-audit` — for each workspace package, compare the
+ * `package.json` `dependencies` / `devDependencies` / `peerDependencies`
+ * against the *specifiers actually imported* from source under
+ * `<pkg>/src/` (per the SharkCraft graph).
+ *
+ * Reports:
+ *   - missing deps: imported but not declared (likely build failure
+ *     in the wild — the package depends on its host's resolution)
+ *   - unused deps: declared but never imported (lint waste)
+ *
+ * Read-only. JSON output via `--json`. Optionally restricted to one
+ * package via `--package <name>`.
+ *
+ * Known limitations:
+ *   - Type-only imports (`import type x from 'y'`) still count; the
+ *     graph can't tell them apart in v3.
+ *   - Subpath imports (`pkg/sub`) are reduced to their root specifier.
+ *   - Built-in node modules (`node:fs`, `fs`, …) are ignored.
+ */
+export const depsAuditCommand = {
+    name: 'deps-audit',
+    description: 'Audit declared dependencies vs imports actually seen in each package source. Reports missing + unused deps. Read-only.',
+    usage: 'shrk deps-audit [--package <name>] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const json = flagBool(args, 'json');
+        const onlyPackage = typeof args.flags.get('package') === 'string'
+            ? args.flags.get('package')
+            : null;
+        const store = new GraphStore(cwd);
+        if (!store.exists()) {
+            process.stderr.write('No SharkCraft graph found. Run `shrk graph index` first so deps-audit has import data.\n');
+            return 1;
+        }
+        const api = GraphQueryApi.fromStore(cwd);
+        const packages = listWorkspacePackages(cwd, onlyPackage);
+        if (packages.length === 0) {
+            process.stderr.write('No packages found (looked under packages/*, libs/*, apps/*).\n');
+            return 1;
+        }
+        const reports = [];
+        for (const pkg of packages) {
+            reports.push(buildPackageReport(api, cwd, pkg));
+        }
+        if (json) {
+            process.stdout.write(asJson({ packages: reports }) + '\n');
+            return 0;
+        }
+        let missingTotal = 0;
+        let unusedTotal = 0;
+        for (const r of reports) {
+            missingTotal += r.missingDeps.length;
+            unusedTotal += r.unusedDeps.length;
+        }
+        process.stdout.write(header(`deps-audit — ${reports.length} package(s), ${missingTotal} missing dep(s), ${unusedTotal} unused dep(s)`));
+        for (const r of reports) {
+            if (r.missingDeps.length === 0 && r.unusedDeps.length === 0)
+                continue;
+            process.stdout.write(`\n${r.packageName} (${r.packageDir})\n`);
+            if (r.missingDeps.length > 0) {
+                process.stdout.write('  missing (imported, not declared):\n');
+                for (const m of r.missingDeps) {
+                    process.stdout.write(`    - ${m.specifier} (imported ${m.importedFromCount}×)\n`);
+                }
+            }
+            if (r.unusedDeps.length > 0) {
+                process.stdout.write('  unused (declared, never imported):\n');
+                for (const u of r.unusedDeps) {
+                    process.stdout.write(`    - ${u.specifier}  [${u.section}]\n`);
+                }
+            }
+        }
+        if (missingTotal === 0 && unusedTotal === 0) {
+            process.stdout.write('\nAll declared deps match actual imports. ✓\n');
+        }
+        return 0;
+    },
+};
+function listWorkspacePackages(cwd, onlyName) {
+    const roots = ['packages', 'libs', 'apps'].map((r) => nodePath.join(cwd, r)).filter((d) => existsSync(d));
+    const out = [];
+    for (const root of roots) {
+        let entries;
+        try {
+            entries = readdirSync(root);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const dir = nodePath.join(root, entry);
+            let stat;
+            try {
+                stat = statSync(dir);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isDirectory())
+                continue;
+            const pkgJsonPath = nodePath.join(dir, 'package.json');
+            if (!existsSync(pkgJsonPath))
+                continue;
+            let pkgJson;
+            try {
+                pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+            }
+            catch {
+                continue;
+            }
+            if (!pkgJson.name)
+                continue;
+            if (onlyName !== null && pkgJson.name !== onlyName)
+                continue;
+            out.push({ name: pkgJson.name, dir, pkgJsonPath });
+        }
+    }
+    return out;
+}
+function buildPackageReport(api, cwd, pkg) {
+    const declared = readDeclaredDeps(pkg.pkgJsonPath);
+    const importedSpecifiers = collectImportedSpecifiersForPackage(api, cwd, pkg.dir);
+    // Count how many distinct files inside the package import each specifier.
+    const importerCounts = new Map();
+    for (const spec of importedSpecifiers) {
+        importerCounts.set(spec, (importerCounts.get(spec) ?? 0) + 1);
+    }
+    const distinctImported = new Set(importedSpecifiers);
+    const declaredAll = new Map();
+    const declaredSections = [
+        ['dependencies', declared.dependencies],
+        ['devDependencies', declared.devDependencies],
+        ['peerDependencies', declared.peerDependencies],
+        ['optionalDependencies', declared.optionalDependencies],
+    ];
+    for (const [section, map] of declaredSections) {
+        for (const k of Object.keys(map))
+            declaredAll.set(k, section);
+    }
+    const missingDeps = [];
+    for (const spec of distinctImported) {
+        if (declaredAll.has(spec))
+            continue;
+        if (spec === pkg.name)
+            continue; // self-import via package name
+        missingDeps.push({ specifier: spec, importedFromCount: importerCounts.get(spec) ?? 0 });
+    }
+    missingDeps.sort((a, b) => b.importedFromCount - a.importedFromCount);
+    const unusedDeps = [];
+    for (const [spec, section] of declaredAll.entries()) {
+        if (distinctImported.has(spec))
+            continue;
+        // devDependencies for build/test tools often don't show up in graph
+        // imports; we still report them so the user can prune if desired.
+        unusedDeps.push({ specifier: spec, section });
+    }
+    unusedDeps.sort((a, b) => a.specifier.localeCompare(b.specifier));
+    return {
+        packageName: pkg.name,
+        packageDir: nodePath.relative(cwd, pkg.dir) || '.',
+        declared,
+        importedSpecifiers: [...distinctImported],
+        missingDeps,
+        unusedDeps,
+    };
+}
+function readDeclaredDeps(pkgJsonPath) {
+    try {
+        const body = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+        return {
+            dependencies: asStringMap(body['dependencies']),
+            devDependencies: asStringMap(body['devDependencies']),
+            peerDependencies: asStringMap(body['peerDependencies']),
+            optionalDependencies: asStringMap(body['optionalDependencies']),
+        };
+    }
+    catch {
+        return { dependencies: {}, devDependencies: {}, peerDependencies: {}, optionalDependencies: {} };
+    }
+}
+function asStringMap(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        if (typeof v === 'string')
+            out[k] = v;
+    }
+    return out;
+}
+function collectImportedSpecifiersForPackage(api, cwd, packageDir) {
+    const out = [];
+    const relDir = nodePath.relative(cwd, packageDir).replace(/\\/g, '/');
+    for (const file of api.allFiles()) {
+        if (file.kind !== NodeKind.File)
+            continue;
+        const p = file.path ?? '';
+        if (!p.startsWith(relDir + '/src/') && !p.startsWith(relDir + '/'))
+            continue;
+        // Each ImportsFile edge resolves to a file node; we want the *raw*
+        // import specifier, which the graph carries on the edge's data
+        // payload. We don't have direct access here, so we approximate by
+        // reading the file contents and extracting from-clauses.
+        const abs = nodePath.isAbsolute(p) ? p : nodePath.join(cwd, p);
+        if (!existsSync(abs))
+            continue;
+        let body;
+        try {
+            body = readFileSync(abs, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const spec of extractRootSpecifiers(body)) {
+            if (isBuiltinModule(spec))
+                continue;
+            if (spec.startsWith('.') || spec.startsWith('/'))
+                continue; // relative
+            out.push(rootOfSpecifier(spec));
+        }
+    }
+    return out;
+}
+const IMPORT_FROM_RE = /(?:^|\n)\s*(?:import|export)\s+[^;]*?\s+from\s+['"]([^'"]+)['"]/g;
+const REQUIRE_RE = /\brequire\(\s*['"]([^'"]+)['"]\s*\)/g;
+const DYNAMIC_IMPORT_RE = /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+function extractRootSpecifiers(body) {
+    const out = [];
+    for (const m of body.matchAll(IMPORT_FROM_RE)) {
+        if (m[1])
+            out.push(m[1]);
+    }
+    for (const m of body.matchAll(REQUIRE_RE)) {
+        if (m[1])
+            out.push(m[1]);
+    }
+    for (const m of body.matchAll(DYNAMIC_IMPORT_RE)) {
+        if (m[1])
+            out.push(m[1]);
+    }
+    return out;
+}
+function rootOfSpecifier(spec) {
+    if (spec.startsWith('@')) {
+        const parts = spec.split('/');
+        return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : spec;
+    }
+    return spec.split('/')[0];
+}
+function isBuiltinModule(spec) {
+    if (spec.startsWith('node:'))
+        return true;
+    // Bun runtime builtins (`bun:test`, `bun:sqlite`, `bun:ffi`, …) are provided by
+    // the runtime, never an npm dependency — so they are not "missing".
+    if (spec.startsWith('bun:'))
+        return true;
+    // Common bare-name builtins.
+    return new Set([
+        'fs', 'path', 'os', 'crypto', 'http', 'https', 'url', 'util', 'stream',
+        'events', 'child_process', 'process', 'buffer', 'querystring', 'zlib',
+        'tls', 'net', 'dns', 'dgram', 'cluster', 'worker_threads', 'perf_hooks',
+        'readline', 'tty', 'vm',
+    ]).has(spec);
+}

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

@@ -1 +1 @@
-{"version":3,"file":"dev.command.d.ts","sourceRoot":"","sources":["../../src/commands/dev.command.ts"],"names":[],"mappings":"AA6CA,OAAO,EAML,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA67ChC,eAAO,MAAM,UAAU,EAAE,eAkExB,CAAC"}
+{"version":3,"file":"dev.command.d.ts","sourceRoot":"","sources":["../../src/commands/dev.command.ts"],"names":[],"mappings":"AA6CA,OAAO,EAML,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAi8ChC,eAAO,MAAM,UAAU,EAAE,eAkExB,CAAC"}

package/dist/commands/dev.command.js

@@ -672,7 +672,11 @@ async function validateSession(args) {
     const allVerifications = flagBool(args, 'all-verifications');
     const allowPackCommands = flagBool(args, 'allow-pack-commands');
     const wantStrict = flagBool(args, 'strict');
-    const wantReport = flagBool(args, 'report') !== false; // default: write report
+    // flagBool is two-valued (absent → false), so `flagBool(...) !== false` is
+    // false when the flag is absent — the opposite of the intended default. Read
+    // the raw value: write the report by default, opt out only via --report=false.
+    const reportFlag = args.flags.get('report');
+    const wantReport = reportFlag !== false && reportFlag !== 'false';
     const wantJson = flagBool(args, 'json');
     const startedAt = new Date().toISOString();
     const reportFileName = `validate-${startedAt.replace(/[:.]/g, '-')}.json`;

package/dist/commands/diff-check.command.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `shrk diff-check` — agent self-validation after edits.
+ *
+ * The story this command tells:
+ *   1. An AI agent (Claude Code, Cursor, etc.) makes some file changes.
+ *   2. Before declaring "done", the agent runs `shrk diff-check`.
+ *   3. The command scopes both the boundary check and the
+ *      import-hygiene check to only the files the agent touched in the
+ *      current git diff.
+ *   4. The output is a single agent-friendly JSON envelope with a
+ *      verdict (ok / warnings / errors) and a one-line next action.
+ *
+ * Why a new command instead of "just run `shrk check boundaries
+ * --changed-only` and `shrk check imports --changed-only`":
+ *
+ *   - One command instead of two — agents reliably run the *one* tool
+ *     they're told to run; chained-command workflows get skipped.
+ *   - One verdict — no need to OR two separate JSON outputs.
+ *   - Stable, narrow schema — designed for agent consumption, not
+ *     human terminals. Won't grow flags over time.
+ *   - Concrete `nextAction` line — the agent knows exactly what to do
+ *     next (declare done, fix N things, or re-run after a manual fix).
+ *
+ * This is a pure composer — all real logic stays in
+ * `@shrkcrft/inspector` and `@shrkcrft/boundaries`. We just stitch
+ * their outputs together with consistent scoping.
+ */
+import { type ICommandHandler } from '../command-registry.js';
+export declare const diffCheckCommand: ICommandHandler;
+//# sourceMappingURL=diff-check.command.d.ts.map

package/dist/commands/diff-check.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-check.command.d.ts","sourceRoot":"","sources":["../../src/commands/diff-check.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAcH,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA0GhC,eAAO,MAAM,gBAAgB,EAAE,eAiI9B,CAAC"}

package/dist/commands/diff-check.command.js

@@ -0,0 +1,210 @@
+/**
+ * `shrk diff-check` — agent self-validation after edits.
+ *
+ * The story this command tells:
+ *   1. An AI agent (Claude Code, Cursor, etc.) makes some file changes.
+ *   2. Before declaring "done", the agent runs `shrk diff-check`.
+ *   3. The command scopes both the boundary check and the
+ *      import-hygiene check to only the files the agent touched in the
+ *      current git diff.
+ *   4. The output is a single agent-friendly JSON envelope with a
+ *      verdict (ok / warnings / errors) and a one-line next action.
+ *
+ * Why a new command instead of "just run `shrk check boundaries
+ * --changed-only` and `shrk check imports --changed-only`":
+ *
+ *   - One command instead of two — agents reliably run the *one* tool
+ *     they're told to run; chained-command workflows get skipped.
+ *   - One verdict — no need to OR two separate JSON outputs.
+ *   - Stable, narrow schema — designed for agent consumption, not
+ *     human terminals. Won't grow flags over time.
+ *   - Concrete `nextAction` line — the agent knows exactly what to do
+ *     next (declare done, fix N things, or re-run after a manual fix).
+ *
+ * This is a pure composer — all real logic stays in
+ * `@shrkcrft/inspector` and `@shrkcrft/boundaries`. We just stitch
+ * their outputs together with consistent scoping.
+ */
+import { buildImportHygieneReport, filterViolationsToChangedScope, inspectSharkcraft, resolveChangedFiles, } from '@shrkcrft/inspector';
+import { evaluateBoundaries, loadTsconfigPaths, scanImports, } from '@shrkcrft/boundaries';
+import { flagBool, flagString, resolveCwd, } from "../command-registry.js";
+import { asJson, bullet, header, kv } from "../output/format-output.js";
+const SCHEMA = 'sharkcraft.diff-check/v1';
+function resolveScope(args, cwd) {
+    const staged = flagBool(args, 'staged');
+    const since = flagString(args, 'since');
+    const filesRaw = flagString(args, 'files');
+    const files = filesRaw
+        ? filesRaw.split(',').map((s) => s.trim()).filter((s) => s.length > 0)
+        : [];
+    if (files.length > 0) {
+        return { mode: 'files', options: { projectRoot: cwd, files } };
+    }
+    if (staged) {
+        return { mode: 'staged', options: { projectRoot: cwd, staged: true } };
+    }
+    if (since) {
+        return { mode: 'since', options: { projectRoot: cwd, since } };
+    }
+    // Default: worktree (== `--changed-only` from `shrk check boundaries`).
+    return {
+        mode: 'worktree',
+        options: { projectRoot: cwd, includeWorktree: true },
+    };
+}
+function deriveVerdict(env) {
+    const bErr = env.boundaries.counts.error;
+    const bWarn = env.boundaries.counts.warning;
+    const iErr = env.imports.verdict === 'errors' ? (env.imports.counts.error ?? env.imports.findings.length) : 0;
+    const iWarn = env.imports.verdict === 'warnings' ? (env.imports.counts.warning ?? env.imports.findings.length) : 0;
+    if (env.scope.fileCount === 0) {
+        return {
+            verdict: 'ok',
+            summary: 'No files changed in the current diff scope.',
+            nextAction: 'Nothing to check. If you expected changes, verify your `--staged` / `--since <ref>` flag or save your edits first.',
+        };
+    }
+    if (bErr > 0 || iErr > 0) {
+        const parts = [];
+        if (bErr > 0)
+            parts.push(`${bErr} boundary violation${bErr === 1 ? '' : 's'}`);
+        if (iErr > 0)
+            parts.push(`${iErr} import-hygiene error${iErr === 1 ? '' : 's'}`);
+        return {
+            verdict: 'errors',
+            summary: `Diff fails the gate: ${parts.join(', ')}.`,
+            nextAction: 'Fix every error in `boundaries.violations` and `imports.findings` (look at each entry\'s `suggestedFix` line), then re-run `shrk diff-check`.',
+        };
+    }
+    if (bWarn > 0 || iWarn > 0) {
+        const parts = [];
+        if (bWarn > 0)
+            parts.push(`${bWarn} boundary warning${bWarn === 1 ? '' : 's'}`);
+        if (iWarn > 0)
+            parts.push(`${iWarn} import-hygiene warning${iWarn === 1 ? '' : 's'}`);
+        return {
+            verdict: 'warnings',
+            summary: `Diff passes the gate with ${parts.join(', ')}.`,
+            nextAction: 'Safe to declare done. Review warnings if the diff touches a sensitive area; otherwise these are non-blocking.',
+        };
+    }
+    return {
+        verdict: 'ok',
+        summary: `Diff passes the gate (${env.scope.fileCount} file${env.scope.fileCount === 1 ? '' : 's'}, 0 violations).`,
+        nextAction: 'Safe to declare done.',
+    };
+}
+export const diffCheckCommand = {
+    name: 'diff-check',
+    description: 'Self-check the current git diff against this project\'s boundary + import-hygiene rules. Single-call composite of `shrk check boundaries --changed-only` + `shrk check imports --changed-only`, with one verdict and one nextAction line. Designed for AI agents to run after editing — pass --json for the structured envelope.',
+    usage: 'shrk [--cwd <dir>] diff-check [--staged | --since <ref> | --files a.ts,b.ts] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const wantJson = flagBool(args, 'json');
+        const { mode, options: scopeOptions } = resolveScope(args, cwd);
+        // 1. Resolve the changed file set once. Both engines re-use it.
+        const changed = resolveChangedFiles(scopeOptions);
+        const changedFiles = changed.files;
+        // 2. Boundary engine — only if rules exist.
+        const inspection = await inspectSharkcraft({ cwd });
+        const rules = inspection.boundaryRegistry.list();
+        let boundaryBlock = {
+            ran: false,
+            rulesEvaluated: 0,
+            counts: { error: 0, warning: 0, info: 0 },
+            violations: [],
+        };
+        if (rules.length > 0 && changedFiles.length > 0) {
+            const scan = scanImports({ projectRoot: cwd });
+            const tsconfigPaths = loadTsconfigPaths(cwd);
+            const evalResult = evaluateBoundaries(scan, rules, {
+                ...(tsconfigPaths.aliases.size > 0 ? { tsconfigPaths } : {}),
+            });
+            const filtered = filterViolationsToChangedScope(evalResult.violations, scopeOptions);
+            boundaryBlock = {
+                ran: true,
+                rulesEvaluated: evalResult.rulesEvaluated,
+                counts: {
+                    error: filtered.includedViolations.filter((v) => v.severity === 'error').length,
+                    warning: filtered.includedViolations.filter((v) => v.severity === 'warning').length,
+                    info: filtered.includedViolations.filter((v) => v.severity === 'info').length,
+                },
+                violations: filtered.includedViolations,
+            };
+        }
+        else if (rules.length > 0 && changedFiles.length === 0) {
+            boundaryBlock = { ...boundaryBlock, ran: true, rulesEvaluated: rules.length };
+        }
+        // 3. Import-hygiene engine — always runs, but scoped to changed files.
+        let importsBlock = {
+            ran: false,
+            verdict: 'skipped',
+            counts: {},
+            findings: [],
+        };
+        if (changedFiles.length > 0) {
+            const report = buildImportHygieneReport(cwd, { files: changedFiles });
+            importsBlock = {
+                ran: true,
+                verdict: report.verdict,
+                counts: report.counts ?? {},
+                findings: report.findings,
+            };
+        }
+        // 4. Build envelope + derive verdict.
+        const partial = {
+            schema: SCHEMA,
+            generatedAt: new Date().toISOString(),
+            scope: {
+                mode,
+                files: changedFiles,
+                fileCount: changedFiles.length,
+            },
+            boundaries: boundaryBlock,
+            imports: importsBlock,
+        };
+        const { verdict, summary, nextAction } = deriveVerdict(partial);
+        const envelope = { ...partial, verdict, summary, nextAction };
+        // 5. Render.
+        if (wantJson) {
+            process.stdout.write(asJson(envelope) + '\n');
+            return verdict === 'errors' ? 1 : 0;
+        }
+        process.stdout.write(header('Diff check'));
+        process.stdout.write(kv('scope', `${envelope.scope.mode} (${envelope.scope.fileCount} file${envelope.scope.fileCount === 1 ? '' : 's'})`) + '\n');
+        process.stdout.write(kv('boundaries', envelope.boundaries.ran
+            ? `${envelope.boundaries.counts.error} errors, ${envelope.boundaries.counts.warning} warnings`
+            : '(no rules configured or no scoped files)') + '\n');
+        process.stdout.write(kv('imports', envelope.imports.ran
+            ? `verdict=${envelope.imports.verdict} (${envelope.imports.findings.length} finding${envelope.imports.findings.length === 1 ? '' : 's'})`
+            : '(no scoped files)') + '\n');
+        process.stdout.write(kv('verdict', envelope.verdict) + '\n');
+        process.stdout.write('\n');
+        process.stdout.write(envelope.summary + '\n');
+        if (envelope.boundaries.violations.length > 0) {
+            process.stdout.write('\nBoundary violations:\n');
+            for (const v of envelope.boundaries.violations.slice(0, 10)) {
+                const file = String(v.file ?? '');
+                const rule = String(v.ruleId ?? '');
+                const fix = v.suggestedFix ? ` — ${String(v.suggestedFix)}` : '';
+                process.stdout.write(bullet(`${rule} in ${file}${fix}`) + '\n');
+            }
+            if (envelope.boundaries.violations.length > 10) {
+                process.stdout.write(`  … and ${envelope.boundaries.violations.length - 10} more (pass --json for full list).\n`);
+            }
+        }
+        if (envelope.imports.findings.length > 0) {
+            process.stdout.write('\nImport findings:\n');
+            for (const f of envelope.imports.findings.slice(0, 10)) {
+                const file = String(f.path ?? f.file ?? '');
+                const kind = String(f.kind ?? '');
+                process.stdout.write(bullet(`${kind} in ${file}`) + '\n');
+            }
+            if (envelope.imports.findings.length > 10) {
+                process.stdout.write(`  … and ${envelope.imports.findings.length - 10} more (pass --json for full list).\n`);
+            }
+        }
+        process.stdout.write(`\nNext: ${envelope.nextAction}\n`);
+        return verdict === 'errors' ? 1 : 0;
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"doctor.command.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.command.ts"],"names":[],"mappings":"AAqBA,OAAO,EAML,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAwJhC,eAAO,MAAM,aAAa,EAAE,eAW3B,CAAC;AA0ZF,eAAO,MAAM,qBAAqB,EAAE,eAmCnC,CAAC;AAuDF,eAAO,MAAM,yBAAyB,EAAE,eAavC,CAAC;AAIF,eAAO,MAAM,wBAAwB,EAAE,eA2CtC,CAAC;AAgCF,eAAO,MAAM,6BAA6B,EAAE,eAa3C,CAAC"}
+{"version":3,"file":"doctor.command.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.command.ts"],"names":[],"mappings":"AAqBA,OAAO,EAML,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA6PhC,eAAO,MAAM,aAAa,EAAE,eAW3B,CAAC;AAwfF,eAAO,MAAM,qBAAqB,EAAE,eAmCnC,CAAC;AAuDF,eAAO,MAAM,yBAAyB,EAAE,eAavC,CAAC;AAIF,eAAO,MAAM,wBAAwB,EAAE,eA2CtC,CAAC;AAgCF,eAAO,MAAM,6BAA6B,EAAE,eAa3C,CAAC"}