mustflow 1.15.97

package/dist/cli/commands/search.js

@@ -0,0 +1,166 @@
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { t } from '../lib/i18n.js';
+import { searchLocalIndex } from '../lib/local-index.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+export function getSearchHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf search <query> [options]',
+        summary: t(lang, 'search.help.summary'),
+        options: [
+            {
+                label: '--limit <number>',
+                description: t(lang, 'search.help.option.limit'),
+            },
+            {
+                label: '--scope <workflow|source|all>',
+                description: t(lang, 'search.help.option.scope'),
+            },
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: [
+            'mf index',
+            'mf index --source',
+            'mf search mustflow_check',
+            'mf search "role mapping" --scope source',
+            'mf search test --limit 5',
+        ],
+        exitCodes: [
+            {
+                label: '0',
+                description: t(lang, 'search.help.exit.ok'),
+            },
+            {
+                label: '1',
+                description: t(lang, 'search.help.exit.fail'),
+            },
+        ],
+    }, lang);
+}
+function parseSearchOptions(args) {
+    const queryParts = [];
+    let limit = 10;
+    let scope = 'workflow';
+    let json = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg) {
+            continue;
+        }
+        if (arg === '--json') {
+            json = true;
+            continue;
+        }
+        if (arg === '--limit') {
+            const rawLimit = args[index + 1];
+            if (!rawLimit || rawLimit.startsWith('-')) {
+                return { query: '', limit, scope, json, error: { key: 'search.error.missingLimit' } };
+            }
+            const parsedLimit = Number.parseInt(rawLimit, 10);
+            if (!Number.isInteger(parsedLimit) || parsedLimit < 1 || parsedLimit > 50) {
+                return { query: '', limit, scope, json, error: { key: 'search.error.invalidLimit' } };
+            }
+            limit = parsedLimit;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--limit=')) {
+            const rawLimit = arg.slice('--limit='.length);
+            const parsedLimit = Number.parseInt(rawLimit, 10);
+            if (!Number.isInteger(parsedLimit) || parsedLimit < 1 || parsedLimit > 50) {
+                return { query: '', limit, scope, json, error: { key: 'search.error.invalidLimit' } };
+            }
+            limit = parsedLimit;
+            continue;
+        }
+        if (arg === '--scope') {
+            const rawScope = args[index + 1];
+            if (!rawScope || rawScope.startsWith('-')) {
+                return { query: '', limit, scope, json, error: { key: 'search.error.missingScope' } };
+            }
+            if (!isSearchScope(rawScope)) {
+                return {
+                    query: '',
+                    limit,
+                    scope,
+                    json,
+                    error: { key: 'search.error.invalidScope', params: { scope: rawScope } },
+                };
+            }
+            scope = rawScope;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--scope=')) {
+            const rawScope = arg.slice('--scope='.length);
+            if (!isSearchScope(rawScope)) {
+                return {
+                    query: '',
+                    limit,
+                    scope,
+                    json,
+                    error: { key: 'search.error.invalidScope', params: { scope: rawScope } },
+                };
+            }
+            scope = rawScope;
+            continue;
+        }
+        if (arg.startsWith('-')) {
+            return { query: '', limit, scope, json, error: { key: 'cli.error.unknownOption', params: { option: arg } } };
+        }
+        queryParts.push(arg);
+    }
+    const query = queryParts.join(' ').trim();
+    if (query.length === 0) {
+        return { query, limit, scope, json, error: { key: 'search.error.missingQuery' } };
+    }
+    return { query, limit, scope, json };
+}
+function isSearchScope(value) {
+    return value === 'workflow' || value === 'source' || value === 'all';
+}
+function renderSearchSummary(result, lang) {
+    const lines = [
+        t(lang, 'search.title'),
+        `${t(lang, 'label.query')}: ${result.query}`,
+        `${t(lang, 'label.scope')}: ${result.scope}`,
+        `${t(lang, 'label.results')}: ${result.result_count}`,
+    ];
+    for (const item of result.results) {
+        const target = item.path ?? item.name ?? item.title ?? item.kind;
+        const title = item.title && item.title !== target ? ` — ${item.title}` : '';
+        const line = item.line_start ? `${target}:${item.line_start}` : target;
+        lines.push(`- [${item.kind}] ${line}${title}`);
+        lines.push(`  ${item.authority_label}; navigation_only=${String(item.navigation_only)}`);
+        lines.push(`  ${item.match}`);
+    }
+    if (result.result_count === 0) {
+        lines.push(t(lang, 'search.noMatches'));
+    }
+    return lines.join('\n');
+}
+export async function runSearch(args, reporter, lang = 'en') {
+    if (args.includes('--help') || args.includes('-h')) {
+        reporter.stdout(getSearchHelp(lang));
+        return 0;
+    }
+    const options = parseSearchOptions(args);
+    if (options.error) {
+        printUsageError(reporter, t(lang, options.error.key, options.error.params), 'mf search --help', getSearchHelp(lang), lang);
+        return 1;
+    }
+    try {
+        const result = await searchLocalIndex(resolveMustflowRoot(), options.query, { limit: options.limit, scope: options.scope });
+        if (options.json) {
+            reporter.stdout(JSON.stringify(result, null, 2));
+            return 0;
+        }
+        reporter.stdout(renderSearchSummary(result, lang));
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        reporter.stderr(t(lang, 'cli.error.prefix', { message }));
+        return 1;
+    }
+}

package/dist/cli/commands/status.js

@@ -0,0 +1,65 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { t } from '../lib/i18n.js';
+import { inspectManifestLock } from '../lib/manifest-lock.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+export function getStatusHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf status [options]',
+        summary: t(lang, 'status.help.summary'),
+        options: [
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: ['mf status', 'mf status --json'],
+        exitCodes: [
+            { label: '0', description: t(lang, 'status.help.exit.ok') },
+            { label: '1', description: t(lang, 'cli.common.invalidInput') },
+        ],
+    }, lang);
+}
+function hasInstalledEntrypoints(projectRoot) {
+    return existsSync(path.join(projectRoot, 'AGENTS.md')) && existsSync(path.join(projectRoot, '.mustflow'));
+}
+function getStatusSnapshot(projectRoot) {
+    const inspection = inspectManifestLock(projectRoot);
+    const lock = inspection.readResult.kind === 'present' ? inspection.readResult.lock : undefined;
+    return {
+        installed: hasInstalledEntrypoints(projectRoot),
+        manifestLock: inspection.readResult.kind,
+        trackedFiles: lock?.files.length ?? 0,
+        changedFiles: inspection.changedFiles,
+        missingFiles: inspection.missingFiles,
+        issues: inspection.issues,
+        template: lock ? { id: lock.templateId, version: lock.templateVersion } : null,
+    };
+}
+export function runStatus(args, reporter, lang = 'en') {
+    if (args.includes('--help') || args.includes('-h')) {
+        reporter.stdout(getStatusHelp(lang));
+        return 0;
+    }
+    const supported = new Set(['--json']);
+    const unsupported = args.filter((arg) => !supported.has(arg));
+    if (unsupported.length > 0) {
+        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf status --help', getStatusHelp(lang), lang);
+        return 1;
+    }
+    const projectRoot = resolveMustflowRoot();
+    const status = getStatusSnapshot(projectRoot);
+    if (args.includes('--json')) {
+        reporter.stdout(JSON.stringify(status, null, 2));
+        return 0;
+    }
+    reporter.stdout(t(lang, 'status.title'));
+    reporter.stdout(`${t(lang, 'label.installed')}: ${status.installed ? 'yes' : 'no'}`);
+    reporter.stdout(`${t(lang, 'label.manifestLock')}: ${status.manifestLock}`);
+    reporter.stdout(`${t(lang, 'label.trackedFiles')}: ${status.trackedFiles}`);
+    reporter.stdout(`${t(lang, 'label.changedFiles')}: ${status.changedFiles.length}`);
+    reporter.stdout(`${t(lang, 'label.missingFiles')}: ${status.missingFiles.length}`);
+    for (const issue of status.issues) {
+        reporter.stdout(`- ${issue.replace(/^Lock hash mismatch: /, '').replace(/^Locked file missing: /, '')}`);
+    }
+    return 0;
+}

package/dist/cli/commands/update.js

@@ -0,0 +1,443 @@
+import { createHash } from 'node:crypto';
+import { copyFileSync, existsSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { ensureFileTargetInsideWithoutSymlinks, ensureInside, writeUtf8FileInsideWithoutSymlinks, } from '../lib/filesystem.js';
+import { MANIFEST_LOCK_RELATIVE_PATH, readManifestLock, sha256File } from '../lib/manifest-lock.js';
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { t } from '../lib/i18n.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { getDefaultTemplate, getTemplateFiles } from '../lib/templates.js';
+import { readTomlFile, stringifyToml } from '../lib/toml.js';
+const UPDATE_SCHEMA_VERSION = '1';
+const CUSTOMIZED_LOCK_ACTION = 'customized';
+const UPDATE_POLICY = {
+    baseline: 'manifest_lock_content_hash',
+    allowed_apply_actions: ['update', 'create'],
+    blocking_actions: ['blocked-local-change', 'manual-review'],
+    dry_run_writes_files: false,
+    backup_path_pattern: '.mustflow/backups/<timestamp>/',
+    never_overwrite_local_changes: true,
+    writes_only_template_manifest_paths: true,
+};
+export function getUpdateHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf update (--dry-run|--apply) [options]',
+        summary: t(lang, 'update.help.summary'),
+        options: [
+            { label: '--dry-run', description: t(lang, 'update.help.option.dryRun') },
+            {
+                label: '--apply',
+                description: t(lang, 'update.help.option.apply'),
+            },
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: ['mf update --dry-run', 'mf update --dry-run --json', 'mf update --apply'],
+        exitCodes: [
+            {
+                label: '0',
+                description: t(lang, 'update.help.exit.ok'),
+            },
+            {
+                label: '1',
+                description: t(lang, 'update.help.exit.fail'),
+            },
+        ],
+    }, lang);
+}
+function byRelativePath(files) {
+    return new Map(files.map((file) => [file.relativePath, file]));
+}
+function sha256Text(content) {
+    return `sha256:${createHash('sha256').update(content).digest('hex')}`;
+}
+function templateFileHash(source) {
+    return source.content === undefined ? sha256File(source.sourcePath) : sha256Text(source.content);
+}
+function writeTemplateFile(projectRoot, source, targetPath) {
+    if (source.content !== undefined) {
+        writeUtf8FileInsideWithoutSymlinks(projectRoot, targetPath, source.content);
+        return;
+    }
+    ensureFileTargetInsideWithoutSymlinks(projectRoot, targetPath, { allowMissingLeaf: true });
+    mkdirSync(path.dirname(targetPath), { recursive: true });
+    copyFileSync(source.sourcePath, targetPath);
+}
+function templateTargetSafetyIssue(projectRoot, targetPath, allowMissingLeaf) {
+    try {
+        ensureFileTargetInsideWithoutSymlinks(projectRoot, targetPath, { allowMissingLeaf });
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+export function planUpdate(projectRoot) {
+    const lockResult = readManifestLock(projectRoot);
+    if (lockResult.kind === 'missing') {
+        return { items: [], error: `Missing ${MANIFEST_LOCK_RELATIVE_PATH}` };
+    }
+    if (lockResult.kind === 'invalid') {
+        return { items: [], error: `Invalid manifest lock: ${lockResult.message}` };
+    }
+    let template;
+    try {
+        template = getDefaultTemplate();
+    }
+    catch (error) {
+        return { items: [], error: error instanceof Error ? error.message : String(error) };
+    }
+    const selectedLocale = lockResult.lock.templateLocale ?? template.manifest.defaultLocale;
+    const selectedProfile = lockResult.lock.templateProfile ?? template.manifest.defaultProfile;
+    const templateFiles = getTemplateFiles(template, selectedLocale, selectedProfile);
+    const lockedFiles = byRelativePath(lockResult.lock.files);
+    const items = [];
+    for (const source of templateFiles) {
+        const targetPath = path.join(projectRoot, source.relativePath);
+        const lockedFile = lockedFiles.get(source.relativePath);
+        ensureInside(template.templateRoot, source.sourcePath);
+        ensureInside(projectRoot, targetPath);
+        const unsafeTargetReason = templateTargetSafetyIssue(projectRoot, targetPath, true);
+        if (unsafeTargetReason) {
+            items.push({
+                relativePath: source.relativePath,
+                sourceKind: source.sourceKind,
+                action: 'blocked-local-change',
+                reason: unsafeTargetReason,
+            });
+            continue;
+        }
+        if (!existsSync(targetPath)) {
+            if (lockedFile) {
+                items.push({
+                    relativePath: source.relativePath,
+                    sourceKind: source.sourceKind,
+                    action: 'blocked-local-change',
+                    reason: 'target file is missing but tracked by the manifest lock',
+                });
+                continue;
+            }
+            items.push({
+                relativePath: source.relativePath,
+                sourceKind: source.sourceKind,
+                action: 'create',
+                reason: 'target file is missing',
+            });
+            continue;
+        }
+        const currentHash = sha256File(targetPath);
+        const templateHash = templateFileHash(source);
+        if (!lockedFile && currentHash !== templateHash) {
+            items.push({
+                relativePath: source.relativePath,
+                sourceKind: source.sourceKind,
+                action: 'blocked-local-change',
+                reason: 'target file exists but is not tracked by the manifest lock',
+            });
+            continue;
+        }
+        if (lockedFile && currentHash !== lockedFile.contentHash) {
+            items.push({
+                relativePath: source.relativePath,
+                sourceKind: source.sourceKind,
+                action: 'blocked-local-change',
+                reason: 'current file differs from the manifest lock baseline',
+            });
+            continue;
+        }
+        if (lockedFile?.lastAction === CUSTOMIZED_LOCK_ACTION && currentHash !== templateHash) {
+            items.push({
+                relativePath: source.relativePath,
+                sourceKind: source.sourceKind,
+                action: 'unchanged',
+                reason: 'manifest lock marks this file as customized and current file matches that baseline',
+            });
+            continue;
+        }
+        if (lockedFile?.source === 'managed_block' && currentHash !== templateHash) {
+            items.push({
+                relativePath: source.relativePath,
+                sourceKind: source.sourceKind,
+                action: 'manual-review',
+                reason: 'managed block requires a block-level manifest baseline',
+            });
+            continue;
+        }
+        if (currentHash !== templateHash) {
+            items.push({
+                relativePath: source.relativePath,
+                sourceKind: source.sourceKind,
+                action: 'update',
+                reason: 'template content differs from current file',
+            });
+            continue;
+        }
+        items.push({
+            relativePath: source.relativePath,
+            sourceKind: source.sourceKind,
+            action: 'unchanged',
+            reason: 'current file matches the bundled template',
+        });
+    }
+    return { items };
+}
+function printItems(title, items, reporter) {
+    reporter.stdout(`${title}: ${items.length}`);
+    for (const item of items) {
+        reporter.stdout(`- ${item.relativePath} (${item.reason})`);
+    }
+}
+export function summarizePlan(items) {
+    return {
+        blockedLocalChanges: items.filter((item) => item.action === 'blocked-local-change').length,
+        manualReview: items.filter((item) => item.action === 'manual-review').length,
+        wouldUpdate: items.filter((item) => item.action === 'update').length,
+        wouldCreate: items.filter((item) => item.action === 'create').length,
+        unchanged: items.filter((item) => item.action === 'unchanged').length,
+    };
+}
+function isMutableTable(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function fileActionToLockAction(action) {
+    return action === 'create' ? 'created' : 'updated';
+}
+function readInstalledTemplateSelection(projectRoot) {
+    const lockResult = readManifestLock(projectRoot);
+    return lockResult.kind === 'present'
+        ? { locale: lockResult.lock.templateLocale, profile: lockResult.lock.templateProfile }
+        : {};
+}
+function copyTemplateFile(projectRoot, relativePath) {
+    const template = getDefaultTemplate();
+    const selection = readInstalledTemplateSelection(projectRoot);
+    const source = getTemplateFiles(template, selection.locale ?? template.manifest.defaultLocale, selection.profile ?? template.manifest.defaultProfile).find((file) => file.relativePath === relativePath);
+    const targetPath = path.join(projectRoot, relativePath);
+    if (!source) {
+        throw new Error(`Template source missing for ${relativePath}`);
+    }
+    ensureInside(template.templateRoot, source.sourcePath);
+    ensureInside(projectRoot, targetPath);
+    ensureFileTargetInsideWithoutSymlinks(projectRoot, targetPath, { allowMissingLeaf: true });
+    writeTemplateFile(projectRoot, source, targetPath);
+}
+function backupUpdateFiles(projectRoot, items, reporter, lang) {
+    const updateItems = items.filter((item) => item.action === 'update');
+    if (updateItems.length === 0) {
+        return;
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupRoot = path.join(projectRoot, '.mustflow', 'backups', timestamp);
+    for (const item of updateItems) {
+        const sourcePath = path.join(projectRoot, item.relativePath);
+        const backupPath = path.join(backupRoot, item.relativePath);
+        ensureInside(projectRoot, sourcePath);
+        ensureInside(backupRoot, backupPath);
+        ensureFileTargetInsideWithoutSymlinks(projectRoot, sourcePath);
+        ensureFileTargetInsideWithoutSymlinks(projectRoot, backupPath, { allowMissingLeaf: true });
+        mkdirSync(path.dirname(backupPath), { recursive: true });
+        copyFileSync(sourcePath, backupPath);
+    }
+    reporter.stdout(t(lang, 'update.backup.files', {
+        count: updateItems.length,
+        fileWord: t(lang, updateItems.length === 1 ? 'init.fileWord.singular' : 'init.fileWord.plural'),
+        path: backupRoot,
+    }));
+}
+function updateManifestLockAfterApply(projectRoot, appliedItems) {
+    if (appliedItems.length === 0) {
+        return;
+    }
+    const lockPath = path.join(projectRoot, MANIFEST_LOCK_RELATIVE_PATH);
+    ensureInside(projectRoot, lockPath);
+    ensureFileTargetInsideWithoutSymlinks(projectRoot, lockPath);
+    const parsed = readTomlFile(lockPath);
+    if (!isMutableTable(parsed)) {
+        throw new Error(`Invalid manifest lock: ${MANIFEST_LOCK_RELATIVE_PATH} must contain a TOML table`);
+    }
+    const template = getDefaultTemplate();
+    const templateTable = isMutableTable(parsed.template) ? parsed.template : {};
+    templateTable.id = template.manifest.id;
+    templateTable.version = template.manifest.version;
+    parsed.template = templateTable;
+    const filesTable = isMutableTable(parsed.files) ? parsed.files : {};
+    for (const item of appliedItems) {
+        const targetPath = path.join(projectRoot, item.relativePath);
+        ensureInside(projectRoot, targetPath);
+        ensureFileTargetInsideWithoutSymlinks(projectRoot, targetPath);
+        const existing = filesTable[item.relativePath];
+        const existingTable = isMutableTable(existing) ? existing : {};
+        filesTable[item.relativePath] = {
+            source: typeof existingTable.source === 'string'
+                ? existingTable.source
+                : item.sourceKind === 'locale'
+                    ? 'template_locale'
+                    : 'template_common',
+            last_action: fileActionToLockAction(item.action),
+            content_hash: sha256File(targetPath),
+        };
+    }
+    parsed.files = filesTable;
+    writeUtf8FileInsideWithoutSymlinks(projectRoot, lockPath, stringifyToml(parsed));
+}
+function applyUpdate(projectRoot, items, reporter, lang) {
+    let created = 0;
+    let updated = 0;
+    const appliedItems = [];
+    backupUpdateFiles(projectRoot, items, reporter, lang);
+    for (const item of items) {
+        if (item.action !== 'create' && item.action !== 'update') {
+            continue;
+        }
+        copyTemplateFile(projectRoot, item.relativePath);
+        appliedItems.push(item);
+        if (item.action === 'create') {
+            created += 1;
+            reporter.stdout(t(lang, 'update.action.created', { path: item.relativePath }));
+        }
+        else {
+            updated += 1;
+            reporter.stdout(t(lang, 'update.action.updated', { path: item.relativePath }));
+        }
+    }
+    updateManifestLockAfterApply(projectRoot, appliedItems);
+    if (appliedItems.length > 0) {
+        reporter.stdout(t(lang, 'update.action.wrote', { path: MANIFEST_LOCK_RELATIVE_PATH }));
+    }
+    return {
+        created,
+        updated,
+        wroteFiles: appliedItems.length > 0,
+    };
+}
+function planOutput(items, error, wroteFiles) {
+    const summary = summarizePlan(items);
+    return {
+        schema_version: UPDATE_SCHEMA_VERSION,
+        command: 'update',
+        mode: 'unspecified',
+        policy: UPDATE_POLICY,
+        ok: !error && summary.blockedLocalChanges === 0 && summary.manualReview === 0,
+        wroteFiles,
+        summary,
+        items,
+        ...(error ? { error } : {}),
+    };
+}
+function withMode(output, mode) {
+    return {
+        ...output,
+        mode,
+    };
+}
+function getRequestedMode(wantsDryRun, wantsApply) {
+    if (wantsDryRun && !wantsApply) {
+        return 'dry-run';
+    }
+    if (wantsApply && !wantsDryRun) {
+        return 'apply';
+    }
+    return 'unspecified';
+}
+function printPolicy(reporter, lang) {
+    reporter.stdout(t(lang, 'update.policy.title'));
+    reporter.stdout(`- ${t(lang, 'update.policy.baseline')}: ${UPDATE_POLICY.baseline}`);
+    reporter.stdout(`- ${t(lang, 'update.policy.applyActions')}: ${UPDATE_POLICY.allowed_apply_actions.join(', ')}`);
+    reporter.stdout(`- ${t(lang, 'update.policy.blockingActions')}: ${UPDATE_POLICY.blocking_actions.join(', ')}`);
+    reporter.stdout(`- ${t(lang, 'update.policy.backupPath')}: ${UPDATE_POLICY.backup_path_pattern}`);
+}
+function printPlan(output, reporter, lang) {
+    const blocked = output.items.filter((item) => item.action === 'blocked-local-change');
+    const manualReview = output.items.filter((item) => item.action === 'manual-review');
+    const updates = output.items.filter((item) => item.action === 'update');
+    const creates = output.items.filter((item) => item.action === 'create');
+    reporter.stdout(t(lang, 'update.plan.title'));
+    printPolicy(reporter, lang);
+    printItems(t(lang, 'update.plan.blocked'), blocked, reporter);
+    printItems(t(lang, 'update.plan.manualReview'), manualReview, reporter);
+    printItems(t(lang, 'update.plan.wouldUpdate'), updates, reporter);
+    printItems(t(lang, 'update.plan.wouldCreate'), creates, reporter);
+    if (blocked.length === 0 && manualReview.length === 0 && updates.length === 0 && creates.length === 0) {
+        reporter.stdout(t(lang, 'update.plan.noUpdates'));
+    }
+}
+export function runUpdate(args, reporter, lang = 'en') {
+    if (args.includes('--help') || args.includes('-h')) {
+        reporter.stdout(getUpdateHelp(lang));
+        return 0;
+    }
+    const supported = new Set(['--dry-run', '--apply', '--json']);
+    const unsupported = args.filter((arg) => !supported.has(arg));
+    const wantsJson = args.includes('--json');
+    const wantsDryRun = args.includes('--dry-run');
+    const wantsApply = args.includes('--apply');
+    const requestedMode = getRequestedMode(wantsDryRun, wantsApply);
+    if (unsupported.length > 0) {
+        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf update --help', getUpdateHelp(lang), lang);
+        return 1;
+    }
+    if (wantsDryRun && wantsApply) {
+        const error = t(lang, 'update.error.cannotCombineModes');
+        if (wantsJson) {
+            reporter.stdout(JSON.stringify(withMode(planOutput([], error, false), requestedMode), null, 2));
+            return 1;
+        }
+        printUsageError(reporter, error, 'mf update --help', getUpdateHelp(lang), lang);
+        return 1;
+    }
+    if (!wantsDryRun && !wantsApply) {
+        const error = t(lang, 'update.error.missingMode');
+        if (wantsJson) {
+            reporter.stdout(JSON.stringify(withMode(planOutput([], error, false), requestedMode), null, 2));
+            return 1;
+        }
+        printUsageError(reporter, error, 'mf update --help', getUpdateHelp(lang), lang);
+        return 1;
+    }
+    const projectRoot = resolveMustflowRoot();
+    const plan = planUpdate(projectRoot);
+    if (plan.error) {
+        if (wantsJson) {
+            reporter.stdout(JSON.stringify(withMode(planOutput(plan.items, plan.error, false), requestedMode), null, 2));
+            return 1;
+        }
+        reporter.stderr(plan.error);
+        return 1;
+    }
+    const dryRunOutput = withMode(planOutput(plan.items, undefined, false), requestedMode);
+    if (wantsDryRun) {
+        if (wantsJson) {
+            reporter.stdout(JSON.stringify(dryRunOutput, null, 2));
+            return dryRunOutput.ok ? 0 : 1;
+        }
+        printPlan(dryRunOutput, reporter, lang);
+        reporter.stdout(t(lang, 'update.plan.noFilesWritten'));
+        return dryRunOutput.ok ? 0 : 1;
+    }
+    if (!dryRunOutput.ok) {
+        if (wantsJson) {
+            reporter.stdout(JSON.stringify(dryRunOutput, null, 2));
+            return 1;
+        }
+        printPlan(dryRunOutput, reporter, lang);
+        reporter.stdout(t(lang, 'update.plan.noFilesWritten'));
+        return 1;
+    }
+    if (wantsJson) {
+        const applicableItems = plan.items.filter((item) => item.action === 'create' || item.action === 'update');
+        const applyResult = applyUpdate(projectRoot, applicableItems, {
+            stdout: () => undefined,
+            stderr: (message) => reporter.stderr(message),
+        }, lang);
+        reporter.stdout(JSON.stringify(withMode(planOutput(plan.items, undefined, applyResult.wroteFiles), 'apply'), null, 2));
+        return 0;
+    }
+    const applyResult = applyUpdate(projectRoot, plan.items, reporter, lang);
+    if (!applyResult.wroteFiles) {
+        reporter.stdout(t(lang, 'update.plan.noUpdates'));
+        reporter.stdout(t(lang, 'update.plan.noFilesWritten'));
+        return 0;
+    }
+    reporter.stdout(t(lang, 'update.complete', { updated: applyResult.updated, created: applyResult.created }));
+    return 0;
+}