mustflow 2.75.2 → 2.85.4

package/dist/cli/lib/script-pack-registry.js

@@ -14,8 +14,9 @@ export const SCRIPT_PACKS = [
                 summaryKey: 'scriptPack.script.codeOutline.summary',
                 actions: ['scan'],
                 useWhen: [
-                    'Scan TypeScript or JavaScript files for symbol headers and source anchors before reading large source files chunk by chunk.',
-                    'Build a bounded source outline with file paths, line ranges, signatures, export flags, source-anchor metadata, and content hashes for codebase orientation.',
+                    'Scan supported source files for symbol headers and source anchors before reading large files chunk by chunk.',
+                    'Build a bounded source outline with file paths, language metadata, line ranges, signatures, ' +
+                        'export flags, source-anchor metadata, and content hashes for codebase orientation.',
                 ],
                 phases: ['before_change', 'during_change', 'review'],
                 readOnly: true,
@@ -35,22 +36,80 @@ export const SCRIPT_PACKS = [
                 reportSchemaFile: 'code-outline-report.schema.json',
                 loadRunner: async () => (await import('../script-packs/code-outline.js')).runCodeOutlineScript,
             },
+            {
+                packId: 'code',
+                id: 'dependency-graph',
+                ref: scriptRef('code', 'dependency-graph'),
+                usage: 'mf script-pack run code/dependency-graph scan <path...> [options]',
+                summaryKey: 'scriptPack.script.codeDependencyGraph.summary',
+                actions: ['scan'],
+                useWhen: [
+                    'Trace relative TypeScript and JavaScript import, export, require, and dynamic import edges before changing a module.',
+                    'Build a bounded dependency graph with nodes, edges, depth, importer counts, import counts, and cycle hints for source impact orientation.',
+                ],
+                phases: ['before_change', 'during_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['path', 'max_files', 'max_file_bytes', 'max_depth', 'max_nodes', 'max_edges'],
+                outputs: ['human_summary', 'json_report', 'dependency_graph', 'cycle_hints'],
+                relatedSkills: [
+                    'change-blast-radius-review',
+                    'codebase-orientation',
+                    'javascript-code-change',
+                    'module-boundary-review',
+                    'typescript-code-change',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'dependency-graph-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/code-dependency-graph.js')).runCodeDependencyGraphScript,
+            },
+            {
+                packId: 'code',
+                id: 'change-impact',
+                ref: scriptRef('code', 'change-impact'),
+                usage: 'mf script-pack run code/change-impact analyze [path...] [options]',
+                summaryKey: 'scriptPack.script.codeChangeImpact.summary',
+                actions: ['analyze'],
+                useWhen: [
+                    'Analyze current git changes and produce bounded file, script-pack, and verification hints after a change.',
+                    'Classify changed source, test, docs, schema, package, template, and workflow surfaces before choosing follow-up checks.',
+                ],
+                phases: ['after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['path', 'base_ref', 'head_ref', 'max_files', 'max_impacts', 'max_file_bytes'],
+                outputs: ['human_summary', 'json_report', 'changed_files', 'impact_candidates', 'verification_hints'],
+                relatedSkills: [
+                    'change-blast-radius-review',
+                    'completion-evidence-gate',
+                    'javascript-code-change',
+                    'public-json-contract-change',
+                    'typescript-code-change',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'change-impact-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/code-change-impact.js')).runCodeChangeImpactScript,
+            },
             {
                 packId: 'code',
                 id: 'symbol-read',
                 ref: scriptRef('code', 'symbol-read'),
-                usage: 'mf script-pack run code/symbol-read read <path> --start-line <line> [options]',
+                usage: 'mf script-pack run code/symbol-read read (<path> --start-line <line> | --anchor <id>) [options]',
                 summaryKey: 'scriptPack.script.codeSymbolRead.summary',
                 actions: ['read'],
                 useWhen: [
-                    'Read only the resolved symbol range or an explicit bounded line range after a code outline identifies the relevant line.',
-                    'Fetch a focused source snippet with path, line, symbol, and content-hash metadata instead of repeatedly paging through a whole file.',
+                    'Read only the resolved symbol range, source-anchor target, or explicit bounded line range after a code outline identifies the relevant location.',
+                    'Fetch a focused source snippet with path, anchor, line, symbol, and content-hash metadata instead of repeatedly paging through a whole file.',
                 ],
                 phases: ['before_change', 'during_change', 'review'],
                 readOnly: true,
                 mutates: false,
                 network: false,
-                inputs: ['path', 'start_line', 'end_line', 'context_lines', 'max_file_bytes', 'max_snippet_lines'],
+                inputs: ['path', 'anchor_id', 'start_line', 'end_line', 'context_lines', 'max_file_bytes', 'max_snippet_lines'],
                 outputs: ['human_summary', 'json_report', 'source_snippet'],
                 relatedSkills: [
                     'codebase-orientation',
@@ -64,6 +123,66 @@ export const SCRIPT_PACKS = [
                 reportSchemaFile: 'code-symbol-read-report.schema.json',
                 loadRunner: async () => (await import('../script-packs/code-outline.js')).runCodeSymbolReadScript,
             },
+            {
+                packId: 'code',
+                id: 'route-outline',
+                ref: scriptRef('code', 'route-outline'),
+                usage: 'mf script-pack run code/route-outline scan <path...> [options]',
+                summaryKey: 'scriptPack.script.codeRouteOutline.summary',
+                actions: ['scan'],
+                useWhen: [
+                    'Scan Hono, Elysia, Axum, and NestJS route source files for method, path, framework, lifecycle, handler, and line metadata before reading whole modules.',
+                    'Build a bounded first-pass route outline with paths, line ranges, lifecycle calls, and content hashes for HTTP route orientation.',
+                ],
+                phases: ['before_change', 'during_change', 'after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['path', 'max_files', 'max_file_bytes'],
+                outputs: ['human_summary', 'json_report', 'route_outline', 'route_lifecycle'],
+                relatedSkills: [
+                    'api-contract-change',
+                    'backend-reliability-change',
+                    'axum-code-change',
+                    'elysia-code-change',
+                    'hono-code-change',
+                    'nestjs-code-change',
+                    'http-delivery-streaming',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'route-outline-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/code-route-outline.js')).runCodeRouteOutlineScript,
+            },
+            {
+                packId: 'code',
+                id: 'export-diff',
+                ref: scriptRef('code', 'export-diff'),
+                usage: 'mf script-pack run code/export-diff compare [path...] [options]',
+                summaryKey: 'scriptPack.script.codeExportDiff.summary',
+                actions: ['compare'],
+                useWhen: [
+                    'Compare exported TypeScript and JavaScript declaration signatures, return metadata, and package surface hints across a git base and head.',
+                    'Review public-ish API changes after source edits without reading every changed file from top to bottom.',
+                ],
+                phases: ['after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['base_ref', 'head_ref', 'path', 'max_files', 'max_file_bytes'],
+                outputs: ['human_summary', 'json_report', 'export_diff', 'return_type_changes', 'package_surface'],
+                relatedSkills: [
+                    'api-contract-change',
+                    'dependency-upgrade-review',
+                    'javascript-code-change',
+                    'public-json-contract-change',
+                    'typescript-code-change',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'export-diff-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/code-export-diff.js')).runCodeExportDiffScript,
+            },
         ],
     },
     {
@@ -100,10 +219,130 @@ export const SCRIPT_PACKS = [
             },
         ],
     },
+    {
+        id: 'docs',
+        summaryKey: 'scriptPack.pack.docs.summary',
+        scripts: [
+            {
+                packId: 'docs',
+                id: 'reference-drift',
+                ref: scriptRef('docs', 'reference-drift'),
+                usage: 'mf script-pack run docs/reference-drift check [path...] [options]',
+                summaryKey: 'scriptPack.script.referenceDrift.summary',
+                actions: ['check'],
+                useWhen: [
+                    'Check documentation references to mf commands, script-pack refs, schema files, and repository paths against current local surfaces.',
+                    'Review docs after CLI, schema, script-pack, or repository structure changes before claiming references are synchronized.',
+                ],
+                phases: ['after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['path', 'max_files', 'max_file_bytes'],
+                outputs: ['human_summary', 'json_report', 'reference_drift', 'stale_reference_findings'],
+                relatedSkills: [
+                    'cli-output-contract-review',
+                    'docs-prose-review',
+                    'public-json-contract-change',
+                    'readme-authoring',
+                    'release-notes-authoring',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'reference-drift-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/docs-reference-drift.js')).runDocsReferenceDriftScript,
+            },
+        ],
+    },
     {
         id: 'repo',
         summaryKey: 'scriptPack.pack.repo.summary',
         scripts: [
+            {
+                packId: 'repo',
+                id: 'config-chain',
+                ref: scriptRef('repo', 'config-chain'),
+                usage: 'mf script-pack run repo/config-chain inspect <path...> [options]',
+                summaryKey: 'scriptPack.script.configChain.summary',
+                actions: ['inspect'],
+                useWhen: [
+                    'Inspect nearby tsconfig, package, ESLint, Prettier, Vite, Vitest, Tailwind, Jest, and Playwright config files before assuming effective rules.',
+                    'Build a read-only config chain with extends, references, workspaces, dynamic-config findings, and source path context.',
+                ],
+                phases: ['before_change', 'during_change', 'after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['path', 'max_configs', 'max_file_bytes'],
+                outputs: ['human_summary', 'json_report', 'config_chain', 'config_edges'],
+                relatedSkills: [
+                    'bun-code-change',
+                    'config-env-change',
+                    'dependency-reality-check',
+                    'tailwind-code-change',
+                    'typescript-code-change',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'config-chain-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/repo-config-chain.js')).runRepoConfigChainScript,
+            },
+            {
+                packId: 'repo',
+                id: 'env-contract',
+                ref: scriptRef('repo', 'env-contract'),
+                usage: 'mf script-pack run repo/env-contract scan [path...] [options]',
+                summaryKey: 'scriptPack.script.envContract.summary',
+                actions: ['scan'],
+                useWhen: [
+                    'Scan code, CI, docs, and env example files for environment variable contract drift without reading real secret env files.',
+                    'Review env keys that are used in code, declared in examples, referenced in CI, documented, missing from examples, or public-prefix secret-like names.',
+                ],
+                phases: ['before_change', 'during_change', 'after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['path', 'max_files', 'max_file_bytes', 'max_keys'],
+                outputs: ['human_summary', 'json_report', 'env_keys', 'env_contract_findings'],
+                relatedSkills: [
+                    'config-env-change',
+                    'public-json-contract-change',
+                    'security-privacy-review',
+                    'typescript-code-change',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'env-contract-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/repo-env-contract.js')).runRepoEnvContractScript,
+            },
+            {
+                packId: 'repo',
+                id: 'secret-risk-scan',
+                ref: scriptRef('repo', 'secret-risk-scan'),
+                usage: 'mf script-pack run repo/secret-risk-scan scan [path...] [options]',
+                summaryKey: 'scriptPack.script.secretRiskScan.summary',
+                actions: ['scan'],
+                useWhen: [
+                    'Scan code, docs, config, CI, and examples for plausible hardcoded secrets without printing secret values.',
+                    'Review provider token prefixes, Bearer tokens, private key markers, secret-like assignments, and realistic env-example values.',
+                ],
+                phases: ['before_change', 'during_change', 'after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['path', 'max_files', 'max_file_bytes', 'max_findings'],
+                outputs: ['human_summary', 'json_report', 'secret_risk_findings', 'redacted_fingerprints'],
+                relatedSkills: [
+                    'config-env-change',
+                    'public-json-contract-change',
+                    'security-privacy-review',
+                    'typescript-code-change',
+                ],
+                riskLevel: 'medium',
+                cost: 'low',
+                reportSchemaFile: 'secret-risk-scan-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/repo-secret-risk-scan.js')).runRepoSecretRiskScanScript,
+            },
             {
                 packId: 'repo',
                 id: 'generated-boundary',
@@ -133,6 +372,36 @@ export const SCRIPT_PACKS = [
                 reportSchemaFile: 'generated-boundary-report.schema.json',
                 loadRunner: async () => (await import('../script-packs/repo-generated-boundary.js')).runRepoGeneratedBoundaryScript,
             },
+            {
+                packId: 'repo',
+                id: 'related-files',
+                ref: scriptRef('repo', 'related-files'),
+                usage: 'mf script-pack run repo/related-files map <path...> [options]',
+                summaryKey: 'scriptPack.script.relatedFiles.summary',
+                actions: ['map'],
+                useWhen: [
+                    'Map direct imports, importers, sibling tests, sibling docs, sibling styles, type siblings, ' +
+                        'and nearby config files for a source path before widening context reads.',
+                    'Review likely adjacent files after a partial implementation without treating the result as verification scope or completeness proof.',
+                ],
+                phases: ['before_change', 'during_change', 'after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['path', 'max_files', 'max_file_bytes', 'max_candidates'],
+                outputs: ['human_summary', 'json_report', 'related_file_candidates'],
+                relatedSkills: [
+                    'codebase-orientation',
+                    'heuristic-candidate-selection',
+                    'module-boundary-review',
+                    'typescript-code-change',
+                    'javascript-code-change',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'related-files-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/repo-related-files.js')).runRepoRelatedFilesScript,
+            },
         ],
     },
 ];

package/dist/cli/lib/validation/index.js

@@ -11,7 +11,7 @@ import { validateSourceAnchorsInProject } from '../../../core/source-anchor-vali
 import { listFilesRecursive, toPosixPath } from '../filesystem.js';
 import { readGitChangedFiles } from '../git-changes.js';
 import { inspectManifestLock } from '../manifest-lock.js';
-import { generateRepoMap } from '../repo-map.js';
+import { getExpectedRepoMapSourceFingerprint } from '../repo-map.js';
 import { parseTomlText, readMustflowTomlFile } from '../toml.js';
 import { MUSTFLOW_JSON_MAX_BYTES } from '../mustflow-read.js';
 import { getContractModelDefinitions, validateCandidateContractModelConfig, } from '../../../core/contract-models.js';
@@ -1464,7 +1464,7 @@ function validateStrictRepoMap(projectRoot, issues) {
     }
     else {
         const currentSourceFingerprint = frontmatter.source_fingerprint;
-        const expectedSourceFingerprint = parseSimpleFrontmatter(generateRepoMap(projectRoot)).source_fingerprint;
+        const expectedSourceFingerprint = getExpectedRepoMapSourceFingerprint(projectRoot);
         if (expectedSourceFingerprint && currentSourceFingerprint !== expectedSourceFingerprint) {
             pushStrictIssue(issues, 'REPO_MAP.md source_fingerprint is stale; regenerate with mf map --write');
         }

package/dist/cli/lib/validation/primitives.js

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { isRecord } from '../command-contract.js';
 import { readMustflowTomlFile } from '../toml.js';
+import { COMMANDS_CONFIG_RELATIVE_PATH, readResolvedCommandContractToml, } from '../../../core/config-loading.js';
 import { REQUIRED_FILES, } from './constants.js';
 import { TECHNOLOGY_CONFIG_RELATIVE_PATH } from '../../../core/technology-preferences.js';
 import { VERSIONING_CONFIG_PATH } from '../../../core/version-sources.js';
@@ -43,7 +44,9 @@ export function validateToml(projectRoot, issues) {
             continue;
         }
         try {
-            const parsed = readMustflowTomlFile(projectRoot, relativePath);
+            const parsed = relativePath === COMMANDS_CONFIG_RELATIVE_PATH
+                ? readResolvedCommandContractToml(projectRoot)
+                : readMustflowTomlFile(projectRoot, relativePath);
             if (!isRecord(parsed)) {
                 issues.push({ message: `${relativePath} must contain a TOML table` });
                 continue;

package/dist/cli/script-packs/code-change-impact.js

@@ -0,0 +1,172 @@
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { t } from '../lib/i18n.js';
+import { formatCliOptionParseError, getParsedCliStringOption, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { CHANGE_IMPACT_SCRIPT_REF, inspectChangeImpact } from '../../core/change-impact.js';
+const CHANGE_IMPACT_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--base', kind: 'string' },
+    { name: '--head', kind: 'string' },
+    { name: '--max-files', kind: 'string' },
+    { name: '--max-impacts', kind: 'string' },
+    { name: '--max-file-bytes', kind: 'string' },
+];
+function parsePositiveInteger(value, option, lang) {
+    if (value === null) {
+        return { value: null };
+    }
+    if (!/^[1-9]\d*$/u.test(value)) {
+        return { value: null, error: t(lang, 'changeImpact.error.invalidPositiveInteger', { option, value }) };
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        return { value: null, error: t(lang, 'changeImpact.error.invalidPositiveInteger', { option, value }) };
+    }
+    return { value: parsed };
+}
+export function getCodeChangeImpactHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf script-pack run code/change-impact analyze [path...] [options]',
+        summary: t(lang, 'changeImpact.help.summary'),
+        options: [
+            { label: '--base <ref>', description: t(lang, 'changeImpact.help.option.base') },
+            { label: '--head <ref>', description: t(lang, 'changeImpact.help.option.head') },
+            { label: '--max-files <count>', description: t(lang, 'changeImpact.help.option.maxFiles') },
+            { label: '--max-impacts <count>', description: t(lang, 'changeImpact.help.option.maxImpacts') },
+            { label: '--max-file-bytes <bytes>', description: t(lang, 'changeImpact.help.option.maxFileBytes') },
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: [
+            'mf script-pack run code/change-impact analyze --base HEAD --json',
+            'mf script-pack run code/change-impact analyze src --base main --head HEAD --json',
+            'mf script-pack run code/change-impact analyze src/core --max-impacts 80 --json',
+        ],
+        exitCodes: [
+            { label: '0', description: t(lang, 'changeImpact.help.exit.ok') },
+            { label: '1', description: t(lang, 'changeImpact.help.exit.fail') },
+        ],
+    }, lang);
+}
+function parseChangeImpactOptions(args, lang) {
+    const [action, ...rest] = args;
+    const parsed = parseCliOptions(rest, CHANGE_IMPACT_OPTIONS, { allowPositionals: true });
+    const json = hasParsedCliOption(parsed, '--json');
+    const baseRef = getParsedCliStringOption(parsed, '--base');
+    const headRef = getParsedCliStringOption(parsed, '--head');
+    const maxFiles = parsePositiveInteger(getParsedCliStringOption(parsed, '--max-files'), '--max-files', lang);
+    const maxImpacts = parsePositiveInteger(getParsedCliStringOption(parsed, '--max-impacts'), '--max-impacts', lang);
+    const maxFileBytes = parsePositiveInteger(getParsedCliStringOption(parsed, '--max-file-bytes'), '--max-file-bytes', lang);
+    const positiveOptions = [maxFiles, maxImpacts, maxFileBytes];
+    if (action !== 'analyze') {
+        return {
+            action: 'analyze',
+            json,
+            baseRef,
+            headRef,
+            paths: parsed.positionals,
+            maxFiles: maxFiles.value,
+            maxImpacts: maxImpacts.value,
+            maxFileBytes: maxFileBytes.value,
+            error: action ? t(lang, 'changeImpact.error.unknownAction', { action }) : t(lang, 'changeImpact.error.missingAction'),
+        };
+    }
+    if (parsed.error) {
+        return {
+            action,
+            json,
+            baseRef,
+            headRef,
+            paths: parsed.positionals,
+            maxFiles: maxFiles.value,
+            maxImpacts: maxImpacts.value,
+            maxFileBytes: maxFileBytes.value,
+            error: formatCliOptionParseError(parsed.error, lang),
+        };
+    }
+    for (const candidate of positiveOptions) {
+        if (candidate.error) {
+            return {
+                action,
+                json,
+                baseRef,
+                headRef,
+                paths: parsed.positionals,
+                maxFiles: maxFiles.value,
+                maxImpacts: maxImpacts.value,
+                maxFileBytes: maxFileBytes.value,
+                error: candidate.error,
+            };
+        }
+    }
+    return {
+        action,
+        json,
+        baseRef,
+        headRef,
+        paths: parsed.positionals,
+        maxFiles: maxFiles.value,
+        maxImpacts: maxImpacts.value,
+        maxFileBytes: maxFileBytes.value,
+    };
+}
+function renderChangeImpactSummary(report, lang) {
+    const lines = [
+        t(lang, 'changeImpact.title'),
+        `${t(lang, 'scriptPack.label.script')}: ${CHANGE_IMPACT_SCRIPT_REF}`,
+        `${t(lang, 'label.status')}: ${report.status}`,
+        `${t(lang, 'changeImpact.label.changedFiles')}: ${report.changed_files.length}`,
+        `${t(lang, 'changeImpact.label.impacts')}: ${report.impacts.length}`,
+        `${t(lang, 'changeImpact.label.truncated')}: ${report.truncated ? t(lang, 'value.yes') : t(lang, 'value.no')}`,
+    ];
+    for (const impact of report.impacts.slice(0, 40)) {
+        lines.push(`- ${impact.path}: ${impact.relationship} (${impact.reason})`);
+    }
+    if (report.script_hints.length > 0) {
+        lines.push(t(lang, 'changeImpact.label.scriptHints'));
+        for (const hint of report.script_hints) {
+            lines.push(`- ${hint.script_ref}: ${hint.command}`);
+        }
+    }
+    if (report.verification_hints.length > 0) {
+        lines.push(t(lang, 'changeImpact.label.verificationHints'));
+        for (const hint of report.verification_hints) {
+            lines.push(`- ${hint.intent}: ${hint.reason}`);
+        }
+    }
+    if (report.findings.length > 0) {
+        lines.push(t(lang, 'changeImpact.label.findings'), ...report.findings.map((finding) => `- ${finding.path}: ${finding.code} (${finding.message})`));
+    }
+    if (report.issues.length > 0) {
+        lines.push(t(lang, 'changeImpact.label.issues'), ...report.issues.map((issue) => `- ${issue}`));
+    }
+    if (report.changed_files.length === 0 && report.findings.length === 0 && report.issues.length === 0) {
+        lines.push(t(lang, 'changeImpact.clean'));
+    }
+    return lines.join('\n');
+}
+export function runCodeChangeImpactScript(args, reporter, lang = 'en') {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getCodeChangeImpactHelp(lang));
+        return 0;
+    }
+    const options = parseChangeImpactOptions(args, lang);
+    if (options.error) {
+        printUsageError(reporter, options.error, 'mf script-pack run code/change-impact --help', getCodeChangeImpactHelp(lang), lang);
+        return 1;
+    }
+    const report = inspectChangeImpact(resolveMustflowRoot(), {
+        baseRef: options.baseRef ?? undefined,
+        headRef: options.headRef,
+        paths: options.paths,
+        maxFiles: options.maxFiles ?? undefined,
+        maxImpacts: options.maxImpacts ?? undefined,
+        maxFileBytes: options.maxFileBytes ?? undefined,
+    });
+    if (options.json) {
+        reporter.stdout(JSON.stringify(report, null, 2));
+        return report.ok ? 0 : 1;
+    }
+    reporter.stdout(renderChangeImpactSummary(report, lang));
+    return report.ok ? 0 : 1;
+}