mustflow 2.75.2 → 2.85.4

package/dist/cli/script-packs/code-dependency-graph.js

@@ -0,0 +1,181 @@
+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 { DEPENDENCY_GRAPH_SCRIPT_REF, inspectDependencyGraph, } from '../../core/dependency-graph.js';
+const DEPENDENCY_GRAPH_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--max-files', kind: 'string' },
+    { name: '--max-file-bytes', kind: 'string' },
+    { name: '--max-depth', kind: 'string' },
+    { name: '--max-nodes', kind: 'string' },
+    { name: '--max-edges', 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, 'dependencyGraph.error.invalidPositiveInteger', { option, value }) };
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        return { value: null, error: t(lang, 'dependencyGraph.error.invalidPositiveInteger', { option, value }) };
+    }
+    return { value: parsed };
+}
+export function getCodeDependencyGraphHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf script-pack run code/dependency-graph scan <path...> [options]',
+        summary: t(lang, 'dependencyGraph.help.summary'),
+        options: [
+            { label: '--max-depth <count>', description: t(lang, 'dependencyGraph.help.option.maxDepth') },
+            { label: '--max-files <count>', description: t(lang, 'dependencyGraph.help.option.maxFiles') },
+            { label: '--max-file-bytes <bytes>', description: t(lang, 'dependencyGraph.help.option.maxFileBytes') },
+            { label: '--max-nodes <count>', description: t(lang, 'dependencyGraph.help.option.maxNodes') },
+            { label: '--max-edges <count>', description: t(lang, 'dependencyGraph.help.option.maxEdges') },
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: [
+            'mf script-pack run code/dependency-graph scan src/cli/index.ts --json',
+            'mf script-pack run code/dependency-graph scan src/core --max-depth 3 --json',
+            'mf script-pack run code/dependency-graph scan src tests --max-nodes 120 --max-edges 300 --json',
+        ],
+        exitCodes: [
+            { label: '0', description: t(lang, 'dependencyGraph.help.exit.ok') },
+            { label: '1', description: t(lang, 'dependencyGraph.help.exit.fail') },
+        ],
+    }, lang);
+}
+function parseDependencyGraphOptions(args, lang) {
+    const [action, ...rest] = args;
+    const parsed = parseCliOptions(rest, DEPENDENCY_GRAPH_OPTIONS, { allowPositionals: true });
+    const json = hasParsedCliOption(parsed, '--json');
+    const maxFiles = parsePositiveInteger(getParsedCliStringOption(parsed, '--max-files'), '--max-files', lang);
+    const maxFileBytes = parsePositiveInteger(getParsedCliStringOption(parsed, '--max-file-bytes'), '--max-file-bytes', lang);
+    const maxDepth = parsePositiveInteger(getParsedCliStringOption(parsed, '--max-depth'), '--max-depth', lang);
+    const maxNodes = parsePositiveInteger(getParsedCliStringOption(parsed, '--max-nodes'), '--max-nodes', lang);
+    const maxEdges = parsePositiveInteger(getParsedCliStringOption(parsed, '--max-edges'), '--max-edges', lang);
+    const positiveOptions = [maxFiles, maxFileBytes, maxDepth, maxNodes, maxEdges];
+    if (action !== 'scan') {
+        return {
+            action: 'scan',
+            json,
+            paths: parsed.positionals,
+            maxFiles: maxFiles.value,
+            maxFileBytes: maxFileBytes.value,
+            maxDepth: maxDepth.value,
+            maxNodes: maxNodes.value,
+            maxEdges: maxEdges.value,
+            error: action ? t(lang, 'dependencyGraph.error.unknownAction', { action }) : t(lang, 'dependencyGraph.error.missingAction'),
+        };
+    }
+    if (parsed.error) {
+        return {
+            action,
+            json,
+            paths: parsed.positionals,
+            maxFiles: maxFiles.value,
+            maxFileBytes: maxFileBytes.value,
+            maxDepth: maxDepth.value,
+            maxNodes: maxNodes.value,
+            maxEdges: maxEdges.value,
+            error: formatCliOptionParseError(parsed.error, lang),
+        };
+    }
+    for (const candidate of positiveOptions) {
+        if (candidate.error) {
+            return {
+                action,
+                json,
+                paths: parsed.positionals,
+                maxFiles: maxFiles.value,
+                maxFileBytes: maxFileBytes.value,
+                maxDepth: maxDepth.value,
+                maxNodes: maxNodes.value,
+                maxEdges: maxEdges.value,
+                error: candidate.error,
+            };
+        }
+    }
+    if (parsed.positionals.length === 0) {
+        return {
+            action,
+            json,
+            paths: parsed.positionals,
+            maxFiles: maxFiles.value,
+            maxFileBytes: maxFileBytes.value,
+            maxDepth: maxDepth.value,
+            maxNodes: maxNodes.value,
+            maxEdges: maxEdges.value,
+            error: t(lang, 'dependencyGraph.error.missingPath'),
+        };
+    }
+    return {
+        action,
+        json,
+        paths: parsed.positionals,
+        maxFiles: maxFiles.value,
+        maxFileBytes: maxFileBytes.value,
+        maxDepth: maxDepth.value,
+        maxNodes: maxNodes.value,
+        maxEdges: maxEdges.value,
+    };
+}
+function renderDependencyGraphSummary(report, lang) {
+    const lines = [
+        t(lang, 'dependencyGraph.title'),
+        `${t(lang, 'scriptPack.label.script')}: ${DEPENDENCY_GRAPH_SCRIPT_REF}`,
+        `${t(lang, 'label.status')}: ${report.status}`,
+        `${t(lang, 'dependencyGraph.label.targets')}: ${report.targets.length}`,
+        `${t(lang, 'dependencyGraph.label.nodes')}: ${report.nodes.length}`,
+        `${t(lang, 'dependencyGraph.label.edges')}: ${report.edges.length}`,
+        `${t(lang, 'dependencyGraph.label.cycles')}: ${report.cycles.length}`,
+        `${t(lang, 'dependencyGraph.label.truncated')}: ${report.truncated ? t(lang, 'value.yes') : t(lang, 'value.no')}`,
+    ];
+    for (const edge of report.edges.slice(0, 40)) {
+        lines.push(`- ${edge.source_path}:${edge.line} -> ${edge.target_path} (${edge.kind}, ${edge.specifier})`);
+    }
+    if (report.cycles.length > 0) {
+        lines.push(t(lang, 'dependencyGraph.label.cycleList'));
+        for (const cycle of report.cycles) {
+            lines.push(`- ${cycle.join(' -> ')}`);
+        }
+    }
+    if (report.findings.length > 0) {
+        lines.push(t(lang, 'dependencyGraph.label.findings'), ...report.findings.map((finding) => `- ${finding.path}: ${finding.code} (${finding.message})`));
+    }
+    if (report.issues.length > 0) {
+        lines.push(t(lang, 'dependencyGraph.label.issues'), ...report.issues.map((issue) => `- ${issue}`));
+    }
+    if (report.edges.length === 0 && report.findings.length === 0 && report.issues.length === 0) {
+        lines.push(t(lang, 'dependencyGraph.clean'));
+    }
+    return lines.join('\n');
+}
+export function runCodeDependencyGraphScript(args, reporter, lang = 'en') {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getCodeDependencyGraphHelp(lang));
+        return 0;
+    }
+    const options = parseDependencyGraphOptions(args, lang);
+    if (options.error) {
+        printUsageError(reporter, options.error, 'mf script-pack run code/dependency-graph --help', getCodeDependencyGraphHelp(lang), lang);
+        return 1;
+    }
+    const report = inspectDependencyGraph(resolveMustflowRoot(), {
+        paths: options.paths,
+        maxFiles: options.maxFiles ?? undefined,
+        maxFileBytes: options.maxFileBytes ?? undefined,
+        maxDepth: options.maxDepth ?? undefined,
+        maxNodes: options.maxNodes ?? undefined,
+        maxEdges: options.maxEdges ?? undefined,
+    });
+    if (options.json) {
+        reporter.stdout(JSON.stringify(report, null, 2));
+        return report.ok ? 0 : 1;
+    }
+    reporter.stdout(renderDependencyGraphSummary(report, lang));
+    return report.ok ? 0 : 1;
+}

package/dist/cli/script-packs/code-export-diff.js

@@ -0,0 +1,160 @@
+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 { CODE_EXPORT_DIFF_SCRIPT_REF, inspectExportDiff, } from '../../core/export-diff.js';
+const EXPORT_DIFF_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--base', kind: 'string' },
+    { name: '--head', kind: 'string' },
+    { name: '--max-files', 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, 'exportDiff.error.invalidPositiveInteger', { option, value }) };
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        return { value: null, error: t(lang, 'exportDiff.error.invalidPositiveInteger', { option, value }) };
+    }
+    return { value: parsed };
+}
+export function getCodeExportDiffHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf script-pack run code/export-diff compare [path...] [options]',
+        summary: t(lang, 'exportDiff.help.summary'),
+        options: [
+            { label: '--base <ref>', description: t(lang, 'exportDiff.help.option.base') },
+            { label: '--head <ref>', description: t(lang, 'exportDiff.help.option.head') },
+            { label: '--max-files <count>', description: t(lang, 'exportDiff.help.option.maxFiles') },
+            { label: '--max-file-bytes <bytes>', description: t(lang, 'exportDiff.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/export-diff compare --base HEAD --json',
+            'mf script-pack run code/export-diff compare src --base HEAD~1 --head HEAD --json',
+            'mf script-pack run code/export-diff compare src/index.ts --max-files 20 --json',
+        ],
+        exitCodes: [
+            { label: '0', description: t(lang, 'exportDiff.help.exit.ok') },
+            { label: '1', description: t(lang, 'exportDiff.help.exit.fail') },
+        ],
+    }, lang);
+}
+function parseExportDiffOptions(args, lang) {
+    const [action, ...rest] = args;
+    const parsed = parseCliOptions(rest, EXPORT_DIFF_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 maxFileBytes = parsePositiveInteger(getParsedCliStringOption(parsed, '--max-file-bytes'), '--max-file-bytes', lang);
+    if (action !== 'compare') {
+        return {
+            action: 'compare',
+            json,
+            baseRef,
+            headRef,
+            paths: parsed.positionals,
+            maxFiles: maxFiles.value,
+            maxFileBytes: maxFileBytes.value,
+            error: action ? t(lang, 'exportDiff.error.unknownAction', { action }) : t(lang, 'exportDiff.error.missingAction'),
+        };
+    }
+    if (parsed.error) {
+        return {
+            action,
+            json,
+            baseRef,
+            headRef,
+            paths: parsed.positionals,
+            maxFiles: maxFiles.value,
+            maxFileBytes: maxFileBytes.value,
+            error: formatCliOptionParseError(parsed.error, lang),
+        };
+    }
+    for (const candidate of [maxFiles, maxFileBytes]) {
+        if (candidate.error) {
+            return {
+                action,
+                json,
+                baseRef,
+                headRef,
+                paths: parsed.positionals,
+                maxFiles: maxFiles.value,
+                maxFileBytes: maxFileBytes.value,
+                error: candidate.error,
+            };
+        }
+    }
+    return {
+        action,
+        json,
+        baseRef,
+        headRef,
+        paths: parsed.positionals,
+        maxFiles: maxFiles.value,
+        maxFileBytes: maxFileBytes.value,
+    };
+}
+function renderExportDiffSummary(report, lang) {
+    const lines = [
+        t(lang, 'exportDiff.title'),
+        `${t(lang, 'scriptPack.label.script')}: ${CODE_EXPORT_DIFF_SCRIPT_REF}`,
+        `${t(lang, 'label.status')}: ${report.status}`,
+        `${t(lang, 'exportDiff.label.files')}: ${report.summary.files_changed}`,
+        `${t(lang, 'exportDiff.label.added')}: ${report.summary.added}`,
+        `${t(lang, 'exportDiff.label.removed')}: ${report.summary.removed}`,
+        `${t(lang, 'exportDiff.label.changed')}: ${report.summary.changed}`,
+    ];
+    if (report.exports.length > 0) {
+        lines.push(t(lang, 'exportDiff.label.exports'));
+        for (const entry of report.exports.filter((candidate) => candidate.change !== 'unchanged')) {
+            const beforeReturn = entry.before?.return_type ?? t(lang, 'value.none');
+            const afterReturn = entry.after?.return_type ?? t(lang, 'value.none');
+            lines.push(`- ${entry.path}: ${entry.change} ${entry.kind} ${entry.name} (${entry.compatibility}, ${beforeReturn} -> ${afterReturn})`);
+        }
+    }
+    if (report.findings.length > 0) {
+        lines.push(t(lang, 'exportDiff.label.findings'));
+        for (const finding of report.findings) {
+            lines.push(`- ${finding.path}: ${finding.code} (${finding.message})`);
+        }
+    }
+    if (report.issues.length > 0) {
+        lines.push(t(lang, 'exportDiff.label.issues'), ...report.issues.map((issue) => `- ${issue}`));
+    }
+    if (report.exports.length === 0 && report.findings.length === 0 && report.issues.length === 0) {
+        lines.push(t(lang, 'exportDiff.clean'));
+    }
+    return lines.join('\n');
+}
+export function runCodeExportDiffScript(args, reporter, lang = 'en') {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getCodeExportDiffHelp(lang));
+        return 0;
+    }
+    const options = parseExportDiffOptions(args, lang);
+    if (options.error) {
+        printUsageError(reporter, options.error, 'mf script-pack run code/export-diff --help', getCodeExportDiffHelp(lang), lang);
+        return 1;
+    }
+    const report = inspectExportDiff(resolveMustflowRoot(), {
+        baseRef: options.baseRef ?? undefined,
+        headRef: options.headRef,
+        paths: options.paths,
+        maxFiles: options.maxFiles ?? undefined,
+        maxFileBytes: options.maxFileBytes ?? undefined,
+    });
+    if (options.json) {
+        reporter.stdout(JSON.stringify(report, null, 2));
+        return report.ok ? 0 : 1;
+    }
+    reporter.stdout(renderExportDiffSummary(report, lang));
+    return report.ok ? 0 : 1;
+}

package/dist/cli/script-packs/code-outline.js

@@ -10,6 +10,7 @@ const CODE_OUTLINE_OPTIONS = [
 ];
 const CODE_SYMBOL_READ_OPTIONS = [
     { name: '--json', kind: 'boolean' },
+    { name: '--anchor', kind: 'string' },
     { name: '--start-line', kind: 'string' },
     { name: '--end-line', kind: 'string' },
     { name: '--context-lines', kind: 'string' },
@@ -65,9 +66,10 @@ export function getCodeOutlineHelp(lang = 'en') {
 }
 export function getCodeSymbolReadHelp(lang = 'en') {
     return renderHelp({
-        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]',
         summary: t(lang, 'codeSymbolRead.help.summary'),
         options: [
+            { label: '--anchor <id>', description: t(lang, 'codeSymbolRead.help.option.anchor') },
             { label: '--start-line <line>', description: t(lang, 'codeSymbolRead.help.option.startLine') },
             { label: '--end-line <line>', description: t(lang, 'codeSymbolRead.help.option.endLine') },
             { label: '--context-lines <count>', description: t(lang, 'codeSymbolRead.help.option.contextLines') },
@@ -78,6 +80,7 @@ export function getCodeSymbolReadHelp(lang = 'en') {
         ],
         examples: [
             'mf script-pack run code/symbol-read read src/cli/commands/script-pack.ts --start-line 100',
+            'mf script-pack run code/symbol-read read --anchor auth.session.resolve --json',
             'mf script-pack run code/symbol-read read src/core/code-outline.ts --start-line 320 --context-lines 2 --json',
             'mf script-pack run code/symbol-read read src/core/code-outline.ts --start-line 1 --end-line 40 --json',
         ],
@@ -147,6 +150,7 @@ function parseCodeSymbolReadOptions(args, lang) {
     const [action, ...rest] = args;
     const parsed = parseCliOptions(rest, CODE_SYMBOL_READ_OPTIONS, { allowPositionals: true });
     const json = hasParsedCliOption(parsed, '--json');
+    const anchorId = getParsedCliStringOption(parsed, '--anchor');
     const startLine = parsePositiveInteger(getParsedCliStringOption(parsed, '--start-line'), '--start-line', lang);
     const endLine = parsePositiveInteger(getParsedCliStringOption(parsed, '--end-line'), '--end-line', lang);
     const contextLines = parseNonNegativeInteger(getParsedCliStringOption(parsed, '--context-lines'), '--context-lines', lang);
@@ -158,6 +162,7 @@ function parseCodeSymbolReadOptions(args, lang) {
             action: 'read',
             json,
             path: inputPath,
+            anchorId,
             startLine: startLine.value,
             endLine: endLine.value,
             contextLines: contextLines.value,
@@ -171,6 +176,7 @@ function parseCodeSymbolReadOptions(args, lang) {
             action,
             json,
             path: inputPath,
+            anchorId,
             startLine: startLine.value,
             endLine: endLine.value,
             contextLines: contextLines.value,
@@ -185,6 +191,7 @@ function parseCodeSymbolReadOptions(args, lang) {
                 action,
                 json,
                 path: inputPath,
+                anchorId,
                 startLine: startLine.value,
                 endLine: endLine.value,
                 contextLines: contextLines.value,
@@ -194,11 +201,28 @@ function parseCodeSymbolReadOptions(args, lang) {
             };
         }
     }
-    if (parsed.positionals.length === 0) {
+    const hasAnchor = anchorId !== null;
+    const hasLineSelection = startLine.value !== null || endLine.value !== null;
+    if (hasAnchor && (parsed.positionals.length > 0 || hasLineSelection)) {
+        return {
+            action,
+            json,
+            path: inputPath,
+            anchorId,
+            startLine: startLine.value,
+            endLine: endLine.value,
+            contextLines: contextLines.value,
+            maxFileBytes: maxFileBytes.value,
+            maxSnippetLines: maxSnippetLines.value,
+            error: t(lang, 'codeSymbolRead.error.anchorConflict'),
+        };
+    }
+    if (!hasAnchor && parsed.positionals.length === 0) {
         return {
             action,
             json,
             path: null,
+            anchorId,
             startLine: startLine.value,
             endLine: endLine.value,
             contextLines: contextLines.value,
@@ -207,11 +231,12 @@ function parseCodeSymbolReadOptions(args, lang) {
             error: t(lang, 'codeSymbolRead.error.missingPath'),
         };
     }
-    if (parsed.positionals.length > 1) {
+    if (!hasAnchor && parsed.positionals.length > 1) {
         return {
             action,
             json,
             path: inputPath,
+            anchorId,
             startLine: startLine.value,
             endLine: endLine.value,
             contextLines: contextLines.value,
@@ -220,11 +245,12 @@ function parseCodeSymbolReadOptions(args, lang) {
             error: t(lang, 'codeSymbolRead.error.tooManyPaths'),
         };
     }
-    if (startLine.value === null) {
+    if (!hasAnchor && startLine.value === null) {
         return {
             action,
             json,
             path: inputPath,
+            anchorId,
             startLine: null,
             endLine: endLine.value,
             contextLines: contextLines.value,
@@ -237,6 +263,7 @@ function parseCodeSymbolReadOptions(args, lang) {
         action,
         json,
         path: inputPath,
+        anchorId,
         startLine: startLine.value,
         endLine: endLine.value,
         contextLines: contextLines.value,
@@ -333,12 +360,13 @@ export function runCodeSymbolReadScript(args, reporter, lang = 'en') {
         return 0;
     }
     const options = parseCodeSymbolReadOptions(args, lang);
-    if (options.error || options.path === null || options.startLine === null) {
+    if (options.error || (options.anchorId === null && (options.path === null || options.startLine === null))) {
         printUsageError(reporter, options.error ?? t(lang, 'cli.common.invalidInput'), 'mf script-pack run code/symbol-read --help', getCodeSymbolReadHelp(lang), lang);
         return 1;
     }
     const report = readCodeSymbol(resolveMustflowRoot(), {
         path: options.path,
+        anchorId: options.anchorId,
         startLine: options.startLine,
         endLine: options.endLine,
         contextLines: options.contextLines ?? undefined,

package/dist/cli/script-packs/code-route-outline.js

@@ -0,0 +1,155 @@
+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 { CODE_ROUTE_OUTLINE_SCRIPT_REF, inspectRouteOutline, } from '../../core/route-outline.js';
+const CODE_ROUTE_OUTLINE_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--max-files', 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, 'codeRouteOutline.error.invalidPositiveInteger', { option, value }) };
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        return { value: null, error: t(lang, 'codeRouteOutline.error.invalidPositiveInteger', { option, value }) };
+    }
+    return { value: parsed };
+}
+export function getCodeRouteOutlineHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf script-pack run code/route-outline scan <path...> [options]',
+        summary: t(lang, 'codeRouteOutline.help.summary'),
+        options: [
+            { label: '--max-files <count>', description: t(lang, 'codeRouteOutline.help.option.maxFiles') },
+            { label: '--max-file-bytes <bytes>', description: t(lang, 'codeRouteOutline.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/route-outline scan src --json',
+            'mf script-pack run code/route-outline scan src/server.ts --max-files 20',
+            'mf script-pack run code/route-outline scan src apps/api --max-file-bytes 262144 --json',
+        ],
+        exitCodes: [
+            { label: '0', description: t(lang, 'codeRouteOutline.help.exit.ok') },
+            { label: '1', description: t(lang, 'codeRouteOutline.help.exit.fail') },
+        ],
+    }, lang);
+}
+function parseCodeRouteOutlineOptions(args, lang) {
+    const [action, ...rest] = args;
+    const parsed = parseCliOptions(rest, CODE_ROUTE_OUTLINE_OPTIONS, { allowPositionals: true });
+    const json = hasParsedCliOption(parsed, '--json');
+    const maxFiles = parsePositiveInteger(getParsedCliStringOption(parsed, '--max-files'), '--max-files', lang);
+    const maxFileBytes = parsePositiveInteger(getParsedCliStringOption(parsed, '--max-file-bytes'), '--max-file-bytes', lang);
+    if (action !== 'scan') {
+        return {
+            action: 'scan',
+            json,
+            paths: parsed.positionals,
+            maxFiles: maxFiles.value,
+            maxFileBytes: maxFileBytes.value,
+            error: action
+                ? t(lang, 'codeRouteOutline.error.unknownAction', { action })
+                : t(lang, 'codeRouteOutline.error.missingAction'),
+        };
+    }
+    if (parsed.error) {
+        return {
+            action,
+            json,
+            paths: parsed.positionals,
+            maxFiles: maxFiles.value,
+            maxFileBytes: maxFileBytes.value,
+            error: formatCliOptionParseError(parsed.error, lang),
+        };
+    }
+    for (const candidate of [maxFiles, maxFileBytes]) {
+        if (candidate.error) {
+            return {
+                action,
+                json,
+                paths: parsed.positionals,
+                maxFiles: maxFiles.value,
+                maxFileBytes: maxFileBytes.value,
+                error: candidate.error,
+            };
+        }
+    }
+    if (parsed.positionals.length === 0) {
+        return {
+            action,
+            json,
+            paths: parsed.positionals,
+            maxFiles: maxFiles.value,
+            maxFileBytes: maxFileBytes.value,
+            error: t(lang, 'codeRouteOutline.error.missingPath'),
+        };
+    }
+    return {
+        action,
+        json,
+        paths: parsed.positionals,
+        maxFiles: maxFiles.value,
+        maxFileBytes: maxFileBytes.value,
+    };
+}
+function renderCodeRouteOutlineSummary(report, lang) {
+    const lines = [
+        t(lang, 'codeRouteOutline.title'),
+        `${t(lang, 'scriptPack.label.script')}: ${CODE_ROUTE_OUTLINE_SCRIPT_REF}`,
+        `${t(lang, 'label.status')}: ${report.status}`,
+        `${t(lang, 'codeRouteOutline.label.files')}: ${report.files.length}`,
+        `${t(lang, 'codeRouteOutline.label.routes')}: ${report.routes.length}`,
+        `${t(lang, 'codeRouteOutline.label.findings')}: ${report.findings.length}`,
+    ];
+    if (report.routes.length > 0) {
+        lines.push(t(lang, 'codeRouteOutline.label.outline'));
+        for (const route of report.routes) {
+            const routePath = route.route_path ?? '<dynamic>';
+            const lifecycle = route.lifecycle.length > 0 ? ` [${route.lifecycle.join(' > ')}]` : '';
+            lines.push(`- ${route.path}:${route.line} ${route.framework} ${route.method.toUpperCase()} ${routePath}${lifecycle}: ${route.signature}`);
+        }
+    }
+    if (report.findings.length > 0) {
+        lines.push(t(lang, 'codeRouteOutline.label.findings'));
+        for (const finding of report.findings) {
+            lines.push(`- ${finding.path}: ${finding.code} (${finding.message})`);
+        }
+    }
+    if (report.issues.length > 0) {
+        lines.push(t(lang, 'codeRouteOutline.label.issues'), ...report.issues.map((issue) => `- ${issue}`));
+    }
+    if (report.routes.length === 0 && report.findings.length === 0 && report.issues.length === 0) {
+        lines.push(t(lang, 'codeRouteOutline.clean'));
+    }
+    return lines.join('\n');
+}
+export function runCodeRouteOutlineScript(args, reporter, lang = 'en') {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getCodeRouteOutlineHelp(lang));
+        return 0;
+    }
+    const options = parseCodeRouteOutlineOptions(args, lang);
+    if (options.error) {
+        printUsageError(reporter, options.error, 'mf script-pack run code/route-outline --help', getCodeRouteOutlineHelp(lang), lang);
+        return 1;
+    }
+    const report = inspectRouteOutline(resolveMustflowRoot(), {
+        paths: options.paths,
+        maxFiles: options.maxFiles ?? undefined,
+        maxFileBytes: options.maxFileBytes ?? undefined,
+    });
+    if (options.json) {
+        reporter.stdout(JSON.stringify(report, null, 2));
+        return report.ok ? 0 : 1;
+    }
+    reporter.stdout(renderCodeRouteOutlineSummary(report, lang));
+    return report.ok ? 0 : 1;
+}