mustflow 2.85.4 → 2.99.0

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

@@ -65,6 +65,35 @@ export const SCRIPT_PACKS = [
                 reportSchemaFile: 'dependency-graph-report.schema.json',
                 loadRunner: async () => (await import('../script-packs/code-dependency-graph.js')).runCodeDependencyGraphScript,
             },
+            {
+                packId: 'code',
+                id: 'import-cycle',
+                ref: scriptRef('code', 'import-cycle'),
+                usage: 'mf script-pack run code/import-cycle check <path...> [options]',
+                summaryKey: 'scriptPack.script.codeImportCycle.summary',
+                actions: ['check'],
+                useWhen: [
+                    'Detect bounded relative TypeScript and JavaScript import cycles before changing module boundaries.',
+                    'Review exact cycle paths and import line evidence after dependency graph orientation finds cycle hints.',
+                ],
+                phases: ['before_change', 'after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['path', 'max_files', 'max_file_bytes', 'max_depth', 'max_nodes', 'max_edges', 'max_cycles'],
+                outputs: ['human_summary', 'json_report', 'import_cycles', 'cycle_edge_evidence'],
+                relatedSkills: [
+                    'change-blast-radius-review',
+                    'codebase-orientation',
+                    'javascript-code-change',
+                    'module-boundary-review',
+                    'typescript-code-change',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'import-cycle-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/code-import-cycle.js')).runCodeImportCycleScript,
+            },
             {
                 packId: 'code',
                 id: 'change-impact',
@@ -81,7 +110,7 @@ export const SCRIPT_PACKS = [
                 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'],
+                outputs: ['human_summary', 'json_report', 'changed_files', 'impact_candidates', 'script_hints', 'verification_hints'],
                 relatedSkills: [
                     'change-blast-radius-review',
                     'completion-evidence-gate',
@@ -252,6 +281,87 @@ export const SCRIPT_PACKS = [
                 reportSchemaFile: 'reference-drift-report.schema.json',
                 loadRunner: async () => (await import('../script-packs/docs-reference-drift.js')).runDocsReferenceDriftScript,
             },
+            {
+                packId: 'docs',
+                id: 'link-integrity',
+                ref: scriptRef('docs', 'link-integrity'),
+                usage: 'mf script-pack run docs/link-integrity check [path...] [options]',
+                summaryKey: 'scriptPack.script.linkIntegrity.summary',
+                actions: ['check'],
+                useWhen: [
+                    'Check Markdown and MDX inline links for local file and anchor drift without fetching external URLs.',
+                    'Review docs after moving, renaming, or retitling documentation files before claiming navigation links still resolve.',
+                ],
+                phases: ['after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['path', 'max_files', 'max_file_bytes'],
+                outputs: ['human_summary', 'json_report', 'link_integrity', 'missing_link_findings'],
+                relatedSkills: [
+                    'cli-output-contract-review',
+                    'docs-prose-review',
+                    'docs-update',
+                    'public-json-contract-change',
+                    'readme-authoring',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'link-integrity-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/docs-link-integrity.js')).runDocsLinkIntegrityScript,
+            },
+        ],
+    },
+    {
+        id: 'test',
+        summaryKey: 'scriptPack.pack.test.summary',
+        scripts: [
+            {
+                packId: 'test',
+                id: 'performance-report',
+                ref: scriptRef('test', 'performance-report'),
+                usage: 'mf script-pack run test/performance-report summarize [options]',
+                summaryKey: 'scriptPack.script.testPerformanceReport.summary',
+                actions: ['summarize'],
+                useWhen: [
+                    'Summarize retained mf run performance evidence, selected-test fallbacks, slow intents, timeout pressure, and phase bottlenecks.',
+                    'Review local verification-loop performance before changing test scheduling, profiling, caching, or command-contract timeout policy.',
+                ],
+                phases: ['after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['max_samples', 'max_intents', 'max_test_files', 'max_findings', 'slow_ms', 'timeout_ratio', 'phase_ms'],
+                outputs: ['human_summary', 'json_report', 'performance_samples', 'intent_timings', 'phase_timings', 'test_file_timings'],
+                relatedSkills: ['test-suite-performance-review', 'test-maintenance', 'completion-evidence-gate'],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'test-performance-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/test-performance-report.js')).runTestPerformanceReportScript,
+            },
+            {
+                packId: 'test',
+                id: 'regression-selector',
+                ref: scriptRef('test', 'regression-selector'),
+                usage: 'mf script-pack run test/regression-selector select [path...] [options]',
+                summaryKey: 'scriptPack.script.testRegressionSelector.summary',
+                actions: ['select'],
+                useWhen: [
+                    'Select likely regression tests from changed files while reporting unsafe surfaces that require fallback verification.',
+                    'Review source, test, package, schema, workflow, and config changes before relying on a related-test shortcut.',
+                ],
+                phases: ['after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['path', 'base_ref', 'head_ref', 'max_files', 'max_tests'],
+                outputs: ['human_summary', 'json_report', 'changed_files', 'selected_tests', 'fallbacks'],
+                relatedSkills: ['test-suite-performance-review', 'test-maintenance', 'change-blast-radius-review'],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'test-regression-selector-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/test-regression-selector.js')).runTestRegressionSelectorScript,
+            },
         ],
     },
     {
@@ -372,6 +482,179 @@ export const SCRIPT_PACKS = [
                 reportSchemaFile: 'generated-boundary-report.schema.json',
                 loadRunner: async () => (await import('../script-packs/repo-generated-boundary.js')).runRepoGeneratedBoundaryScript,
             },
+            {
+                packId: 'repo',
+                id: 'merge-conflict-scan',
+                ref: scriptRef('repo', 'merge-conflict-scan'),
+                usage: 'mf script-pack run repo/merge-conflict-scan check [path...] [options]',
+                summaryKey: 'scriptPack.script.mergeConflictScan.summary',
+                actions: ['check'],
+                useWhen: [
+                    'Scan changed files or explicit paths for Git merge conflict markers without printing surrounding file content.',
+                    'Review dirty worktrees before final verification, packaging, commit preparation, or handoff to avoid shipping unresolved conflict markers.',
+                ],
+                phases: ['after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['path', 'max_files', 'max_file_bytes'],
+                outputs: ['human_summary', 'json_report', 'merge_conflict_markers', 'marker_findings'],
+                relatedSkills: [
+                    'cli-output-contract-review',
+                    'completion-evidence-gate',
+                    'public-json-contract-change',
+                    'test-maintenance',
+                    'typescript-code-change',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'repo-merge-conflict-scan-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/repo-merge-conflict-scan.js')).runRepoMergeConflictScanScript,
+            },
+            {
+                packId: 'repo',
+                id: 'git-ignore-audit',
+                ref: scriptRef('repo', 'git-ignore-audit'),
+                usage: 'mf script-pack run repo/git-ignore-audit audit [path...] [options]',
+                summaryKey: 'scriptPack.script.gitIgnoreAudit.summary',
+                actions: ['audit'],
+                useWhen: [
+                    'Inspect explicit paths or changed files against .gitignore, .git/info/exclude, core.excludesFile, and config visibility evidence.',
+                    'Review ignored, untracked, missing, and tracked-but-ignored paths before assuming Git visibility, package contents, or generated output coverage.',
+                ],
+                phases: ['before_change', 'after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['path', 'max_paths'],
+                outputs: ['human_summary', 'json_report', 'ignore_sources', 'ignored_path_evidence'],
+                relatedSkills: [
+                    'cli-output-contract-review',
+                    'completion-evidence-gate',
+                    'file-path-cross-platform-change',
+                    'public-json-contract-change',
+                    'test-maintenance',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'repo-git-ignore-audit-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/repo-git-ignore-audit.js')).runRepoGitIgnoreAuditScript,
+            },
+            {
+                packId: 'repo',
+                id: 'manifest-lock-drift',
+                ref: scriptRef('repo', 'manifest-lock-drift'),
+                usage: 'mf script-pack run repo/manifest-lock-drift check [path...] [options]',
+                summaryKey: 'scriptPack.script.manifestLockDrift.summary',
+                actions: ['check'],
+                useWhen: [
+                    'Compare .mustflow/config/manifest.lock.toml entries with the current repository files without rewriting the lock.',
+                    'Review missing, unsafe, unreadable, invalid-hash, and content-hash mismatch evidence before trusting template update or install state.',
+                ],
+                phases: ['before_change', 'after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['path', 'max_entries'],
+                outputs: ['human_summary', 'json_report', 'manifest_lock_entries', 'hash_mismatch_findings'],
+                relatedSkills: [
+                    'cli-output-contract-review',
+                    'completion-evidence-gate',
+                    'contract-sync-check',
+                    'file-path-cross-platform-change',
+                    'public-json-contract-change',
+                    'template-install-surface-sync',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'repo-manifest-lock-drift-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/repo-manifest-lock-drift.js')).runRepoManifestLockDriftScript,
+            },
+            {
+                packId: 'repo',
+                id: 'skill-route-audit',
+                ref: scriptRef('repo', 'skill-route-audit'),
+                usage: 'mf script-pack run repo/skill-route-audit audit [options]',
+                summaryKey: 'scriptPack.script.skillRouteAudit.summary',
+                actions: ['audit'],
+                useWhen: [
+                    'Audit source skill files, route metadata, skill index entries, default template skill copies, manifest profiles, and i18n metadata for drift.',
+                    'Review mustflow skill-route surfaces after adding, refreshing, or synchronizing skills before relying on installed template coverage.',
+                ],
+                phases: ['before_change', 'after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: [],
+                outputs: ['human_summary', 'json_report', 'skill_route_findings', 'template_drift', 'manifest_drift', 'i18n_drift'],
+                relatedSkills: [
+                    'contract-sync-check',
+                    'public-json-contract-change',
+                    'skill-authoring',
+                    'skill-refresh',
+                    'template-install-surface-sync',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'skill-route-audit-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/repo-skill-route-audit.js')).runRepoSkillRouteAuditScript,
+            },
+            {
+                packId: 'repo',
+                id: 'version-source',
+                ref: scriptRef('repo', 'version-source'),
+                usage: 'mf script-pack run repo/version-source inspect [options]',
+                summaryKey: 'scriptPack.script.versionSource.summary',
+                actions: ['inspect'],
+                useWhen: [
+                    'Inspect detected version source files before editing package, template, release, or versioning metadata.',
+                    'Review whether enabled release versioning preferences have at least one detected version source.',
+                ],
+                phases: ['before_change', 'after_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: [],
+                outputs: ['human_summary', 'json_report', 'version_sources', 'versioning_findings'],
+                relatedSkills: [
+                    'completion-evidence-gate',
+                    'public-json-contract-change',
+                    'release-publish-change',
+                    'version-freshness-check',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'repo-version-source-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/repo-version-source.js')).runRepoVersionSourceScript,
+            },
+            {
+                packId: 'repo',
+                id: 'approval-gate',
+                ref: scriptRef('repo', 'approval-gate'),
+                usage: 'mf script-pack run repo/approval-gate check --action <type> [options]',
+                summaryKey: 'scriptPack.script.approvalGate.summary',
+                actions: ['check'],
+                useWhen: [
+                    'Check planned action types against .mustflow/config/mustflow.toml [approval].required_for before proceeding.',
+                    'Review whether git, dependency, network, database, destructive, secret, release, or cross-repository actions require human approval.',
+                ],
+                phases: ['before_change', 'review'],
+                readOnly: true,
+                mutates: false,
+                network: false,
+                inputs: ['action_type'],
+                outputs: ['human_summary', 'json_report', 'approval_decisions', 'approval_findings'],
+                relatedSkills: [
+                    'command-contract-authoring',
+                    'completion-evidence-gate',
+                    'public-json-contract-change',
+                    'release-publish-change',
+                ],
+                riskLevel: 'low',
+                cost: 'low',
+                reportSchemaFile: 'repo-approval-gate-report.schema.json',
+                loadRunner: async () => (await import('../script-packs/repo-approval-gate.js')).runRepoApprovalGateScript,
+            },
             {
                 packId: 'repo',
                 id: 'related-files',

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

@@ -126,6 +126,12 @@ function renderChangeImpactSummary(report, lang) {
         lines.push(t(lang, 'changeImpact.label.scriptHints'));
         for (const hint of report.script_hints) {
             lines.push(`- ${hint.script_ref}: ${hint.command}`);
+            if (hint.related_intents && hint.related_intents.length > 0) {
+                lines.push(`  related intents: ${hint.related_intents.join(', ')}`);
+            }
+            if (hint.expected_fallback_reasons && hint.expected_fallback_reasons.length > 0) {
+                lines.push(`  expected fallback reasons: ${hint.expected_fallback_reasons.join(', ')}`);
+            }
         }
     }
     if (report.verification_hints.length > 0) {

package/dist/cli/script-packs/code-import-cycle.js

@@ -0,0 +1,193 @@
+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 { IMPORT_CYCLE_SCRIPT_REF, inspectImportCycles } from '../../core/import-cycle.js';
+const IMPORT_CYCLE_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' },
+    { name: '--max-cycles', 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, 'importCycle.error.invalidPositiveInteger', { option, value }) };
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        return { value: null, error: t(lang, 'importCycle.error.invalidPositiveInteger', { option, value }) };
+    }
+    return { value: parsed };
+}
+export function getCodeImportCycleHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf script-pack run code/import-cycle check <path...> [options]',
+        summary: t(lang, 'importCycle.help.summary'),
+        options: [
+            { label: '--max-depth <count>', description: t(lang, 'importCycle.help.option.maxDepth') },
+            { label: '--max-files <count>', description: t(lang, 'importCycle.help.option.maxFiles') },
+            { label: '--max-file-bytes <bytes>', description: t(lang, 'importCycle.help.option.maxFileBytes') },
+            { label: '--max-nodes <count>', description: t(lang, 'importCycle.help.option.maxNodes') },
+            { label: '--max-edges <count>', description: t(lang, 'importCycle.help.option.maxEdges') },
+            { label: '--max-cycles <count>', description: t(lang, 'importCycle.help.option.maxCycles') },
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: [
+            'mf script-pack run code/import-cycle check src --json',
+            'mf script-pack run code/import-cycle check src/core --max-depth 30 --json',
+            'mf script-pack run code/import-cycle check src tests --max-cycles 20 --json',
+        ],
+        exitCodes: [
+            { label: '0', description: t(lang, 'importCycle.help.exit.ok') },
+            { label: '1', description: t(lang, 'importCycle.help.exit.fail') },
+        ],
+    }, lang);
+}
+function parseImportCycleOptions(args, lang) {
+    const [action, ...rest] = args;
+    const parsed = parseCliOptions(rest, IMPORT_CYCLE_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 maxCycles = parsePositiveInteger(getParsedCliStringOption(parsed, '--max-cycles'), '--max-cycles', lang);
+    const positiveOptions = [maxFiles, maxFileBytes, maxDepth, maxNodes, maxEdges, maxCycles];
+    if (action !== 'check') {
+        return {
+            action: 'check',
+            json,
+            paths: parsed.positionals,
+            maxFiles: maxFiles.value,
+            maxFileBytes: maxFileBytes.value,
+            maxDepth: maxDepth.value,
+            maxNodes: maxNodes.value,
+            maxEdges: maxEdges.value,
+            maxCycles: maxCycles.value,
+            error: action ? t(lang, 'importCycle.error.unknownAction', { action }) : t(lang, 'importCycle.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,
+            maxCycles: maxCycles.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,
+                maxCycles: maxCycles.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,
+            maxCycles: maxCycles.value,
+            error: t(lang, 'importCycle.error.missingPath'),
+        };
+    }
+    return {
+        action,
+        json,
+        paths: parsed.positionals,
+        maxFiles: maxFiles.value,
+        maxFileBytes: maxFileBytes.value,
+        maxDepth: maxDepth.value,
+        maxNodes: maxNodes.value,
+        maxEdges: maxEdges.value,
+        maxCycles: maxCycles.value,
+    };
+}
+function renderImportCycleSummary(report, lang) {
+    const lines = [
+        t(lang, 'importCycle.title'),
+        `${t(lang, 'scriptPack.label.script')}: ${IMPORT_CYCLE_SCRIPT_REF}`,
+        `${t(lang, 'label.status')}: ${report.status}`,
+        `${t(lang, 'importCycle.label.targets')}: ${report.targets.length}`,
+        `${t(lang, 'importCycle.label.nodes')}: ${report.graph.node_count}`,
+        `${t(lang, 'importCycle.label.edges')}: ${report.graph.edge_count}`,
+        `${t(lang, 'importCycle.label.cycles')}: ${report.cycles.length}`,
+        `${t(lang, 'importCycle.label.truncated')}: ${report.truncated ? t(lang, 'value.yes') : t(lang, 'value.no')}`,
+    ];
+    if (report.cycles.length > 0) {
+        lines.push(t(lang, 'importCycle.label.cycleList'));
+        for (const cycle of report.cycles) {
+            lines.push(`- ${cycle.cycle_id}: ${cycle.paths.join(' -> ')}`);
+            for (const edge of cycle.edges) {
+                lines.push(`  - ${edge.source_path}:${edge.line} -> ${edge.target_path} (${edge.kind}, ${edge.specifier})`);
+            }
+        }
+    }
+    if (report.findings.length > 0) {
+        lines.push(t(lang, 'importCycle.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, 'importCycle.label.issues'), ...report.issues.map((issue) => `- ${issue}`));
+    }
+    if (report.cycles.length === 0 && report.findings.length === 0 && report.issues.length === 0) {
+        lines.push(t(lang, 'importCycle.clean'));
+    }
+    return lines.join('\n');
+}
+export function runCodeImportCycleScript(args, reporter, lang = 'en') {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getCodeImportCycleHelp(lang));
+        return 0;
+    }
+    const options = parseImportCycleOptions(args, lang);
+    if (options.error) {
+        printUsageError(reporter, options.error, 'mf script-pack run code/import-cycle --help', getCodeImportCycleHelp(lang), lang);
+        return 1;
+    }
+    const report = inspectImportCycles(resolveMustflowRoot(), {
+        paths: options.paths,
+        maxFiles: options.maxFiles ?? undefined,
+        maxFileBytes: options.maxFileBytes ?? undefined,
+        maxDepth: options.maxDepth ?? undefined,
+        maxNodes: options.maxNodes ?? undefined,
+        maxEdges: options.maxEdges ?? undefined,
+        maxCycles: options.maxCycles ?? undefined,
+    });
+    if (options.json) {
+        reporter.stdout(JSON.stringify(report, null, 2));
+        return report.ok ? 0 : 1;
+    }
+    reporter.stdout(renderImportCycleSummary(report, lang));
+    return report.ok ? 0 : 1;
+}

package/dist/cli/script-packs/docs-link-integrity.js

@@ -0,0 +1,145 @@
+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 { checkLinkIntegrity, LINK_INTEGRITY_SCRIPT_REF, } from '../../core/docs-link-integrity.js';
+const LINK_INTEGRITY_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, 'linkIntegrity.error.invalidPositiveInteger', { option, value }) };
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        return { value: null, error: t(lang, 'linkIntegrity.error.invalidPositiveInteger', { option, value }) };
+    }
+    return { value: parsed };
+}
+export function getDocsLinkIntegrityHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf script-pack run docs/link-integrity check [path...] [options]',
+        summary: t(lang, 'linkIntegrity.help.summary'),
+        options: [
+            { label: '--max-files <count>', description: t(lang, 'linkIntegrity.help.option.maxFiles') },
+            { label: '--max-file-bytes <bytes>', description: t(lang, 'linkIntegrity.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 docs/link-integrity check --json',
+            'mf script-pack run docs/link-integrity check README.md schemas/README.md --json',
+            'mf script-pack run docs/link-integrity check docs-site/src/content/docs --max-files 80 --json',
+        ],
+        exitCodes: [
+            { label: '0', description: t(lang, 'linkIntegrity.help.exit.ok') },
+            { label: '1', description: t(lang, 'linkIntegrity.help.exit.fail') },
+        ],
+    }, lang);
+}
+function parseLinkIntegrityOptions(args, lang) {
+    const [action, ...rest] = args;
+    const parsed = parseCliOptions(rest, LINK_INTEGRITY_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 !== 'check') {
+        return {
+            action: 'check',
+            json,
+            paths: parsed.positionals,
+            maxFiles: maxFiles.value,
+            maxFileBytes: maxFileBytes.value,
+            error: action
+                ? t(lang, 'linkIntegrity.error.unknownAction', { action })
+                : t(lang, 'linkIntegrity.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,
+            };
+        }
+    }
+    return {
+        action,
+        json,
+        paths: parsed.positionals,
+        maxFiles: maxFiles.value,
+        maxFileBytes: maxFileBytes.value,
+    };
+}
+function renderLinkIntegritySummary(report, lang) {
+    const lines = [
+        t(lang, 'linkIntegrity.title'),
+        `${t(lang, 'scriptPack.label.script')}: ${LINK_INTEGRITY_SCRIPT_REF}`,
+        `${t(lang, 'label.status')}: ${report.status}`,
+        `${t(lang, 'linkIntegrity.label.files')}: ${report.files.length}`,
+        `${t(lang, 'linkIntegrity.label.links')}: ${report.links.length}`,
+        `${t(lang, 'linkIntegrity.label.findings')}: ${report.findings.length}`,
+    ];
+    if (report.links.length > 0) {
+        lines.push(t(lang, 'linkIntegrity.label.links'));
+        for (const link of report.links.slice(0, 40)) {
+            const resolved = link.resolved_path === null ? link.target : link.resolved_path;
+            lines.push(`- ${link.path}:${link.line}: ${link.kind} ${resolved} (${link.status})`);
+        }
+    }
+    if (report.findings.length > 0) {
+        lines.push(t(lang, 'linkIntegrity.label.findings'));
+        for (const finding of report.findings) {
+            const line = finding.line === undefined ? '' : `:${finding.line}`;
+            lines.push(`- ${finding.path}${line}: ${finding.code} (${finding.message})`);
+        }
+    }
+    if (report.issues.length > 0) {
+        lines.push(t(lang, 'linkIntegrity.label.issues'), ...report.issues.map((issue) => `- ${issue}`));
+    }
+    if (report.links.length === 0 && report.findings.length === 0 && report.issues.length === 0) {
+        lines.push(t(lang, 'linkIntegrity.clean'));
+    }
+    return lines.join('\n');
+}
+export function runDocsLinkIntegrityScript(args, reporter, lang = 'en') {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getDocsLinkIntegrityHelp(lang));
+        return 0;
+    }
+    const options = parseLinkIntegrityOptions(args, lang);
+    if (options.error) {
+        printUsageError(reporter, options.error, 'mf script-pack run docs/link-integrity --help', getDocsLinkIntegrityHelp(lang), lang);
+        return 1;
+    }
+    const report = checkLinkIntegrity(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(renderLinkIntegritySummary(report, lang));
+    return report.ok ? 0 : 1;
+}