mustflow 2.23.0 → 2.24.2

package/dist/cli/commands/onboard.js

@@ -0,0 +1,136 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { lintCommandContract, } from '../../core/contract-lint.js';
+import { isRecord, readCommandContract, } from '../../core/config-loading.js';
+import { releaseVersioningIsEnabled } from '../../core/version-sources.js';
+import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { t } from '../lib/i18n.js';
+import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
+import { resolveMustflowRoot } from '../lib/project-root.js';
+import { readMustflowTomlFile } from '../lib/toml.js';
+const ONBOARD_COMMANDS_SCHEMA_VERSION = '1';
+const COMMAND_CONTRACT_PATH = '.mustflow/config/commands.toml';
+const ONBOARD_COMMANDS_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+];
+export function getOnboardHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf onboard commands [options]',
+        summary: t(lang, 'onboard.help.summary'),
+        options: [
+            { label: '--json', description: t(lang, 'cli.option.json') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: ['mf onboard commands', 'mf onboard commands --json'],
+        exitCodes: [
+            { label: '0', description: t(lang, 'onboard.help.exit.ok') },
+            { label: '1', description: t(lang, 'onboard.help.exit.fail') },
+        ],
+    }, lang);
+}
+function readPreferences(projectRoot) {
+    const preferencesPath = path.join(projectRoot, '.mustflow', 'config', 'preferences.toml');
+    if (!existsSync(preferencesPath)) {
+        return undefined;
+    }
+    const preferences = readMustflowTomlFile(projectRoot, '.mustflow/config/preferences.toml');
+    return isRecord(preferences) ? preferences : undefined;
+}
+function countSuggestionsByKind(suggestions, sourceKind) {
+    return suggestions.filter((suggestion) => suggestion.sourceKind === sourceKind).length;
+}
+function createNextSteps(suggestions) {
+    if (suggestions.length === 0) {
+        return [
+            'No package.json scripts, Makefile targets, or justfile recipes need review-only command-intent suggestions.',
+            'Keep command execution authority in .mustflow/config/commands.toml.',
+        ];
+    }
+    return [
+        'Review each suggested unknown intent before copying it into .mustflow/config/commands.toml.',
+        'Do not add argv, lifecycle, run_policy, stdin, timeout_seconds, writes, network, or destructive fields until a maintainer has reviewed the command behavior.',
+        'After accepting any snippet, run command-contract validation through the configured mustflow check intent.',
+    ];
+}
+function createOnboardCommandsOutput(projectRoot) {
+    const report = lintCommandContract(readCommandContract(projectRoot), {
+        suggest: true,
+        projectRoot,
+        releaseVersioningEnabled: releaseVersioningIsEnabled(readPreferences(projectRoot)),
+    });
+    const suggestions = report.suggestions ?? [];
+    return {
+        schema_version: ONBOARD_COMMANDS_SCHEMA_VERSION,
+        command: 'onboard commands',
+        mustflow_root: projectRoot,
+        command_contract_path: COMMAND_CONTRACT_PATH,
+        policy: {
+            command_authority: COMMAND_CONTRACT_PATH,
+            suggestions_grant_command_authority: false,
+            suggestions_are_review_only: true,
+            writes_files: false,
+        },
+        summary: {
+            total_intents: report.summary.totalIntents,
+            runnable_intents: report.summary.runnable,
+            manual_only_intents: report.summary.manualOnly,
+            unknown_intents: report.summary.unknown,
+            suggestions: suggestions.length,
+            package_scripts: countSuggestionsByKind(suggestions, 'package_script'),
+            make_targets: countSuggestionsByKind(suggestions, 'make_target'),
+            just_recipes: countSuggestionsByKind(suggestions, 'just_recipe'),
+            contract_errors: report.summary.errors,
+            contract_warnings: report.summary.warnings,
+        },
+        suggestions,
+        next_steps: createNextSteps(suggestions),
+    };
+}
+function renderOnboardCommandsOutput(output, lang) {
+    const reviewOnlyValue = output.policy.suggestions_are_review_only ? t(lang, 'value.yes') : t(lang, 'value.no');
+    const writesFilesValue = output.policy.writes_files ? t(lang, 'value.yes') : t(lang, 'value.no');
+    const lines = [
+        t(lang, 'onboard.title'),
+        `${t(lang, 'label.mustflowRoot')}: ${output.mustflow_root}`,
+        `${t(lang, 'label.commandContract')}: ${output.command_contract_path}`,
+        `${t(lang, 'onboard.label.suggestions')}: ${output.summary.suggestions}`,
+        `${t(lang, 'onboard.label.reviewOnly')}: ${reviewOnlyValue}`,
+        `${t(lang, 'onboard.label.writesFiles')}: ${writesFilesValue}`,
+    ];
+    if (output.suggestions.length > 0) {
+        lines.push('', t(lang, 'onboard.label.reviewSnippets'));
+        for (const suggestion of output.suggestions) {
+            lines.push(`- ${suggestion.sourceFile}:${suggestion.sourceName} -> ${suggestion.suggestedIntent}`);
+            lines.push(...suggestion.snippet.split('\n').map((line) => `  ${line}`));
+        }
+    }
+    lines.push('', t(lang, 'onboard.label.nextSteps'));
+    for (const step of output.next_steps) {
+        lines.push(`- ${step}`);
+    }
+    return lines.join('\n');
+}
+export function runOnboard(args, reporter, lang = 'en') {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
+        reporter.stdout(getOnboardHelp(lang));
+        return 0;
+    }
+    const [action, ...rest] = args;
+    if (action !== 'commands') {
+        printUsageError(reporter, t(lang, action ? 'onboard.error.unknownAction' : 'onboard.error.missingAction', { action: action ?? '' }), 'mf onboard --help', getOnboardHelp(lang), lang);
+        return 1;
+    }
+    const options = parseCliOptions(rest, ONBOARD_COMMANDS_OPTIONS);
+    if (options.error) {
+        printUsageError(reporter, formatCliOptionParseError(options.error, lang), 'mf onboard --help', getOnboardHelp(lang), lang);
+        return 1;
+    }
+    const output = createOnboardCommandsOutput(resolveMustflowRoot());
+    if (hasParsedCliOption(options, '--json')) {
+        reporter.stdout(JSON.stringify(output, null, 2));
+    }
+    else {
+        reporter.stdout(renderOnboardCommandsOutput(output, lang));
+    }
+    return 0;
+}

package/dist/cli/commands/run.js

@@ -7,6 +7,7 @@ import { printUsageError, renderCliError, renderHelp } from '../lib/cli-output.j
 import { readCommandContract, readMustflowConfigIfExists } from '../../core/config-loading.js';
 import { resolveRunReceiptRetentionPolicy } from '../../core/retention-policy.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 { ALLOW_UNTRUSTED_ROOT_OPTION, assessRunRootTrust } from '../lib/run-root-trust.js';
 import { createRunPlan, createRunPreview, renderRunPreviewText, } from '../lib/run-plan.js';
@@ -20,6 +21,14 @@ import { createPendingTimeoutTermination, getKillMethod, terminateProcessTree }
 import { assembleRunReceipt } from './run/receipt.js';
 const DEFAULT_ACTIVE_LOCK_WAIT_TIMEOUT_SECONDS = 300;
 const ACTIVE_LOCK_WAIT_POLL_MS = 1_000;
+const RUN_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--dry-run', kind: 'boolean' },
+    { name: '--plan-only', kind: 'boolean' },
+    { name: '--wait', kind: 'boolean' },
+    { name: ALLOW_UNTRUSTED_ROOT_OPTION, kind: 'boolean' },
+    { name: '--wait-timeout', kind: 'string' },
+];
 function delay(milliseconds) {
     return new Promise((resolve) => {
         setTimeout(resolve, milliseconds);
@@ -125,51 +134,44 @@ function renderActiveLockConflictMessage(intentName, conflicts, lang) {
     return t(lang, 'run.error.activeLockConflict', { intent: intentName, detail });
 }
 function parseRunArguments(args) {
-    const supportedBooleanOptions = new Set(['--json', '--dry-run', '--plan-only', '--wait', ALLOW_UNTRUSTED_ROOT_OPTION]);
-    const supportedValueOptions = new Set(['--wait-timeout']);
-    const positional = [];
-    const unsupported = [];
+    const parsed = parseCliOptions(args, RUN_OPTIONS, { allowPositionals: true });
     let waitTimeoutSeconds = DEFAULT_ACTIVE_LOCK_WAIT_TIMEOUT_SECONDS;
-    let invalidWaitTimeout = false;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (supportedBooleanOptions.has(arg)) {
-            continue;
-        }
-        if (supportedValueOptions.has(arg)) {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                invalidWaitTimeout = true;
-                continue;
-            }
-            const parsed = Number(value);
-            if (!Number.isInteger(parsed) || parsed <= 0) {
-                invalidWaitTimeout = true;
-            }
-            else {
-                waitTimeoutSeconds = parsed;
-            }
-            index += 1;
-            continue;
+    if (parsed.error) {
+        const [intentName, ...extra] = parsed.positionals;
+        return {
+            json: hasParsedCliOption(parsed, '--json'),
+            dryRun: hasParsedCliOption(parsed, '--dry-run'),
+            planOnly: hasParsedCliOption(parsed, '--plan-only'),
+            allowUntrustedRoot: hasParsedCliOption(parsed, ALLOW_UNTRUSTED_ROOT_OPTION),
+            wait: hasParsedCliOption(parsed, '--wait'),
+            waitTimeoutSeconds,
+            intentName: intentName ?? null,
+            extra,
+            error: parsed.error,
+        };
+    }
+    const waitTimeoutValue = getParsedCliStringOption(parsed, '--wait-timeout');
+    let error = null;
+    if (waitTimeoutValue !== null) {
+        const parsedWaitTimeout = Number(waitTimeoutValue);
+        if (!Number.isInteger(parsedWaitTimeout) || parsedWaitTimeout <= 0) {
+            error = 'invalid_wait_timeout';
         }
-        if (arg.startsWith('-')) {
-            unsupported.push(arg);
-            continue;
+        else {
+            waitTimeoutSeconds = parsedWaitTimeout;
         }
-        positional.push(arg);
     }
-    const [intentName, ...extra] = positional;
+    const [intentName, ...extra] = parsed.positionals;
     return {
-        json: args.includes('--json'),
-        dryRun: args.includes('--dry-run'),
-        planOnly: args.includes('--plan-only'),
-        allowUntrustedRoot: args.includes(ALLOW_UNTRUSTED_ROOT_OPTION),
-        wait: args.includes('--wait'),
+        json: hasParsedCliOption(parsed, '--json'),
+        dryRun: hasParsedCliOption(parsed, '--dry-run'),
+        planOnly: hasParsedCliOption(parsed, '--plan-only'),
+        allowUntrustedRoot: hasParsedCliOption(parsed, ALLOW_UNTRUSTED_ROOT_OPTION),
+        wait: hasParsedCliOption(parsed, '--wait'),
         waitTimeoutSeconds,
         intentName: intentName ?? null,
         extra,
-        unsupported,
-        invalidWaitTimeout,
+        error,
     };
 }
 async function acquireActiveRunLockWithOptionalWait(input) {
@@ -256,17 +258,20 @@ export function getRunHelp(lang = 'en') {
 export async function runRun(args, reporter, lang = 'en', options = {}) {
     const executorStartedAtMs = performance.now();
     const profiler = new RunProfiler();
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getRunHelp(lang));
         return 0;
     }
     const parsedArgs = parseRunArguments(args);
-    const unsupported = parsedArgs.unsupported;
-    if (unsupported.length > 0) {
-        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf run --help', getRunHelp(lang), lang);
+    if (parsedArgs.error && parsedArgs.error !== 'invalid_wait_timeout') {
+        if (parsedArgs.error.kind === 'missing_value' && parsedArgs.error.option === '--wait-timeout') {
+            printUsageError(reporter, t(lang, 'run.error.invalidWaitTimeout'), 'mf run --help', getRunHelp(lang), lang);
+            return 1;
+        }
+        printUsageError(reporter, formatCliOptionParseError(parsedArgs.error, lang), 'mf run --help', getRunHelp(lang), lang);
         return 1;
     }
-    if (parsedArgs.invalidWaitTimeout) {
+    if (parsedArgs.error === 'invalid_wait_timeout') {
         printUsageError(reporter, t(lang, 'run.error.invalidWaitTimeout'), 'mf run --help', getRunHelp(lang), lang);
         return 1;
     }

package/dist/cli/commands/search.js

@@ -1,7 +1,13 @@
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
 import { searchLocalIndex } from '../lib/local-index.js';
+import { getParsedCliStringOption, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
+const SEARCH_OPTIONS = [
+    { name: '--limit', kind: 'string' },
+    { name: '--scope', kind: 'string' },
+    { name: '--json', kind: 'boolean' },
+];
 export function getSearchHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf search <query> [options]',
@@ -37,80 +43,48 @@ export function getSearchHelp(lang = 'en') {
         ],
     }, lang);
 }
+function toSearchOptionError(error) {
+    if (error.kind === 'missing_value' && error.option === '--limit') {
+        return { key: 'search.error.missingLimit' };
+    }
+    if (error.kind === 'missing_value' && error.option === '--scope') {
+        return { key: 'search.error.missingScope' };
+    }
+    if (error.kind === 'missing_value') {
+        return { key: 'cli.error.missingValue', params: { option: error.option } };
+    }
+    return { key: 'cli.error.unknownOption', params: { option: error.option } };
+}
 function parseSearchOptions(args) {
-    const queryParts = [];
+    const parsed = parseCliOptions(args, SEARCH_OPTIONS, { allowPositionals: true });
     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;
+    const json = hasParsedCliOption(parsed, '--json');
+    if (parsed.error) {
+        return { query: '', limit, scope, json, error: toSearchOptionError(parsed.error) };
+    }
+    const rawLimit = getParsedCliStringOption(parsed, '--limit');
+    if (rawLimit !== null) {
+        const parsedLimit = Number.parseInt(rawLimit, 10);
+        if (!Number.isInteger(parsedLimit) || parsedLimit < 1 || parsedLimit > 50) {
+            return { query: '', limit, scope, json, error: { key: 'search.error.invalidLimit' } };
         }
-        if (arg.startsWith('-')) {
-            return { query: '', limit, scope, json, error: { key: 'cli.error.unknownOption', params: { option: arg } } };
+        limit = parsedLimit;
+    }
+    const rawScope = getParsedCliStringOption(parsed, '--scope');
+    if (rawScope !== null) {
+        if (!isSearchScope(rawScope)) {
+            return {
+                query: '',
+                limit,
+                scope,
+                json,
+                error: { key: 'search.error.invalidScope', params: { scope: rawScope } },
+            };
         }
-        queryParts.push(arg);
+        scope = rawScope;
     }
-    const query = queryParts.join(' ').trim();
+    const query = parsed.positionals.join(' ').trim();
     if (query.length === 0) {
         return { query, limit, scope, json, error: { key: 'search.error.missingQuery' } };
     }
@@ -140,7 +114,7 @@ function renderSearchSummary(result, lang) {
     return lines.join('\n');
 }
 export async function runSearch(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getSearchHelp(lang));
         return 0;
     }

package/dist/cli/commands/status.js

@@ -3,7 +3,11 @@ 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 { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
+const STATUS_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+];
 export function getStatusHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf status [options]',
@@ -36,19 +40,18 @@ function getStatusSnapshot(projectRoot) {
     };
 }
 export function runStatus(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-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);
+    const options = parseCliOptions(args, STATUS_OPTIONS);
+    if (options.error) {
+        printUsageError(reporter, formatCliOptionParseError(options.error, lang), 'mf status --help', getStatusHelp(lang), lang);
         return 1;
     }
     const projectRoot = resolveMustflowRoot();
     const status = getStatusSnapshot(projectRoot);
-    if (args.includes('--json')) {
+    if (hasParsedCliOption(options, '--json')) {
         reporter.stdout(JSON.stringify(status, null, 2));
         return 0;
     }

package/dist/cli/commands/update.js

@@ -5,12 +5,19 @@ import { copyFileInsideWithoutSymlinks, ensureFileTargetInsideWithoutSymlinks, e
 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 { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 import { getDefaultTemplate, getTemplateFiles, skillNameForTemplatePath } from '../lib/templates.js';
 import { readMustflowTomlFile, stringifyToml } from '../lib/toml.js';
 import { createUpdateDiffPreview, shouldPreviewUpdateDiff } from '../lib/update-diff-preview.js';
 const UPDATE_SCHEMA_VERSION = '1';
 const CUSTOMIZED_LOCK_ACTION = 'customized';
+const UPDATE_OPTIONS = [
+    { name: '--dry-run', kind: 'boolean' },
+    { name: '--apply', kind: 'boolean' },
+    { name: '--json', kind: 'boolean' },
+    { name: '--diff', kind: 'boolean' },
+];
 const UPDATE_POLICY = {
     baseline: 'manifest_lock_content_hash',
     allowed_apply_actions: ['update', 'create'],
@@ -381,21 +388,20 @@ function printDiffPreviews(items, reporter, lang) {
     }
 }
 export function runUpdate(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getUpdateHelp(lang));
         return 0;
     }
-    const supported = new Set(['--dry-run', '--apply', '--json', '--diff']);
-    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 wantsDiff = args.includes('--diff');
-    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);
+    const parsed = parseCliOptions(args, UPDATE_OPTIONS);
+    if (parsed.error) {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf update --help', getUpdateHelp(lang), lang);
         return 1;
     }
+    const wantsJson = hasParsedCliOption(parsed, '--json');
+    const wantsDryRun = hasParsedCliOption(parsed, '--dry-run');
+    const wantsApply = hasParsedCliOption(parsed, '--apply');
+    const wantsDiff = hasParsedCliOption(parsed, '--diff');
+    const requestedMode = getRequestedMode(wantsDryRun, wantsApply);
     if (wantsDryRun && wantsApply) {
         const error = t(lang, 'update.error.cannotCombineModes');
         if (wantsJson) {

package/dist/cli/commands/upgrade.js

@@ -1,8 +1,12 @@
 import { printUsageError, renderCliError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
 import { checkNpmLatestVersion } from '../lib/npm-version-check.js';
+import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { readPackageMetadata } from '../lib/package-info.js';
 import { runUpdate } from './update.js';
+const UPGRADE_OPTIONS = [
+    { name: '--dry-run', kind: 'boolean' },
+];
 export function getUpgradeHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf upgrade [options]',
@@ -32,17 +36,16 @@ function printPackageCheck(check, reporter, lang) {
     }
 }
 export async function runUpgrade(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getUpgradeHelp(lang));
         return 0;
     }
-    const supported = new Set(['--dry-run']);
-    const unsupported = args.filter((arg) => !supported.has(arg));
-    if (unsupported.length > 0) {
-        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf upgrade --help', getUpgradeHelp(lang), lang);
+    const options = parseCliOptions(args, UPGRADE_OPTIONS);
+    if (options.error) {
+        printUsageError(reporter, formatCliOptionParseError(options.error, lang), 'mf upgrade --help', getUpgradeHelp(lang), lang);
         return 1;
     }
-    const dryRun = args.includes('--dry-run');
+    const dryRun = hasParsedCliOption(options, '--dry-run');
     reporter.stdout(t(lang, 'upgrade.title'));
     reporter.stdout('');
     reporter.stdout(t(lang, 'upgrade.packageSection'));