mustflow 1.15.97

package/dist/cli/commands/explain.js

@@ -0,0 +1,293 @@
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { t } from '../lib/i18n.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { explainAssetOptimization, explainCommandIntent } from '../../core/command-explanation.js';
+import { readCommandContract, readMustflowConfigIfExists } from '../../core/config-loading.js';
+import { explainManagedMarkdownAuthority, } from '../../core/authority-resolution.js';
+import { explainRetentionPolicy } from '../../core/retention-explanation.js';
+import { explainSkillRoute } from '../../core/skill-route-explanation.js';
+import { explainSkillRouteAlignment, } from '../../core/skill-route-alignment.js';
+import { explainPublicSurface } from '../../core/public-surface-explanation.js';
+import { explainSourceAnchor } from '../../core/source-anchor-explanation.js';
+import { checkMustflowProject } from '../lib/validation.js';
+const EXPLAIN_SCHEMA_VERSION = '1';
+export function getExplainHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf explain <topic> [target] [options]',
+        summary: t(lang, 'explain.help.summary'),
+        options: [
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: [
+            'mf explain authority',
+            'mf explain authority AGENTS.md',
+            'mf explain anchor auth.session.resolve',
+            'mf explain anchor auth.session.resolve --json',
+            'mf explain asset-optimization',
+            'mf explain asset-optimization --json',
+            'mf explain command test',
+            'mf explain command lint --json',
+            'mf explain retention',
+            'mf explain retention --json',
+            'mf explain skill code-review',
+            'mf explain skill mustflow.core.code-review --json',
+            'mf explain skills',
+            'mf explain skills --json',
+            'mf explain surface README.md',
+            'mf explain surface templates/default/manifest.toml --json',
+            'mf explain authority .mustflow/skills/INDEX.md --json',
+        ],
+        exitCodes: [
+            { label: '0', description: t(lang, 'explain.help.exit.ok') },
+            { label: '1', description: t(lang, 'cli.common.invalidInput') },
+        ],
+    }, lang);
+}
+function getAuthorityExplainOutput(projectRoot, pathArg) {
+    return {
+        schema_version: EXPLAIN_SCHEMA_VERSION,
+        command: 'explain',
+        topic: 'authority',
+        mustflow_root: projectRoot,
+        decision: explainManagedMarkdownAuthority(pathArg),
+    };
+}
+function getAssetOptimizationExplainOutput(projectRoot) {
+    return {
+        schema_version: EXPLAIN_SCHEMA_VERSION,
+        command: 'explain',
+        topic: 'asset-optimization',
+        mustflow_root: projectRoot,
+        decision: explainAssetOptimization(readCommandContract(projectRoot)),
+    };
+}
+function getAnchorExplainOutput(projectRoot, anchorId) {
+    return {
+        schema_version: EXPLAIN_SCHEMA_VERSION,
+        command: 'explain',
+        topic: 'anchor',
+        mustflow_root: projectRoot,
+        decision: explainSourceAnchor(projectRoot, anchorId),
+    };
+}
+function getCommandExplainOutput(projectRoot, commandName) {
+    return {
+        schema_version: EXPLAIN_SCHEMA_VERSION,
+        command: 'explain',
+        topic: 'command',
+        mustflow_root: projectRoot,
+        decision: explainCommandIntent(readCommandContract(projectRoot), commandName),
+    };
+}
+function getRetentionExplainOutput(projectRoot) {
+    return {
+        schema_version: EXPLAIN_SCHEMA_VERSION,
+        command: 'explain',
+        topic: 'retention',
+        mustflow_root: projectRoot,
+        decision: explainRetentionPolicy(readMustflowConfigIfExists(projectRoot)),
+    };
+}
+function getSkillsExplainOutput(projectRoot) {
+    return {
+        schema_version: EXPLAIN_SCHEMA_VERSION,
+        command: 'explain',
+        topic: 'skills',
+        mustflow_root: projectRoot,
+        decision: explainSkillRouteAlignment(checkMustflowProject(projectRoot, { strict: true })),
+    };
+}
+function getSkillExplainOutput(projectRoot, skillName) {
+    return {
+        schema_version: EXPLAIN_SCHEMA_VERSION,
+        command: 'explain',
+        topic: 'skill',
+        mustflow_root: projectRoot,
+        decision: explainSkillRoute(projectRoot, skillName),
+    };
+}
+function getSurfaceExplainOutput(projectRoot, pathArg) {
+    return {
+        schema_version: EXPLAIN_SCHEMA_VERSION,
+        command: 'explain',
+        topic: 'surface',
+        mustflow_root: projectRoot,
+        decision: explainPublicSurface(pathArg),
+    };
+}
+function formatNullable(value, lang) {
+    if (value === null) {
+        return t(lang, 'value.none');
+    }
+    if (typeof value === 'boolean') {
+        return value ? t(lang, 'value.yes') : t(lang, 'value.no');
+    }
+    return String(value);
+}
+function renderExplainDecision(output, lang) {
+    const lines = [
+        t(lang, 'explain.title'),
+        `${t(lang, 'label.mustflowRoot')}: ${output.mustflow_root}`,
+        `${t(lang, 'explain.label.topic')}: ${output.topic}`,
+        `${t(lang, 'explain.label.decision')}: ${output.decision.decision}`,
+        `${t(lang, 'explain.label.reason')}: ${output.decision.reason}`,
+        `${t(lang, 'explain.label.effectiveAction')}: ${output.decision.effectiveAction}`,
+        `${t(lang, 'explain.label.countsAsMustflowVerification')}: ${output.decision.countsAsMustflowVerification ? t(lang, 'value.yes') : t(lang, 'value.no')}`,
+        '',
+        t(lang, 'explain.label.sourceFiles'),
+        ...output.decision.sourceFiles.map((sourceFile) => `- ${sourceFile}`),
+    ];
+    if ('expectation' in output.decision && output.decision.expectation) {
+        lines.push('', t(lang, 'explain.label.expectedFrontmatter'), `- mustflow_doc: ${output.decision.expectation.docId}`, `- authority: ${output.decision.expectation.authority}`, `- lifecycle: ${output.decision.expectation.lifecycle}`);
+    }
+    if ('boundary' in output.decision) {
+        lines.push('', t(lang, 'explain.label.authorityBoundary'), `- role: ${output.decision.boundary.role}`);
+        if (output.decision.boundary.canDefine.length > 0) {
+            lines.push(`- ${t(lang, 'explain.label.canDefine')}:`);
+            for (const item of output.decision.boundary.canDefine) {
+                lines.push(`  - ${item}`);
+            }
+        }
+        if (output.decision.boundary.cannotDefine.length > 0) {
+            lines.push(`- ${t(lang, 'explain.label.cannotDefine')}:`);
+            for (const item of output.decision.boundary.cannotDefine) {
+                lines.push(`  - ${item}`);
+            }
+        }
+    }
+    if ('intent' in output.decision && output.decision.intent) {
+        const intent = output.decision.intent;
+        lines.push('', t(lang, 'explain.label.commandIntent'), `- ${t(lang, 'explain.label.commandName')}: ${intent.name}`, `- status: ${intent.status ?? t(lang, 'value.none')}`, `- lifecycle: ${intent.lifecycle ?? t(lang, 'value.none')}`, `- run_policy: ${intent.runPolicy ?? t(lang, 'value.none')}`, `- stdin: ${intent.stdin ?? t(lang, 'value.none')}`, `- timeout_seconds: ${intent.timeoutSeconds ?? t(lang, 'value.none')}`, `- mode: ${intent.mode}`, `- cwd: ${intent.cwd ?? t(lang, 'value.none')}`, `- writes: ${intent.writes.join(', ') || t(lang, 'value.none')}`, `- network: ${formatNullable(intent.network, lang)}`, `- destructive: ${formatNullable(intent.destructive, lang)}`, `- success_exit_codes: ${intent.successExitCodes.join(', ') || t(lang, 'value.none')}`, `- required_after: ${intent.requiredAfter.join(', ') || t(lang, 'value.none')}`);
+    }
+    if ('retention' in output.decision) {
+        const retention = output.decision.retention;
+        lines.push('', t(lang, 'explain.label.retentionPolicy'), `- enabled: ${formatNullable(retention.enabled, lang)}`, `- raw_events.store: ${formatNullable(retention.rawEvents.store, lang)}`, `- raw_events.on_limit: ${formatNullable(retention.rawEvents.onLimit, lang)}`, `- run_receipts.store: ${retention.runReceipts.store}`, `- run_receipts.max_file_kb: ${retention.runReceipts.maxFileKb}`, `- run_receipts.max_items: ${retention.runReceipts.maxItems}`, `- run_receipts.keep_stdout_tail_bytes: ${retention.runReceipts.stdoutTailBytes}`, `- run_receipts.keep_stderr_tail_bytes: ${retention.runReceipts.stderrTailBytes}`, `- knowledge.enabled: ${formatNullable(retention.knowledge.enabled, lang)}`, `- context.max_file_kb: ${retention.context.maxFileKb}`, `- repo_map.max_file_kb: ${retention.repoMap.maxFileKb}`, `- repo_map.fail_if_larger: ${formatNullable(retention.repoMap.failIfLarger, lang)}`);
+    }
+    if ('alignment' in output.decision) {
+        const alignment = output.decision.alignment;
+        lines.push('', t(lang, 'explain.label.skillRoutes'), `- status: ${alignment.status}`, `- issue_count: ${alignment.issueCount}`, `- summary: ${alignment.summary}`, `- action: ${alignment.action ?? t(lang, 'value.none')}`);
+        if (alignment.issues.length > 0) {
+            lines.push(`- ${t(lang, 'doctor.section.issueList')}`);
+            for (const issue of alignment.issues) {
+                lines.push(`  - ${issue}`);
+            }
+        }
+    }
+    if ('route' in output.decision) {
+        const route = output.decision.route;
+        lines.push('', t(lang, 'explain.label.skillRoute'));
+        if (!route) {
+            lines.push(`- ${t(lang, 'value.none')}`);
+        }
+        else {
+            lines.push(`- skill: ${route.skill}`, `- path: ${route.skillPath}`, `- trigger: ${route.trigger}`, `- required_input: ${route.requiredInput}`, `- edit_scope: ${route.editScope}`, `- risk: ${route.risk}`, `- verification_intents: ${route.verificationIntents.join(', ') || t(lang, 'value.none')}`, `- declared_command_intents: ${route.declaredCommandIntents.join(', ') || t(lang, 'value.none')}`, `- expected_output: ${route.expectedOutput}`);
+        }
+    }
+    if ('surface' in output.decision) {
+        const surface = output.decision.surface;
+        lines.push('', t(lang, 'explain.label.publicSurface'), `- kind: ${surface.kind}`, `- category: ${surface.category}`, `- is_public_surface: ${surface.isPublicSurface ? t(lang, 'value.yes') : t(lang, 'value.no')}`, `- ${t(lang, 'explain.label.validationReasons')}: ${surface.validationReasons.join(', ') || t(lang, 'value.none')}`, `- ${t(lang, 'explain.label.affectedContracts')}: ${surface.affectedContracts.join(', ') || t(lang, 'value.none')}`, `- ${t(lang, 'classify.label.updatePolicy')}: ${surface.updatePolicy}`, `- ${t(lang, 'classify.label.driftChecks')}: ${surface.driftChecks.join(', ') || t(lang, 'value.none')}`);
+    }
+    if ('anchor' in output.decision) {
+        const anchor = output.decision.anchor;
+        lines.push('', 'Source anchor');
+        if (!anchor) {
+            lines.push(`- ${t(lang, 'value.none')}`);
+        }
+        else {
+            lines.push(`- id: ${anchor.id}`, `- path: ${anchor.path}`, `- line_start: ${anchor.lineStart}`, `- purpose: ${anchor.purpose ?? t(lang, 'value.none')}`, `- search: ${anchor.search.join(', ') || t(lang, 'value.none')}`, `- invariant: ${anchor.invariant ?? t(lang, 'value.none')}`, `- risk: ${anchor.risk.join(', ') || t(lang, 'value.none')}`, `- navigation_only: ${anchor.navigationOnly ? t(lang, 'value.yes') : t(lang, 'value.no')}`, `- can_instruct_agent: ${anchor.canInstructAgent ? t(lang, 'value.yes') : t(lang, 'value.no')}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function runExplain(args, reporter, lang = 'en') {
+    if (args.includes('--help') || args.includes('-h')) {
+        reporter.stdout(getExplainHelp(lang));
+        return 0;
+    }
+    const json = args.includes('--json');
+    const unsupported = args.filter((arg) => arg.startsWith('-') && arg !== '--json');
+    if (unsupported.length > 0) {
+        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf explain --help', getExplainHelp(lang), lang);
+        return 1;
+    }
+    const positional = args.filter((arg) => arg !== '--json');
+    const [topic, targetArg, ...rest] = positional;
+    if (topic !== 'asset-optimization' &&
+        topic !== 'anchor' &&
+        topic !== 'authority' &&
+        topic !== 'command' &&
+        topic !== 'retention' &&
+        topic !== 'skill' &&
+        topic !== 'skills' &&
+        topic !== 'surface') {
+        printUsageError(reporter, t(lang, topic ? 'explain.error.unknownTopic' : 'explain.error.missingTopic', { topic: topic ?? '' }), 'mf explain --help', getExplainHelp(lang), lang);
+        return 1;
+    }
+    if (topic === 'command' && !targetArg) {
+        printUsageError(reporter, t(lang, 'explain.error.missingCommand'), 'mf explain --help', getExplainHelp(lang), lang);
+        return 1;
+    }
+    if (topic === 'skill' && !targetArg) {
+        printUsageError(reporter, t(lang, 'explain.error.missingSkill'), 'mf explain --help', getExplainHelp(lang), lang);
+        return 1;
+    }
+    if (topic === 'anchor' && !targetArg) {
+        printUsageError(reporter, t(lang, 'explain.error.missingAnchor'), 'mf explain --help', getExplainHelp(lang), lang);
+        return 1;
+    }
+    if (topic === 'retention' && targetArg) {
+        printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: targetArg }), 'mf explain --help', getExplainHelp(lang), lang);
+        return 1;
+    }
+    if (topic === 'asset-optimization' && targetArg) {
+        printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: targetArg }), 'mf explain --help', getExplainHelp(lang), lang);
+        return 1;
+    }
+    if (topic === 'anchor' && rest.length > 0) {
+        printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: rest[0] }), 'mf explain --help', getExplainHelp(lang), lang);
+        return 1;
+    }
+    if (topic === 'skills' && targetArg) {
+        printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: targetArg }), 'mf explain --help', getExplainHelp(lang), lang);
+        return 1;
+    }
+    if (rest.length > 0) {
+        printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: rest[0] }), 'mf explain --help', getExplainHelp(lang), lang);
+        return 1;
+    }
+    const projectRoot = resolveMustflowRoot();
+    let output;
+    switch (topic) {
+        case 'anchor':
+            output = getAnchorExplainOutput(projectRoot, targetArg);
+            break;
+        case 'asset-optimization':
+            output = getAssetOptimizationExplainOutput(projectRoot);
+            break;
+        case 'authority':
+            output = getAuthorityExplainOutput(projectRoot, targetArg);
+            break;
+        case 'command':
+            output = getCommandExplainOutput(projectRoot, targetArg);
+            break;
+        case 'retention':
+            output = getRetentionExplainOutput(projectRoot);
+            break;
+        case 'skill':
+            output = getSkillExplainOutput(projectRoot, targetArg);
+            break;
+        case 'surface':
+            output = getSurfaceExplainOutput(projectRoot, targetArg);
+            break;
+        case 'skills':
+            output = getSkillsExplainOutput(projectRoot);
+            break;
+    }
+    if (json) {
+        reporter.stdout(JSON.stringify(output, null, 2));
+        return 0;
+    }
+    reporter.stdout(renderExplainDecision(output, lang));
+    return 0;
+}

package/dist/cli/commands/help.js

@@ -0,0 +1,148 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { printUsageError, renderCliError, renderHelp } from '../lib/cli-output.js';
+import { t } from '../lib/i18n.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { readTomlFile } from '../lib/toml.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function readTextIfExists(projectRoot, relativePath) {
+    const filePath = path.join(projectRoot, ...relativePath.split('/'));
+    return existsSync(filePath) ? readFileSync(filePath, 'utf8') : undefined;
+}
+function readTomlIfExists(projectRoot, relativePath) {
+    const filePath = path.join(projectRoot, ...relativePath.split('/'));
+    if (!existsSync(filePath)) {
+        return undefined;
+    }
+    const parsed = readTomlFile(filePath);
+    return isRecord(parsed) ? parsed : undefined;
+}
+function renderMissing(relativePath, lang) {
+    return t(lang, 'help.missingFile', { path: relativePath });
+}
+function renderWorkflowHelp(projectRoot, lang) {
+    return readTextIfExists(projectRoot, '.mustflow/docs/agent-workflow.md') ?? renderMissing('.mustflow/docs/agent-workflow.md', lang);
+}
+function renderSkillsHelp(projectRoot, lang) {
+    return readTextIfExists(projectRoot, '.mustflow/skills/INDEX.md') ?? renderMissing('.mustflow/skills/INDEX.md', lang);
+}
+function renderCommandsHelp(projectRoot, lang) {
+    const commands = readTomlIfExists(projectRoot, '.mustflow/config/commands.toml');
+    if (!commands) {
+        return renderMissing('.mustflow/config/commands.toml', lang);
+    }
+    if (!isRecord(commands.intents)) {
+        return t(lang, 'help.commands.noIntents');
+    }
+    const lines = [t(lang, 'help.commands.title'), '', t(lang, 'help.commands.configuredIntents'), ''];
+    for (const [name, intent] of Object.entries(commands.intents).sort(([left], [right]) => left.localeCompare(right))) {
+        if (!isRecord(intent)) {
+            continue;
+        }
+        const status = typeof intent.status === 'string' ? intent.status : 'unknown';
+        const description = typeof intent.description === 'string' ? ` - ${intent.description}` : '';
+        lines.push(`- ${name}: ${status}${description}`);
+    }
+    return lines.join('\n');
+}
+function renderPreferencesHelp(projectRoot, lang) {
+    const preferences = readTomlIfExists(projectRoot, '.mustflow/config/preferences.toml');
+    if (!preferences) {
+        return `${t(lang, 'help.preferences.title')}\n\n${renderMissing('.mustflow/config/preferences.toml', lang)}`;
+    }
+    const lines = [t(lang, 'help.preferences.title'), '', t(lang, 'help.preferences.intro'), ''];
+    for (const [sectionName, section] of Object.entries(preferences)) {
+        if (!isRecord(section)) {
+            continue;
+        }
+        renderPreferenceSection(lines, sectionName, section);
+    }
+    return lines.join('\n').trimEnd();
+}
+function renderPreferenceSection(lines, sectionName, section) {
+    const nestedSections = [];
+    const scalarLines = [];
+    for (const [key, value] of Object.entries(section)) {
+        if (isRecord(value)) {
+            nestedSections.push([`${sectionName}.${key}`, value]);
+            continue;
+        }
+        if (Array.isArray(value)) {
+            scalarLines.push(`- ${key}: ${value.join(', ')}`);
+            continue;
+        }
+        if (typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number') {
+            scalarLines.push(`- ${key}: ${String(value)}`);
+        }
+    }
+    lines.push(`[${sectionName}]`, ...scalarLines, '');
+    for (const [nestedName, nestedSection] of nestedSections) {
+        renderPreferenceSection(lines, nestedName, nestedSection);
+    }
+}
+export function getHelpHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf help [topic]',
+        summary: t(lang, 'help.help.summary'),
+        topics: [
+            {
+                label: 'workflow',
+                description: t(lang, 'help.topic.workflow'),
+            },
+            { label: 'skills', description: t(lang, 'help.topic.skills') },
+            {
+                label: 'commands',
+                description: t(lang, 'help.topic.commands'),
+            },
+            {
+                label: 'preferences',
+                description: t(lang, 'help.topic.preferences'),
+            },
+        ],
+        options: [{ label: '-h, --help', description: t(lang, 'cli.option.help') }],
+        examples: ['mf help workflow', 'mf help skills', 'mf help preferences'],
+        exitCodes: [
+            {
+                label: '0',
+                description: t(lang, 'help.help.exit.ok'),
+            },
+            {
+                label: '1',
+                description: t(lang, 'help.help.exit.fail'),
+            },
+        ],
+    }, lang);
+}
+export function runHelp(args, reporter, lang = 'en') {
+    const [topic, ...rest] = args;
+    if (!topic || topic === '--help' || topic === '-h') {
+        reporter.stdout(getHelpHelp(lang));
+        return 0;
+    }
+    if (rest.length > 0) {
+        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: rest[0] }), 'mf help --help', getHelpHelp(lang), lang);
+        return 1;
+    }
+    const projectRoot = resolveMustflowRoot();
+    if (topic === 'workflow') {
+        reporter.stdout(renderWorkflowHelp(projectRoot, lang));
+        return 0;
+    }
+    if (topic === 'skills') {
+        reporter.stdout(renderSkillsHelp(projectRoot, lang));
+        return 0;
+    }
+    if (topic === 'commands') {
+        reporter.stdout(renderCommandsHelp(projectRoot, lang));
+        return 0;
+    }
+    if (topic === 'preferences') {
+        reporter.stdout(renderPreferencesHelp(projectRoot, lang));
+        return 0;
+    }
+    reporter.stderr(renderCliError(t(lang, 'help.error.unknownTopic', { topic }), 'mf help --help', lang));
+    reporter.stdout(getHelpHelp(lang));
+    return 1;
+}

package/dist/cli/commands/impact.js

@@ -0,0 +1,120 @@
+import path from 'node:path';
+import { createChangeClassificationReport } from '../../core/change-classification.js';
+import { summarizeVersionImpact } from '../../core/version-impact.js';
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { isRecord } from '../lib/command-contract.js';
+import { readGitChangedFiles } from '../lib/git-changes.js';
+import { t } from '../lib/i18n.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { readTomlFile } from '../lib/toml.js';
+import { detectVersionSources, releaseVersioningIsEnabled, } from '../../core/version-sources.js';
+const IMPACT_SCHEMA_VERSION = '1';
+export function getImpactHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf impact --changed [options] | mf impact <path...> [options]',
+        summary: t(lang, 'impact.help.summary'),
+        options: [
+            { label: '--changed', description: t(lang, 'impact.help.option.changed') },
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: ['mf impact --changed', 'mf impact package.json schemas/impact-report.schema.json --json'],
+        exitCodes: [
+            { label: '0', description: t(lang, 'impact.help.exit.ok') },
+            { label: '1', description: t(lang, 'cli.common.invalidInput') },
+        ],
+    }, lang);
+}
+function parseImpactArgs(args) {
+    const paths = [];
+    let json = false;
+    let changed = false;
+    for (const arg of args) {
+        if (arg === '--json') {
+            json = true;
+            continue;
+        }
+        if (arg === '--changed') {
+            changed = true;
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            return { json, changed, paths, error: arg };
+        }
+        paths.push(arg);
+    }
+    return { json, changed, paths };
+}
+function readPreferences(projectRoot) {
+    try {
+        const preferences = readTomlFile(path.join(projectRoot, '.mustflow', 'config', 'preferences.toml'));
+        return isRecord(preferences) ? preferences : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function createImpactOutput(projectRoot, parsed) {
+    const source = parsed.changed ? 'changed' : 'paths';
+    const files = parsed.changed ? readGitChangedFiles(projectRoot) : parsed.paths;
+    const classificationReport = createChangeClassificationReport(source, files);
+    const versionSources = detectVersionSources(projectRoot);
+    return {
+        schema_version: IMPACT_SCHEMA_VERSION,
+        command: 'impact',
+        mustflow_root: projectRoot,
+        source,
+        files: classificationReport.files,
+        versioning_enabled: releaseVersioningIsEnabled(readPreferences(projectRoot)),
+        version_sources: versionSources,
+        classification_summary: classificationReport.summary,
+        version_impact: summarizeVersionImpact(classificationReport, versionSources),
+    };
+}
+function renderList(values, lang) {
+    return values.length > 0 ? values.join(', ') : t(lang, 'value.none');
+}
+function renderImpactOutput(output, lang) {
+    const sourceLabel = output.source === 'changed' ? t(lang, 'classify.source.changed') : t(lang, 'classify.source.paths');
+    const lines = [
+        t(lang, 'impact.title'),
+        `${t(lang, 'label.mustflowRoot')}: ${output.mustflow_root}`,
+        `${t(lang, 'classify.label.source')}: ${sourceLabel}`,
+        `${t(lang, 'classify.label.files')}: ${output.files.length}`,
+        `${t(lang, 'impact.label.versioning')}: ${output.versioning_enabled ? t(lang, 'versionSources.value.enabled') : t(lang, 'versionSources.value.disabled')}`,
+        `${t(lang, 'impact.label.requiresVersionDecision')}: ${output.version_impact.requiresVersionDecision ? t(lang, 'value.yes') : t(lang, 'value.no')}`,
+        `${t(lang, 'impact.label.severity')}: ${output.version_impact.severity}`,
+        `${t(lang, 'impact.label.suggestedBump')}: ${output.version_impact.suggestedBump ?? t(lang, 'value.none')}`,
+        `${t(lang, 'impact.label.reasons')}: ${renderList(output.version_impact.reasons, lang)}`,
+        `${t(lang, 'impact.label.versionSources')}: ${renderList(output.version_sources.map((source) => source.path), lang)}`,
+        `${t(lang, 'impact.label.affectedVersionSources')}: ${renderList(output.version_impact.affectedVersionSources, lang)}`,
+        `${t(lang, 'impact.label.affectedSurfaces')}: ${renderList(output.version_impact.affectedSurfaces, lang)}`,
+    ];
+    return lines.join('\n');
+}
+export function runImpact(args, reporter, lang = 'en') {
+    if (args.includes('--help') || args.includes('-h')) {
+        reporter.stdout(getImpactHelp(lang));
+        return 0;
+    }
+    const parsed = parseImpactArgs(args);
+    if (parsed.error) {
+        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: parsed.error }), 'mf impact --help', getImpactHelp(lang), lang);
+        return 1;
+    }
+    if (parsed.changed && parsed.paths.length > 0) {
+        printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: parsed.paths[0] }), 'mf impact --help', getImpactHelp(lang), lang);
+        return 1;
+    }
+    if (!parsed.changed && parsed.paths.length === 0) {
+        printUsageError(reporter, t(lang, 'impact.error.missingInput'), 'mf impact --help', getImpactHelp(lang), lang);
+        return 1;
+    }
+    const output = createImpactOutput(resolveMustflowRoot(), parsed);
+    if (parsed.json) {
+        reporter.stdout(JSON.stringify(output, null, 2));
+        return 0;
+    }
+    reporter.stdout(renderImpactOutput(output, lang));
+    return 0;
+}

package/dist/cli/commands/index.js

@@ -0,0 +1,70 @@
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { t } from '../lib/i18n.js';
+import { createLocalIndex } from '../lib/local-index.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+export function getIndexHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf index [options]',
+        summary: t(lang, 'index.help.summary'),
+        options: [
+            {
+                label: '--dry-run',
+                description: t(lang, 'index.help.option.dryRun'),
+            },
+            {
+                label: '--source',
+                description: t(lang, 'index.help.option.source'),
+            },
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: ['mf index --dry-run --json', 'mf index', 'mf index --json'],
+        exitCodes: [
+            {
+                label: '0',
+                description: t(lang, 'index.help.exit.ok'),
+            },
+            { label: '1', description: t(lang, 'cli.common.invalidInput') },
+        ],
+    }, lang);
+}
+function renderIndexSummary(result, lang) {
+    const lines = [
+        t(lang, 'index.title'),
+        `${t(lang, 'label.mustflowRoot')}: ${result.mustflow_root}`,
+        `${t(lang, 'label.database')}: ${result.database_path}`,
+        `${t(lang, 'label.documents')}: ${result.document_count}`,
+        `${t(lang, 'label.skills')}: ${result.skill_count}`,
+        `skill_routes: ${result.skill_route_count}`,
+        `${t(lang, 'label.commandIntents')}: ${result.command_intent_count}`,
+        `command_effects: ${result.command_effect_count}`,
+        `source_anchors: ${result.source_anchor_count}`,
+        `${t(lang, 'label.wroteFiles')}: ${result.wrote_files ? 'yes' : 'no'}`,
+    ];
+    if (result.dry_run) {
+        lines.push(t(lang, 'index.dryRunNoFiles'));
+    }
+    return lines.join('\n');
+}
+export async function runIndex(args, reporter, lang = 'en') {
+    if (args.includes('--help') || args.includes('-h')) {
+        reporter.stdout(getIndexHelp(lang));
+        return 0;
+    }
+    const supported = new Set(['--dry-run', '--json', '--source']);
+    const unsupported = args.filter((arg) => !supported.has(arg));
+    if (unsupported.length > 0) {
+        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf index --help', getIndexHelp(lang), lang);
+        return 1;
+    }
+    const result = await createLocalIndex(resolveMustflowRoot(), {
+        dryRun: args.includes('--dry-run'),
+        includeSource: args.includes('--source'),
+    });
+    if (args.includes('--json')) {
+        reporter.stdout(JSON.stringify(result, null, 2));
+        return 0;
+    }
+    reporter.stdout(renderIndexSummary(result, lang));
+    return 0;
+}