mustflow 2.23.0 → 2.25.0

package/dist/cli/commands/classify.js

@@ -5,8 +5,14 @@ import { writeJsonFileInsideWithoutSymlinks } from '../../core/safe-filesystem.j
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { requireGitChangedFiles } from '../lib/git-changes.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';
 const CLASSIFY_SCHEMA_VERSION = '1';
+const CLASSIFY_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--changed', kind: 'boolean' },
+    { name: '--write', kind: 'string' },
+];
 export function getClassifyHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf classify --changed [options] | mf classify <path...> [options]',
@@ -29,43 +35,14 @@ export function getClassifyHelp(lang = 'en') {
     }, lang);
 }
 function parseClassifyArgs(args) {
-    const paths = [];
-    let json = false;
-    let changed = false;
-    let writePath;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === '--json') {
-            json = true;
-            continue;
-        }
-        if (arg === '--changed') {
-            changed = true;
-            continue;
-        }
-        if (arg === '--write') {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                return { json, changed, writePath, paths, error: 'missing_write_value' };
-            }
-            writePath = value;
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith('--write=')) {
-            const value = arg.slice('--write='.length);
-            if (value.length === 0) {
-                return { json, changed, writePath, paths, error: 'missing_write_value' };
-            }
-            writePath = value;
-            continue;
-        }
-        if (arg.startsWith('-')) {
-            return { json, changed, writePath, paths, error: arg };
-        }
-        paths.push(arg);
-    }
-    return { json, changed, writePath, paths };
+    const parsed = parseCliOptions(args, CLASSIFY_OPTIONS, { allowPositionals: true });
+    return {
+        json: hasParsedCliOption(parsed, '--json'),
+        changed: hasParsedCliOption(parsed, '--changed'),
+        writePath: getParsedCliStringOption(parsed, '--write'),
+        paths: parsed.positionals,
+        error: parsed.error,
+    };
 }
 export function createClassifyOutput(projectRoot, source, paths) {
     const files = source === 'changed' ? requireGitChangedFiles(projectRoot) : paths;
@@ -116,16 +93,13 @@ function writeClassifyOutput(projectRoot, inputPath, output) {
     writeJsonFileInsideWithoutSymlinks(projectRoot, outputPath, output);
 }
 export function runClassify(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getClassifyHelp(lang));
         return 0;
     }
     const parsed = parseClassifyArgs(args);
     if (parsed.error) {
-        const message = parsed.error === 'missing_write_value'
-            ? t(lang, 'cli.error.missingValue', { option: '--write' })
-            : t(lang, 'cli.error.unknownOption', { option: parsed.error });
-        printUsageError(reporter, message, 'mf classify --help', getClassifyHelp(lang), lang);
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf classify --help', getClassifyHelp(lang), lang);
         return 1;
     }
     if (parsed.changed && parsed.paths.length > 0) {

package/dist/cli/commands/context.js

@@ -1,6 +1,7 @@
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { getAgentContext, getPromptCacheProfileContext } from '../lib/agent-context.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';
 export function getContextHelp(lang = 'en') {
     return renderHelp({
@@ -27,55 +28,41 @@ export function getContextHelp(lang = 'en') {
         ],
     }, lang);
 }
+const CONTEXT_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--cache-profile', kind: 'string' },
+];
 const CACHE_PROFILES = new Set(['stable', 'task', 'volatile', 'all']);
-function parseCacheProfile(args) {
-    const index = args.indexOf('--cache-profile');
-    if (index === -1) {
-        return { profile: null, error: null };
-    }
-    const value = args[index + 1];
-    if (!value || value.startsWith('-')) {
-        return { profile: null, error: 'missing' };
+function parseCacheProfile(value) {
+    if (value === null) {
+        return { profile: null, invalid: false };
     }
     if (!CACHE_PROFILES.has(value)) {
-        return { profile: null, error: value };
+        return { profile: null, invalid: true };
     }
-    return { profile: value, error: null };
+    return { profile: value, invalid: false };
 }
 export async function runContext(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getContextHelp(lang));
         return 0;
     }
-    const supported = new Set(['--json', '--cache-profile']);
-    const cacheProfile = parseCacheProfile(args);
-    const unsupported = args.filter((arg, index) => {
-        if (arg === '--cache-profile') {
-            return false;
-        }
-        if (index > 0 && args[index - 1] === '--cache-profile') {
-            return false;
-        }
-        return !supported.has(arg);
-    });
-    if (unsupported.length > 0) {
-        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf context --help', getContextHelp(lang), lang);
-        return 1;
-    }
-    if (cacheProfile.error === 'missing') {
-        printUsageError(reporter, t(lang, 'cli.error.missingValue', { option: '--cache-profile' }), 'mf context --help', getContextHelp(lang), lang);
+    const parsed = parseCliOptions(args, CONTEXT_OPTIONS);
+    if (parsed.error) {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf context --help', getContextHelp(lang), lang);
         return 1;
     }
-    if (cacheProfile.error) {
+    const cacheProfile = parseCacheProfile(getParsedCliStringOption(parsed, '--cache-profile'));
+    if (cacheProfile.invalid) {
         printUsageError(reporter, t(lang, 'cli.error.unexpectedValue', { option: '--cache-profile' }), 'mf context --help', getContextHelp(lang), lang);
         return 1;
     }
-    if (cacheProfile.profile && !args.includes('--json')) {
+    if (cacheProfile.profile && !hasParsedCliOption(parsed, '--json')) {
         printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: '--cache-profile' }), 'mf context --help', getContextHelp(lang), lang);
         return 1;
     }
     const mustflowRoot = resolveMustflowRoot();
-    if (args.includes('--json')) {
+    if (hasParsedCliOption(parsed, '--json')) {
         if (cacheProfile.profile) {
             reporter.stdout(JSON.stringify(await getPromptCacheProfileContext(mustflowRoot, cacheProfile.profile), null, 2));
             return 0;

package/dist/cli/commands/contract-lint.js

@@ -5,9 +5,15 @@ import { readCommandContract, isRecord } 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 CONTRACT_LINT_SCHEMA_VERSION = '1';
+const CONTRACT_LINT_OPTIONS = [
+    { name: '--coverage', kind: 'boolean' },
+    { name: '--suggest', kind: 'boolean' },
+    { name: '--json', kind: 'boolean' },
+];
 export function getContractLintHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf contract-lint [options]',
@@ -82,18 +88,17 @@ function renderContractLintOutput(output, lang) {
     return lines.join('\n');
 }
 export function runContractLint(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getContractLintHelp(lang));
         return 0;
     }
-    const supported = new Set(['--coverage', '--suggest', '--json']);
-    const unsupported = args.filter((arg) => !supported.has(arg));
-    if (unsupported.length > 0) {
-        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf contract-lint --help', getContractLintHelp(lang), lang);
+    const options = parseCliOptions(args, CONTRACT_LINT_OPTIONS);
+    if (options.error) {
+        printUsageError(reporter, formatCliOptionParseError(options.error, lang), 'mf contract-lint --help', getContractLintHelp(lang), lang);
         return 1;
     }
-    const output = createContractLintOutput(resolveMustflowRoot(), args.includes('--coverage'), args.includes('--suggest'));
-    if (args.includes('--json')) {
+    const output = createContractLintOutput(resolveMustflowRoot(), hasParsedCliOption(options, '--coverage'), hasParsedCliOption(options, '--suggest'));
+    if (hasParsedCliOption(options, '--json')) {
         reporter.stdout(JSON.stringify(output, null, 2));
     }
     else {

package/dist/cli/commands/dashboard.js

@@ -4,6 +4,7 @@ import http from 'node:http';
 import path from 'node:path';
 import { openUrlInBrowser } from '../lib/browser-open.js';
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
+import { formatCliOptionParseError, getParsedCliStringOption, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { renderDashboardHtml, } from '../lib/dashboard-html.js';
 import { DashboardExportPathError, writeDashboardExport, } from '../lib/dashboard-export.js';
 import { DASHBOARD_VERIFICATION_MAX_FILE_MATCHES, createDashboardVerificationSnapshot, } from '../../core/dashboard-verification.js';
@@ -18,6 +19,7 @@ import { markDashboardDocReviewFromPayload, openDashboardMustflowFolder, updateD
 import { MANIFEST_LOCK_RELATIVE_PATH, inspectManifestLock } from '../lib/manifest-lock.js';
 import { getLocalIndexDatabasePath, readLatestLocalVerificationReadModelQueries, readLocalCommandEffectGraphs, } from '../lib/local-index.js';
 import { readPackageMetadata } from '../lib/package-info.js';
+import { createRunPlan } from '../lib/run-plan.js';
 import { t } from '../lib/i18n.js';
 import { MUSTFLOW_JSON_MAX_BYTES, readMustflowTextFile, readMustflowTextFileIfExists, } from '../lib/mustflow-read.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
@@ -27,6 +29,16 @@ const DEFAULT_DASHBOARD_HOST = '127.0.0.1';
 const DEFAULT_DASHBOARD_PORT = 0;
 const MAX_REQUEST_BYTES = 64 * 1024;
 const LOCAL_DASHBOARD_HOSTS = new Set(['127.0.0.1', 'localhost', '::1']);
+const DASHBOARD_OPTIONS = [
+    { name: '--host', kind: 'string' },
+    { name: '--port', kind: 'string' },
+    { name: '--open', kind: 'boolean' },
+    { name: '--no-open', kind: 'boolean' },
+    { name: '--json', kind: 'boolean' },
+    { name: '--export', kind: 'string' },
+    { name: '--export-json', kind: 'string' },
+    { name: '--help', kind: 'boolean', aliases: ['-h'] },
+];
 const RELEASE_FILE_PATTERNS = [
     /^package\.json$/u,
     /^bun\.lockb?$/u,
@@ -168,112 +180,34 @@ export function getDashboardHelp(lang = 'en') {
     }, lang);
 }
 function parseDashboardOptions(args, lang) {
-    let host = DEFAULT_DASHBOARD_HOST;
+    const parsed = parseCliOptions(args, DASHBOARD_OPTIONS);
+    if (parsed.error) {
+        return { error: formatCliOptionParseError(parsed.error, lang) };
+    }
+    const host = getParsedCliStringOption(parsed, '--host') ?? DEFAULT_DASHBOARD_HOST;
     let port = DEFAULT_DASHBOARD_PORT;
-    let json = false;
-    let openBrowser = false;
-    let exportPath;
-    let exportFormat;
-    let serverOptionUsed = false;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (!arg) {
-            continue;
-        }
-        if (arg === '--json') {
-            json = true;
-            openBrowser = false;
-            serverOptionUsed = true;
-            continue;
-        }
-        if (arg === '--open') {
-            openBrowser = true;
-            serverOptionUsed = true;
-            continue;
-        }
-        if (arg === '--no-open') {
-            openBrowser = false;
-            serverOptionUsed = true;
-            continue;
-        }
-        if (arg === '--host') {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                return { error: t(lang, 'cli.error.missingValue', { option: '--host' }) };
-            }
-            host = value;
-            serverOptionUsed = true;
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith('--host=')) {
-            host = arg.slice('--host='.length);
-            serverOptionUsed = true;
-            continue;
-        }
-        if (arg === '--port') {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                return { error: t(lang, 'cli.error.missingValue', { option: '--port' }) };
-            }
-            const parsedPort = Number(value);
-            if (!Number.isInteger(parsedPort) || parsedPort < 0 || parsedPort > 65_535) {
-                return { error: t(lang, 'dashboard.error.invalidPort', { port: value }) };
-            }
-            port = parsedPort;
-            serverOptionUsed = true;
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith('--port=')) {
-            const value = arg.slice('--port='.length);
-            const parsedPort = Number(value);
-            if (!Number.isInteger(parsedPort) || parsedPort < 0 || parsedPort > 65_535) {
-                return { error: t(lang, 'dashboard.error.invalidPort', { port: value }) };
-            }
-            port = parsedPort;
-            serverOptionUsed = true;
-            continue;
+    const portValue = getParsedCliStringOption(parsed, '--port');
+    if (portValue !== null) {
+        const parsedPort = Number(portValue);
+        if (!Number.isInteger(parsedPort) || parsedPort < 0 || parsedPort > 65_535) {
+            return { error: t(lang, 'dashboard.error.invalidPort', { port: portValue }) };
         }
-        if (arg === '--export' || arg === '--export-json') {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                return { error: t(lang, 'cli.error.missingValue', { option: arg }) };
-            }
-            if (exportPath) {
-                return { error: t(lang, 'dashboard.error.conflictingExportModes') };
-            }
-            exportPath = value;
-            exportFormat = arg === '--export-json' ? 'json' : 'html';
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith('--export=')) {
-            if (exportPath) {
-                return { error: t(lang, 'dashboard.error.conflictingExportModes') };
-            }
-            exportPath = arg.slice('--export='.length);
-            exportFormat = 'html';
-            if (!exportPath) {
-                return { error: t(lang, 'cli.error.missingValue', { option: '--export' }) };
-            }
-            continue;
-        }
-        if (arg.startsWith('--export-json=')) {
-            if (exportPath) {
-                return { error: t(lang, 'dashboard.error.conflictingExportModes') };
-            }
-            exportPath = arg.slice('--export-json='.length);
-            exportFormat = 'json';
-            if (!exportPath) {
-                return { error: t(lang, 'cli.error.missingValue', { option: '--export-json' }) };
-            }
-            continue;
-        }
-        if (arg.startsWith('-')) {
-            return { error: t(lang, 'cli.error.unknownOption', { option: arg }) };
-        }
-        return { error: t(lang, 'cli.error.unexpectedArgument', { argument: arg }) };
+        port = parsedPort;
+    }
+    const json = hasParsedCliOption(parsed, '--json');
+    const lastOpenOption = lastOptionTokenName(args, ['--open', '--no-open']);
+    const openBrowser = lastOpenOption === '--open' && !json;
+    const serverOptionUsed = hasParsedCliOption(parsed, '--json')
+        || hasParsedCliOption(parsed, '--open')
+        || hasParsedCliOption(parsed, '--no-open')
+        || getParsedCliStringOption(parsed, '--host') !== null
+        || portValue !== null;
+    const htmlExportPath = getParsedCliStringOption(parsed, '--export');
+    const jsonExportPath = getParsedCliStringOption(parsed, '--export-json');
+    const exportPath = htmlExportPath ?? jsonExportPath ?? undefined;
+    const exportFormat = jsonExportPath !== null ? 'json' : htmlExportPath !== null ? 'html' : undefined;
+    if (countOptionTokens(args, ['--export', '--export-json']) > 1) {
+        return { error: t(lang, 'dashboard.error.conflictingExportModes') };
     }
     if (exportPath && serverOptionUsed) {
         return { error: t(lang, 'dashboard.error.exportServerOptions') };
@@ -284,11 +218,33 @@ function parseDashboardOptions(args, lang) {
     if (!LOCAL_DASHBOARD_HOSTS.has(host)) {
         return { error: t(lang, 'dashboard.error.nonLocalHost', { host }) };
     }
-    if (json) {
-        openBrowser = false;
-    }
     return { options: { host, port, json, openBrowser } };
 }
+function countOptionTokens(args, names) {
+    const nameSet = new Set(names);
+    let count = 0;
+    for (const arg of args) {
+        if (nameSet.has(optionTokenName(arg))) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function lastOptionTokenName(args, names) {
+    const nameSet = new Set(names);
+    let lastName = null;
+    for (const arg of args) {
+        const name = optionTokenName(arg);
+        if (nameSet.has(name)) {
+            lastName = name;
+        }
+    }
+    return lastName;
+}
+function optionTokenName(arg) {
+    const separatorIndex = arg.indexOf('=');
+    return separatorIndex === -1 ? arg : arg.slice(0, separatorIndex);
+}
 function sendJson(response, statusCode, value) {
     response.writeHead(statusCode, {
         'cache-control': 'no-store',
@@ -510,12 +466,7 @@ async function renderCommandContractResponse(projectRoot, contract) {
         const runPolicy = readString(intent, 'run_policy') ?? null;
         const stdin = readString(intent, 'stdin') ?? null;
         const timeoutSeconds = readPositiveInteger(intent, 'timeout_seconds') ?? null;
-        const runnable = status === 'configured' &&
-            lifecycle === 'oneshot' &&
-            runPolicy === 'agent_allowed' &&
-            stdin === 'closed' &&
-            timeoutSeconds !== null &&
-            (readStringArray(intent, 'argv') !== undefined || readString(intent, 'cmd') !== undefined);
+        const runnable = createRunPlan(projectRoot, contract, name).ok;
         return [
             {
                 name,
@@ -753,7 +704,7 @@ function toDashboardUrl(host, port) {
     return `http://${formattedHost}:${port}/`;
 }
 export async function runDashboard(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getDashboardHelp(lang));
         return 0;
     }

package/dist/cli/commands/docs.js

@@ -4,6 +4,7 @@ import { printUsageError, renderCliError, renderHelp } from '../lib/cli-output.j
 import { DOC_REVIEW_LEDGER_RELATIVE_PATH, DOC_REVIEW_STATUSES, REVIEWER_KINDS, addDocReviewEntry, commentDocReviewEntry, isReviewerKind, listDocReviewEntries, markDocReviewEntry, } from '../lib/doc-review-ledger.js';
 import { ensureInside, readUtf8FileInsideWithoutSymlinks } from '../lib/filesystem.js';
 import { t } from '../lib/i18n.js';
+import { getParsedCliStringOption, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 const LIST_FLAGS = new Set(['--json', '--all']);
 const LIST_VALUE_OPTIONS = new Set(['--status']);
@@ -50,35 +51,51 @@ export function getDocsHelp(lang = 'en') {
     }, lang);
 }
 function parseOptions(args, valueOptions, flags) {
+    const specs = createDocsOptionSpecs(valueOptions, flags);
+    const parsed = parseCliOptions(args, specs, { allowPositionals: true });
+    const values = parsedDocsValues(parsed, valueOptions);
+    const parsedFlags = parsedDocsFlags(parsed, flags);
+    if (parsed.error) {
+        return {
+            values,
+            flags: parsedFlags,
+            positionals: parsed.positionals,
+            error: {
+                option: parsed.error.option,
+                missingValue: parsed.error.kind === 'missing_value',
+            },
+        };
+    }
+    return { values, flags: parsedFlags, positionals: parsed.positionals };
+}
+function createDocsOptionSpecs(valueOptions, flags) {
+    const specs = new Map();
+    for (const option of valueOptions) {
+        specs.set(option, 'string');
+    }
+    for (const flag of flags) {
+        specs.set(flag, 'boolean');
+    }
+    return [...specs.entries()].map(([name, kind]) => ({ name, kind }));
+}
+function parsedDocsValues(parsed, valueOptions) {
     const values = new Map();
-    const parsedFlags = new Set();
-    const positionals = [];
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (flags.has(arg)) {
-            parsedFlags.add(arg);
-            continue;
-        }
-        const equalsIndex = arg.indexOf('=');
-        const optionName = equalsIndex > -1 ? arg.slice(0, equalsIndex) : arg;
-        if (valueOptions.has(optionName)) {
-            const inlineValue = equalsIndex > -1 ? arg.slice(equalsIndex + 1) : undefined;
-            const nextValue = inlineValue ?? args[index + 1];
-            if (!nextValue || (!inlineValue && nextValue.startsWith('-'))) {
-                return { values, flags: parsedFlags, positionals, error: { option: optionName, missingValue: true } };
-            }
-            values.set(optionName, nextValue);
-            if (inlineValue === undefined) {
-                index += 1;
-            }
-            continue;
+    for (const option of valueOptions) {
+        const value = getParsedCliStringOption(parsed, option);
+        if (value !== null) {
+            values.set(option, value);
         }
-        if (arg.startsWith('-')) {
-            return { values, flags: parsedFlags, positionals, error: { option: arg } };
+    }
+    return values;
+}
+function parsedDocsFlags(parsed, flags) {
+    const parsedFlags = new Set();
+    for (const flag of flags) {
+        if (hasParsedCliOption(parsed, flag)) {
+            parsedFlags.add(flag);
         }
-        positionals.push(arg);
     }
-    return { values, flags: parsedFlags, positionals };
+    return parsedFlags;
 }
 function parseStatus(value) {
     if (value === undefined) {
@@ -352,7 +369,7 @@ function runReviewMark(args, status, reporter, lang) {
     }
 }
 export function runDocs(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getDocsHelp(lang));
         return 0;
     }

package/dist/cli/commands/doctor.js

@@ -4,12 +4,17 @@ import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { getAgentContext, } from '../lib/agent-context.js';
 import { t } from '../lib/i18n.js';
 import { getLocalIndexDatabasePath } from '../lib/local-index.js';
+import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 import { checkMustflowProjectReport } from '../lib/validation.js';
 import { findCommandEnvInheritanceWarnings } from '../../core/command-contract-validation.js';
 import { readCommandContract } from '../../core/config-loading.js';
 import { summarizeSkillRouteAlignment } from '../../core/skill-route-alignment.js';
 const DOCTOR_SCHEMA_VERSION = '1';
+const DOCTOR_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--strict', kind: 'boolean' },
+];
 export function getDoctorHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf doctor [options]',
@@ -264,18 +269,17 @@ function renderDoctorOutput(output, lang) {
     return lines.join('\n');
 }
 export function runDoctor(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getDoctorHelp(lang));
         return 0;
     }
-    const supported = new Set(['--json', '--strict']);
-    const unsupported = args.filter((arg) => !supported.has(arg));
-    if (unsupported.length > 0) {
-        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf doctor --help', getDoctorHelp(lang), lang);
+    const options = parseCliOptions(args, DOCTOR_OPTIONS);
+    if (options.error) {
+        printUsageError(reporter, formatCliOptionParseError(options.error, lang), 'mf doctor --help', getDoctorHelp(lang), lang);
         return 1;
     }
-    const output = createDoctorOutput(args.includes('--strict'));
-    if (args.includes('--json')) {
+    const output = createDoctorOutput(hasParsedCliOption(options, '--strict'));
+    if (hasParsedCliOption(options, '--json')) {
         reporter.stdout(JSON.stringify(output, null, 2));
         return output.ok ? 0 : 1;
     }