@shrkcrft/cli 0.1.0-alpha.1

package/dist/commands/boundaries.command.js

@@ -0,0 +1,326 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildOnboardingPlan, buildPolyglotBoundaryReport, inspectSharkcraft, renderPolyglotBoundaryReportMarkdown, renderPolyglotBoundaryReportText, suggestBoundaryFixes, } from '@shrkcrft/inspector';
+import { evaluateBoundaries, loadTsconfigPaths, scanImports, } from '@shrkcrft/boundaries';
+import { flagBool, flagString, resolveCwd } from "../command-registry.js";
+import { asJson, header, kv } from "../output/format-output.js";
+export const boundariesListCommand = {
+    name: 'list',
+    description: 'List all registered boundary rules (local + pack-contributed).',
+    usage: 'shrk [--cwd <dir>] boundaries list [--json]',
+    async run(args) {
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const rules = inspection.boundaryRegistry.list();
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(rules) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Boundary rules (${rules.length})`));
+        if (rules.length === 0) {
+            process.stdout.write('  (none registered)\n');
+            return 0;
+        }
+        for (const r of rules) {
+            process.stdout.write(`  ${(r.severity ?? 'warning').toUpperCase().padEnd(8)} ${r.id.padEnd(36)} ${r.title}\n`);
+        }
+        return 0;
+    },
+};
+export const boundariesGetCommand = {
+    name: 'get',
+    description: 'Show one boundary rule (by id) in full.',
+    usage: 'shrk [--cwd <dir>] boundaries get <ruleId> [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk boundaries get <ruleId>\n');
+            return 2;
+        }
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const rule = inspection.boundaryRegistry.get(id);
+        if (!rule) {
+            process.stderr.write(`No boundary rule with id "${id}".\n`);
+            return 1;
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(rule) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Boundary rule: ${rule.id}`));
+        process.stdout.write(kv('title', rule.title) + '\n');
+        process.stdout.write(kv('severity', rule.severity ?? 'warning') + '\n');
+        if (rule.from && rule.from.length > 0) {
+            process.stdout.write(kv('from', rule.from.join(', ')) + '\n');
+        }
+        if (rule.forbiddenImports && rule.forbiddenImports.length > 0) {
+            process.stdout.write(kv('forbidden', rule.forbiddenImports.join(', ')) + '\n');
+        }
+        if (rule.allowedImports && rule.allowedImports.length > 0) {
+            process.stdout.write(kv('allowed', rule.allowedImports.join(', ')) + '\n');
+        }
+        if (rule.suggestedFix) {
+            process.stdout.write(kv('suggestedFix', rule.suggestedFix) + '\n');
+        }
+        return 0;
+    },
+};
+export const boundariesExplainCommand = {
+    name: 'explain',
+    description: 'Explain a boundary rule: where it came from (local vs pack), what it forbids, what to do about violations.',
+    usage: 'shrk [--cwd <dir>] boundaries explain <ruleId> [--json]',
+    async run(args) {
+        const id = args.positional[0];
+        if (!id) {
+            process.stderr.write('Usage: shrk boundaries explain <ruleId>\n');
+            return 2;
+        }
+        const inspection = await inspectSharkcraft({ cwd: resolveCwd(args) });
+        const rule = inspection.boundaryRegistry.get(id);
+        if (!rule) {
+            process.stderr.write(`No boundary rule with id "${id}".\n`);
+            return 1;
+        }
+        const source = inspection.boundarySources.get(id);
+        const explanation = {
+            id: rule.id,
+            title: rule.title,
+            severity: rule.severity ?? 'warning',
+            origin: source ? (source.type === 'pack' ? `pack: ${source.packageName}` : 'local') : 'unknown',
+            from: rule.from ?? [],
+            forbiddenImports: rule.forbiddenImports ?? [],
+            allowedImports: rule.allowedImports ?? [],
+            suggestedFix: rule.suggestedFix,
+            howToFix: 'Adjust the offending import to either (a) drop the disallowed dependency, (b) use a public interface from the allowed list, or (c) move the importer into a layer where this dependency is permitted.',
+        };
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(explanation) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Boundary explain: ${rule.id}`));
+        process.stdout.write(kv('title', rule.title) + '\n');
+        process.stdout.write(kv('severity', rule.severity ?? 'warning') + '\n');
+        process.stdout.write(kv('origin', explanation.origin) + '\n');
+        if (explanation.from.length > 0) {
+            process.stdout.write(kv('applies to', explanation.from.join(', ')) + '\n');
+        }
+        if (explanation.forbiddenImports.length > 0) {
+            process.stdout.write(kv('forbidden', explanation.forbiddenImports.join(', ')) + '\n');
+        }
+        if (explanation.allowedImports.length > 0) {
+            process.stdout.write(kv('allowed', explanation.allowedImports.join(', ')) + '\n');
+        }
+        if (rule.suggestedFix)
+            process.stdout.write(`\nSuggested fix: ${rule.suggestedFix}\n`);
+        process.stdout.write(`\nHow to fix: ${explanation.howToFix}\n`);
+        return 0;
+    },
+};
+export const boundariesInferCommand = {
+    name: 'infer',
+    description: 'Infer candidate boundary rules from the current repo (monorepo structure, package boundaries, naming heuristics). Dry-run by default; --write-drafts writes to sharkcraft/boundary-drafts/boundaries.draft.ts. --language all|java|csharp|python|go|rust adds polyglot suggestions.',
+    usage: 'shrk [--cwd <dir>] boundaries infer [--write-drafts] [--language all|java|csharp|python|go|rust] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const plan = buildOnboardingPlan(inspection, {});
+        const inferred = plan.inferredBoundaryRules;
+        const langFlag = flagString(args, 'language');
+        let languageSuggestions = null;
+        if (langFlag) {
+            const { suggestLanguageBoundaries } = await import('@shrkcrft/inspector');
+            const lang = langFlag.toLowerCase();
+            languageSuggestions = suggestLanguageBoundaries(cwd, lang === 'all' ? {} : { language: lang });
+        }
+        const wantJson = flagBool(args, 'json');
+        const writeDrafts = flagBool(args, 'write-drafts');
+        if (writeDrafts) {
+            const outDir = nodePath.join(cwd, 'sharkcraft', 'boundary-drafts');
+            mkdirSync(outDir, { recursive: true });
+            const outFile = nodePath.join(outDir, 'boundaries.draft.ts');
+            if (!outFile.startsWith(outDir + nodePath.sep)) {
+                process.stderr.write('Refusing to write outside boundary-drafts dir.\n');
+                return 1;
+            }
+            const body = renderInferredBoundariesDraft(inferred);
+            writeFileSync(outFile, body, 'utf8');
+            if (wantJson) {
+                process.stdout.write(asJson({ mode: 'write-drafts', outFile, bytes: body.length, count: inferred.length }) +
+                    '\n');
+                return 0;
+            }
+            process.stdout.write(header('Boundary inference (write-drafts)'));
+            process.stdout.write(kv('outFile', outFile) + '\n');
+            process.stdout.write(kv('count', String(inferred.length)) + '\n');
+            return 0;
+        }
+        if (wantJson) {
+            process.stdout.write(asJson({ inferred, ...(languageSuggestions ? { languageSuggestions } : {}) }) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Inferred boundary rules (${inferred.length})`));
+        if (inferred.length === 0) {
+            process.stdout.write('  (no candidates inferred)\n');
+        }
+        for (const r of inferred) {
+            process.stdout.write(`  ${r.severity.toUpperCase().padEnd(8)} ${r.id.padEnd(36)} ${r.title}\n`);
+            process.stdout.write(`           reason: ${r.reason}\n`);
+        }
+        if (languageSuggestions && languageSuggestions.suggestions.length > 0) {
+            process.stdout.write(`\nPolyglot suggestions (${languageSuggestions.suggestions.length}):\n`);
+            for (const s of languageSuggestions.suggestions) {
+                process.stdout.write(`  ${s.severity.toUpperCase().padEnd(8)} [${s.language}] ${s.id.padEnd(48)} ${s.title}\n`);
+                process.stdout.write(`           reason: ${s.reason}\n`);
+            }
+        }
+        process.stdout.write('\nDry-run only. Re-run with `--write-drafts` to write sharkcraft/boundary-drafts/boundaries.draft.ts.\n');
+        return 0;
+    },
+};
+function renderInferredBoundariesDraft(rules) {
+    const lines = [];
+    lines.push('// Boundary rules inferred by `shrk boundaries infer --write-drafts`.');
+    lines.push('// Review and copy keepers into sharkcraft/boundaries.ts.');
+    lines.push('export default [');
+    for (const r of rules) {
+        lines.push(`  {`);
+        lines.push(`    id: '${r.id}',`);
+        lines.push(`    title: ${JSON.stringify(r.title)},`);
+        lines.push(`    severity: '${r.severity}',`);
+        lines.push(`    from: ${JSON.stringify(r.from)},`);
+        if (r.forbiddenImports && r.forbiddenImports.length > 0) {
+            lines.push(`    forbiddenImports: ${JSON.stringify(r.forbiddenImports)},`);
+        }
+        if (r.allowedImports && r.allowedImports.length > 0) {
+            lines.push(`    allowedImports: ${JSON.stringify(r.allowedImports)},`);
+        }
+        lines.push(`    suggestedFix: ${JSON.stringify(r.suggestedFix)},`);
+        lines.push(`    // reason: ${r.reason}`);
+        lines.push(`  },`);
+    }
+    lines.push('];');
+    return lines.join('\n') + '\n';
+}
+/** Polyglot enforcement subcommand. */
+export const boundariesEnforceCommand = {
+    name: 'enforce',
+    description: 'Polyglot boundary enforcement report. Read-only; CLI-only — never mutates source.',
+    usage: 'shrk [--cwd <dir>] boundaries enforce [--language all|java|csharp|python|go|rust|typescript] [--changed-only|--since <ref>|--staged|--files a,b,c] [--format text|markdown|json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const langFlag = (flagString(args, 'language') ?? 'all').toLowerCase();
+        const languages = langFlag === 'all' ? undefined : [langFlag];
+        const report = buildPolyglotBoundaryReport({ projectRoot: cwd, ...(languages ? { languages } : {}) });
+        // Changed-only filtering against the polyglot report.
+        const changedOnly = flagBool(args, 'changed-only');
+        const staged = flagBool(args, 'staged');
+        const since = flagString(args, 'since');
+        const filesRaw = flagString(args, 'files');
+        const fileList = filesRaw
+            ? filesRaw.split(',').map((s) => s.trim()).filter(Boolean)
+            : [];
+        if (since) {
+            const { verifyGitRef } = await import('@shrkcrft/inspector');
+            const verify = verifyGitRef(cwd, since);
+            if (!verify.valid) {
+                process.stderr.write(`error: --since ref "${since}" does not resolve to a commit in this repository.\n` +
+                    (verify.suggestions && verify.suggestions.length > 0
+                        ? `\nDid you mean:\n${verify.suggestions.map((s) => `  --since ${s}`).join('\n')}\n`
+                        : '') +
+                    '\nUse `git branch -a` to list available refs.\n');
+                return 2;
+            }
+        }
+        const wantChangedScope = changedOnly || staged || Boolean(since) || fileList.length > 0;
+        const { filterViolationsToChangedScope } = await import('@shrkcrft/inspector');
+        const filtered = wantChangedScope
+            ? filterViolationsToChangedScope(report.violations, {
+                projectRoot: cwd,
+                ...(fileList.length > 0 ? { files: fileList } : {}),
+                ...(staged ? { staged: true } : {}),
+                ...(since ? { since } : {}),
+                ...(changedOnly && !staged && !since && fileList.length === 0
+                    ? { includeWorktree: true }
+                    : {}),
+            })
+            : null;
+        const finalViolations = filtered ? filtered.includedViolations : report.violations;
+        const errors = finalViolations.filter((v) => v.severity === 'error').length;
+        const warnings = finalViolations.filter((v) => v.severity === 'warning').length;
+        const format = (flagString(args, 'format') ?? 'text').toLowerCase();
+        if (flagBool(args, 'json') || format === 'json') {
+            const payload = {
+                ...report,
+                violations: finalViolations,
+                counts: { ...report.counts, errors, warnings },
+                ...(filtered
+                    ? {
+                        changedScope: {
+                            mode: filtered.mode,
+                            changedFiles: filtered.changedFiles,
+                            ignoredLegacyCount: filtered.ignoredLegacyCount,
+                            ignoredLegacyByRule: filtered.ignoredLegacyByRule,
+                        },
+                    }
+                    : {}),
+            };
+            process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
+            return errors > 0 ? 1 : 0;
+        }
+        if (format === 'markdown' || format === 'md') {
+            process.stdout.write(renderPolyglotBoundaryReportMarkdown({ ...report, violations: finalViolations, counts: { ...report.counts, errors, warnings } }) + '\n');
+            return errors > 0 ? 1 : 0;
+        }
+        // Default text path: render via existing renderer and append changed-scope footer.
+        process.stdout.write(renderPolyglotBoundaryReportText({ ...report, violations: finalViolations, counts: { ...report.counts, errors, warnings } }));
+        if (filtered) {
+            process.stdout.write(`\nMode: ${filtered.mode}\n`);
+            process.stdout.write(`Changed files: ${filtered.changedFiles.length}\n`);
+            process.stdout.write(`Legacy ignored: ${filtered.ignoredLegacyCount}\n`);
+            if (finalViolations.length === 0) {
+                process.stdout.write('No polyglot boundary violations introduced by changed files.\n');
+            }
+        }
+        return errors > 0 ? 1 : 0;
+    },
+};
+export const boundariesSuggestCommand = {
+    name: 'suggest',
+    description: 'Suggest fixes for boundary violations (by rule id, file, or all).',
+    usage: 'shrk boundaries suggest [<ruleId or file>] [--json]',
+    async run(args) {
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const rules = inspection.boundaryRegistry.list();
+        if (rules.length === 0) {
+            process.stderr.write('No boundary rules configured.\n');
+            return 0;
+        }
+        const scan = scanImports({ projectRoot: cwd });
+        const tsconfigPaths = loadTsconfigPaths(cwd);
+        const evalResult = evaluateBoundaries(scan, rules, {
+            ...(tsconfigPaths.aliases.size > 0 ? { tsconfigPaths } : {}),
+        });
+        const filter = args.positional[0];
+        const filtered = filter
+            ? evalResult.violations.filter((v) => v.ruleId === filter || v.file.includes(filter))
+            : evalResult.violations;
+        const suggestions = suggestBoundaryFixes(inspection, filtered.map((v) => ({
+            ruleId: v.ruleId,
+            file: v.file,
+            line: v.line,
+            importSpecifier: v.importSpecifier,
+            ...(v.suggestedFix ? { suggestedFix: v.suggestedFix } : {}),
+        })));
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(suggestions) + '\n');
+            return 0;
+        }
+        process.stdout.write(header(`Boundary fix suggestions (${suggestions.length})`));
+        for (const s of suggestions) {
+            process.stdout.write(`  ${s.ruleId}  ${s.file}:${s.line}\n`);
+            for (const sug of s.suggestions)
+                process.stdout.write(`    ↳ ${sug}\n`);
+        }
+        return 0;
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"brief.command.d.ts","sourceRoot":"","sources":["../../src/commands/brief.command.ts"],"names":[],"mappings":"AAYA,OAAO,EAML,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AAehC,eAAO,MAAM,YAAY,EAAE,eAmJ1B,CAAC"}

package/dist/commands/brief.command.js

@@ -0,0 +1,206 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { buildAgentBrief, BriefMode, getChangedFiles, inspectSharkcraft, setDevNextAction, writeDevSessionState, scanDevSession, } from '@shrkcrft/inspector';
+import { flagBool, flagNumber, flagString, flagList, resolveCwd, } from "../command-registry.js";
+import { asJson } from "../output/format-output.js";
+const VALID_MODES = new Set(Object.values(BriefMode));
+function resolveMode(args) {
+    const raw = flagString(args, 'mode');
+    if (!raw)
+        return undefined;
+    if (!VALID_MODES.has(raw)) {
+        process.stderr.write(`Unknown --mode "${raw}". Use ${[...VALID_MODES].join('|')}.\n`);
+        process.exit(2);
+    }
+    return raw;
+}
+export const briefCommand = {
+    name: 'brief',
+    description: 'Render a single Markdown / JSON brief for an AI agent before it starts work. Read-only.',
+    usage: 'shrk brief "<task>" [--mode compact|full|review|implementation|handoff] [--since ref] [--staged] [--files a,b] [--bundle id] [--session id] [--output file.md] [--chunk [--output-dir <dir>]] [--section-budget rules=N,impact=N] [--max-tokens N] [--json]',
+    async run(args) {
+        const task = args.positional.join(' ').trim();
+        const cwd = resolveCwd(args);
+        const inspection = await inspectSharkcraft({ cwd });
+        const mode = resolveMode(args);
+        const since = flagString(args, 'since');
+        const staged = flagBool(args, 'staged');
+        const files = flagList(args, 'files');
+        const bundleId = flagString(args, 'bundle');
+        const sessionId = flagString(args, 'session');
+        const maxTokens = flagNumber(args, 'max-tokens');
+        const fileSet = [...files];
+        if (since)
+            fileSet.push(...getChangedFiles(cwd, { since }));
+        if (staged)
+            fileSet.push(...getChangedFiles(cwd, { staged: true }));
+        const wantChunked = flagBool(args, 'chunk') || flagBool(args, 'chunked');
+        const outputDir = flagString(args, 'output-dir');
+        const sectionBudgetRaw = flagString(args, 'section-budget');
+        const sectionBudgets = {};
+        if (sectionBudgetRaw) {
+            for (const pair of sectionBudgetRaw.split(',')) {
+                const [k, v] = pair.split('=');
+                if (k && v && !Number.isNaN(Number(v)))
+                    sectionBudgets[k.trim()] = Number(v);
+            }
+        }
+        const brief = await buildAgentBrief(inspection, {
+            ...(task ? { task } : {}),
+            ...(mode ? { mode } : {}),
+            files: [...new Set(fileSet)],
+            ...(since ? { since } : {}),
+            staged,
+            ...(bundleId ? { bundleId } : {}),
+            ...(sessionId ? { sessionId } : {}),
+            ...(maxTokens ? { maxTokens } : {}),
+            ...(wantChunked ? { chunked: true } : {}),
+            ...(Object.keys(sectionBudgets).length > 0 ? { sectionBudgets } : {}),
+        });
+        if (wantChunked) {
+            const dir = outputDir
+                ? nodePath.isAbsolute(outputDir)
+                    ? outputDir
+                    : nodePath.resolve(cwd, outputDir)
+                : null;
+            // Hashes for every section, used for cross-session delta detection.
+            const sectionHashes = {};
+            for (const c of brief.chunks ?? []) {
+                sectionHashes[c.sectionId] = createHash('sha256').update(c.body).digest('hex');
+            }
+            if (dir) {
+                mkdirSync(dir, { recursive: true });
+                for (const c of brief.chunks ?? []) {
+                    writeFileSync(nodePath.join(dir, c.file), c.body, 'utf8');
+                }
+                writeFileSync(nodePath.join(dir, 'section-hashes.json'), JSON.stringify({ schema: 'sharkcraft.brief-section-hashes/v1', task: brief.task, sectionHashes }, null, 2) + '\n', 'utf8');
+            }
+            // Optional comparison against a previous brief chunk directory.
+            let compareReport = null;
+            const compareWith = flagString(args, 'compare-with');
+            if (compareWith) {
+                const otherAbs = nodePath.isAbsolute(compareWith)
+                    ? compareWith
+                    : nodePath.resolve(cwd, compareWith);
+                compareReport = compareBriefDirs(brief.chunks ?? [], otherAbs);
+            }
+            if (flagBool(args, 'json')) {
+                process.stdout.write(asJson({ ...brief, outputDir: dir, sectionHashes, compare: compareReport }) + '\n');
+            }
+            else {
+                if (dir) {
+                    process.stdout.write(`Wrote ${brief.chunks?.length ?? 0} chunk(s) to ${dir}\n`);
+                }
+                else {
+                    for (const c of brief.chunks ?? []) {
+                        process.stdout.write(`\n--- ${c.file} (${c.tokenEstimate} toks) ---\n`);
+                        process.stdout.write(c.body);
+                    }
+                }
+                if (compareReport) {
+                    process.stdout.write(`\nCompare vs ${compareReport.otherDir}:\n` +
+                        `  unchanged=${compareReport.unchanged.length}  changed=${compareReport.changed.length}  new=${compareReport.added.length}  removed=${compareReport.removed.length}\n`);
+                    if (compareReport.changed.length > 0) {
+                        process.stdout.write('  changed:\n');
+                        for (const c of compareReport.changed.slice(0, 20))
+                            process.stdout.write(`    ~ ${c.sectionId} (${c.file})\n`);
+                    }
+                    if (compareReport.added.length > 0) {
+                        process.stdout.write('  new:\n');
+                        for (const c of compareReport.added.slice(0, 20))
+                            process.stdout.write(`    + ${c.sectionId} (${c.file})\n`);
+                    }
+                    if (compareReport.removed.length > 0) {
+                        process.stdout.write('  removed:\n');
+                        for (const c of compareReport.removed.slice(0, 20))
+                            process.stdout.write(`    - ${c.sectionId} (${c.file})\n`);
+                    }
+                }
+            }
+            return 0;
+        }
+        const output = flagString(args, 'output');
+        if (output) {
+            const abs = nodePath.isAbsolute(output) ? output : nodePath.resolve(cwd, output);
+            mkdirSync(nodePath.dirname(abs), { recursive: true });
+            writeFileSync(abs, brief.markdown, 'utf8');
+            // If --session was used and output went into the session dir, record the path.
+            if (sessionId) {
+                const load = scanDevSession(cwd, sessionId);
+                if (load?.state) {
+                    const dir = load.dir;
+                    if (abs.startsWith(dir + nodePath.sep)) {
+                        const updated = setDevNextAction(load.state, load.state.nextAction);
+                        // mutate session.json with brief path stored under nextAction-adjacent metadata via warnings is awkward;
+                        // we just leave the path on disk.
+                        writeDevSessionState(cwd, updated);
+                    }
+                }
+            }
+            if (flagBool(args, 'json')) {
+                process.stdout.write(asJson({ ...brief, outputPath: abs }) + '\n');
+            }
+            else {
+                process.stdout.write(`Wrote ${abs}\n`);
+            }
+            return 0;
+        }
+        if (flagBool(args, 'json')) {
+            process.stdout.write(asJson(brief) + '\n');
+            return 0;
+        }
+        process.stdout.write(brief.markdown);
+        return 0;
+    },
+};
+function sectionIdFromFile(name) {
+    // Chunks are named NN-<sectionId>.md (e.g. 01-task.md). Strip the prefix.
+    const trimmed = name.replace(/\.md$/, '');
+    const m = /^\d+-(.+)$/.exec(trimmed);
+    return m ? m[1] : trimmed;
+}
+function compareBriefDirs(currentChunks, otherDir) {
+    const currentMap = new Map();
+    for (const c of currentChunks)
+        currentMap.set(c.sectionId, { file: c.file, body: c.body });
+    const otherMap = new Map();
+    if (existsSync(otherDir)) {
+        for (const f of readdirSync(otherDir)) {
+            if (!f.endsWith('.md'))
+                continue;
+            const full = nodePath.join(otherDir, f);
+            if (!statSync(full).isFile())
+                continue;
+            const id = sectionIdFromFile(f);
+            try {
+                otherMap.set(id, { file: f, body: readFileSync(full, 'utf8') });
+            }
+            catch {
+                /* skip */
+            }
+        }
+    }
+    const unchanged = [];
+    const changed = [];
+    const added = [];
+    const removed = [];
+    for (const [id, cur] of currentMap) {
+        const other = otherMap.get(id);
+        if (!other) {
+            added.push({ sectionId: id, file: cur.file });
+        }
+        else if (other.body === cur.body) {
+            unchanged.push({ sectionId: id, file: cur.file });
+        }
+        else {
+            changed.push({ sectionId: id, file: cur.file });
+        }
+    }
+    for (const [id, other] of otherMap) {
+        if (!currentMap.has(id))
+            removed.push({ sectionId: id, file: other.file });
+    }
+    return { otherDir, unchanged, changed, added, removed };
+}
+void existsSync;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.command.d.ts","sourceRoot":"","sources":["../../src/commands/bundle.command.ts"],"names":[],"mappings":"AA0CA,OAAO,EAML,KAAK,eAAe,EAErB,MAAM,wBAAwB,CAAC;AA+4BhC,eAAO,MAAM,aAAa,EAAE,eAkC3B,CAAC"}