mustflow 2.23.0 → 2.24.2

package/dist/cli/commands/verify/args.js

@@ -1,264 +1,70 @@
 import { availableParallelism } from 'node:os';
+import { getParsedCliStringOption, hasParsedCliOption, parseCliOptions, } from '../../lib/option-parser.js';
 export const DEFAULT_VERIFY_PARALLELISM = 1;
 export const MAX_VERIFY_PARALLELISM = 8;
+const VERIFY_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--plan-only', kind: 'boolean' },
+    { name: '--changed', kind: 'boolean' },
+    { name: '--reason', kind: 'string' },
+    { name: '--parallel', kind: 'string' },
+    { name: '--from-classification', kind: 'string' },
+    { name: '--from-plan', kind: 'string' },
+    { name: '--write-plan', kind: 'string' },
+    { name: '--external-evidence', kind: 'string' },
+    { name: '--repro-evidence', kind: 'string' },
+];
+const VERIFY_MISSING_VALUE_ERRORS = new Map([
+    ['--parallel', 'missing_parallel_value'],
+    ['--reason', 'missing_reason_value'],
+    ['--from-plan', 'missing_from_plan_value'],
+    ['--from-classification', 'missing_from_classification_value'],
+    ['--write-plan', 'missing_write_plan_value'],
+    ['--external-evidence', 'missing_external_evidence_value'],
+    ['--repro-evidence', 'missing_repro_evidence_value'],
+]);
 export function parseVerifyArgs(args) {
-    let reason;
-    let fromClassification;
-    let fromPlan;
-    let writePlan;
-    let reproEvidence;
-    let externalEvidence;
-    let json = false;
-    let planOnly = false;
-    let changed = false;
+    const parsed = parseCliOptions(args, VERIFY_OPTIONS);
+    const base = createParsedVerifyArgsBase(parsed);
     let parallelism = DEFAULT_VERIFY_PARALLELISM;
     let parallelismSpecified = false;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === '--json') {
-            json = true;
-            continue;
-        }
-        if (arg === '--plan-only') {
-            planOnly = true;
-            continue;
-        }
-        if (arg === '--changed') {
-            changed = true;
-            continue;
-        }
-        if (arg === '--parallel') {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                return { json, planOnly, changed, reason, parallelism, error: 'missing_parallel_value' };
-            }
-            const parsedParallelism = parseVerifyParallelism(value);
-            if (parsedParallelism === null) {
-                return { json, planOnly, changed, reason, parallelism, error: 'invalid_parallel_value' };
-            }
-            parallelism = parsedParallelism;
-            parallelismSpecified = true;
-            index += 1;
-            continue;
-        }
-        if (arg === '--reason') {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                return { json, planOnly, changed, reason, error: 'missing_reason_value' };
-            }
-            reason = value;
-            index += 1;
-            continue;
-        }
-        if (arg === '--from-plan') {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                return { json, planOnly, changed, reason, fromClassification, fromPlan, error: 'missing_from_plan_value' };
-            }
-            fromPlan = value;
-            index += 1;
-            continue;
-        }
-        if (arg === '--from-classification') {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                return {
-                    json,
-                    planOnly,
-                    changed,
-                    reason,
-                    fromClassification,
-                    fromPlan,
-                    error: 'missing_from_classification_value',
-                };
-            }
-            fromClassification = value;
-            index += 1;
-            continue;
-        }
-        if (arg === '--write-plan') {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                return {
-                    json,
-                    planOnly,
-                    changed,
-                    reason,
-                    fromClassification,
-                    fromPlan,
-                    writePlan,
-                    error: 'missing_write_plan_value',
-                };
-            }
-            writePlan = value;
-            index += 1;
-            continue;
-        }
-        if (arg === '--external-evidence') {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                return {
-                    json,
-                    planOnly,
-                    changed,
-                    reason,
-                    fromClassification,
-                    fromPlan,
-                    writePlan,
-                    externalEvidence,
-                    error: 'missing_external_evidence_value',
-                };
-            }
-            externalEvidence = value;
-            index += 1;
-            continue;
-        }
-        if (arg === '--repro-evidence') {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                return {
-                    json,
-                    planOnly,
-                    changed,
-                    reason,
-                    fromClassification,
-                    fromPlan,
-                    writePlan,
-                    reproEvidence,
-                    externalEvidence,
-                    error: 'missing_repro_evidence_value',
-                };
-            }
-            reproEvidence = value;
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith('--reason=')) {
-            const value = arg.slice('--reason='.length);
-            if (value.length === 0) {
-                return { json, planOnly, changed, reason, error: 'missing_reason_value' };
-            }
-            reason = value;
-            continue;
-        }
-        if (arg.startsWith('--parallel=')) {
-            const value = arg.slice('--parallel='.length);
-            const parsedParallelism = parseVerifyParallelism(value);
-            if (parsedParallelism === null) {
-                return { json, planOnly, changed, reason, parallelism, error: 'invalid_parallel_value' };
-            }
-            parallelism = parsedParallelism;
-            parallelismSpecified = true;
-            continue;
-        }
-        if (arg.startsWith('--from-plan=')) {
-            const value = arg.slice('--from-plan='.length);
-            if (value.length === 0) {
-                return { json, planOnly, changed, reason, fromClassification, fromPlan, error: 'missing_from_plan_value' };
-            }
-            fromPlan = value;
-            continue;
-        }
-        if (arg.startsWith('--from-classification=')) {
-            const value = arg.slice('--from-classification='.length);
-            if (value.length === 0) {
-                return {
-                    json,
-                    planOnly,
-                    changed,
-                    reason,
-                    fromClassification,
-                    fromPlan,
-                    error: 'missing_from_classification_value',
-                };
-            }
-            fromClassification = value;
-            continue;
-        }
-        if (arg.startsWith('--write-plan=')) {
-            const value = arg.slice('--write-plan='.length);
-            if (value.length === 0) {
-                return {
-                    json,
-                    planOnly,
-                    changed,
-                    reason,
-                    fromClassification,
-                    fromPlan,
-                    writePlan,
-                    error: 'missing_write_plan_value',
-                };
-            }
-            writePlan = value;
-            continue;
-        }
-        if (arg.startsWith('--external-evidence=')) {
-            const value = arg.slice('--external-evidence='.length);
-            if (value.length === 0) {
-                return {
-                    json,
-                    planOnly,
-                    changed,
-                    reason,
-                    fromClassification,
-                    fromPlan,
-                    writePlan,
-                    externalEvidence,
-                    error: 'missing_external_evidence_value',
-                };
-            }
-            externalEvidence = value;
-            continue;
-        }
-        if (arg.startsWith('--repro-evidence=')) {
-            const value = arg.slice('--repro-evidence='.length);
-            if (value.length === 0) {
-                return {
-                    json,
-                    planOnly,
-                    changed,
-                    reason,
-                    fromClassification,
-                    fromPlan,
-                    writePlan,
-                    reproEvidence,
-                    externalEvidence,
-                    error: 'missing_repro_evidence_value',
-                };
-            }
-            reproEvidence = value;
-            continue;
-        }
-        if (arg.startsWith('-')) {
-            return { json, planOnly, changed, reason, fromClassification, fromPlan, writePlan, reproEvidence, externalEvidence, error: arg };
-        }
-        return {
-            json,
-            planOnly,
-            changed,
-            reason,
-            fromClassification,
-            fromPlan,
-            writePlan,
-            reproEvidence,
-            externalEvidence,
-            error: `unexpected:${arg}`,
-        };
+    if (parsed.error) {
+        return { ...base, parallelism, parallelismSpecified, error: mapVerifyOptionParseError(parsed.error) };
+    }
+    const parallelValue = getParsedCliStringOption(parsed, '--parallel');
+    if (parallelValue !== null) {
+        const parsedParallelism = parseVerifyParallelism(parallelValue);
+        if (parsedParallelism === null) {
+            return { ...base, parallelism, parallelismSpecified, error: 'invalid_parallel_value' };
+        }
+        parallelism = parsedParallelism;
+        parallelismSpecified = true;
     }
     return {
-        json,
-        planOnly,
-        changed,
-        reason,
-        fromClassification,
-        fromPlan,
-        writePlan,
-        reproEvidence,
-        externalEvidence,
+        ...base,
         parallelism,
         parallelismSpecified,
     };
 }
+function createParsedVerifyArgsBase(parsed) {
+    return {
+        json: hasParsedCliOption(parsed, '--json'),
+        planOnly: hasParsedCliOption(parsed, '--plan-only'),
+        changed: hasParsedCliOption(parsed, '--changed'),
+        reason: getParsedCliStringOption(parsed, '--reason') ?? undefined,
+        fromClassification: getParsedCliStringOption(parsed, '--from-classification') ?? undefined,
+        fromPlan: getParsedCliStringOption(parsed, '--from-plan') ?? undefined,
+        writePlan: getParsedCliStringOption(parsed, '--write-plan') ?? undefined,
+        reproEvidence: getParsedCliStringOption(parsed, '--repro-evidence') ?? undefined,
+        externalEvidence: getParsedCliStringOption(parsed, '--external-evidence') ?? undefined,
+    };
+}
+function mapVerifyOptionParseError(error) {
+    if (error.kind === 'missing_value') {
+        return VERIFY_MISSING_VALUE_ERRORS.get(error.option) ?? error.option;
+    }
+    return error.option.startsWith('-') ? error.option : `unexpected:${error.option}`;
+}
 function parseVerifyParallelism(value) {
     if (!/^[1-9][0-9]*$/u.test(value)) {
         return null;

package/dist/cli/commands/verify.js

@@ -22,6 +22,7 @@ import { createVerifyIntentReceiptPath, createVerifyRunStatePaths, resolveLatest
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
 import { readLocalCommandEffectGraphs, readLocalPathSurfaces, readLocalSourceAnchorVerdictRisks, } from '../lib/local-index.js';
+import { hasCliOptionToken } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 export { planErrorMessageKey, readInputFromClassificationReport } from './verify/input.js';
 const VERIFY_SCHEMA_VERSION = '1';
@@ -910,7 +911,7 @@ function renderVerifyOutput(output, lang) {
     return lines.join('\n');
 }
 export async function runVerify(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getVerifyHelp(lang));
         return 0;
     }

package/dist/cli/commands/version-sources.js

@@ -1,10 +1,14 @@
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { isRecord } from '../lib/command-contract.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';
 import { detectVersionSources, releaseVersioningIsEnabled, } from '../../core/version-sources.js';
 const VERSION_SOURCES_SCHEMA_VERSION = '1';
+const VERSION_SOURCES_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+];
 export function getVersionSourcesHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf version-sources [options]',
@@ -58,18 +62,17 @@ function renderVersionSources(output, lang) {
     return lines.join('\n');
 }
 export function runVersionSources(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getVersionSourcesHelp(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 version-sources --help', getVersionSourcesHelp(lang), lang);
+    const options = parseCliOptions(args, VERSION_SOURCES_OPTIONS);
+    if (options.error) {
+        printUsageError(reporter, formatCliOptionParseError(options.error, lang), 'mf version-sources --help', getVersionSourcesHelp(lang), lang);
         return 1;
     }
     const output = getVersionSourcesOutput(resolveMustflowRoot());
-    if (args.includes('--json')) {
+    if (hasParsedCliOption(options, '--json')) {
         reporter.stdout(JSON.stringify(output, null, 2));
         return 0;
     }

package/dist/cli/commands/version.js

@@ -1,7 +1,11 @@
 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';
+const VERSION_OPTIONS = [
+    { name: '--check', kind: 'boolean' },
+];
 export function getVersionHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf version [options]',
@@ -30,18 +34,17 @@ function renderVersionCheck(check, lang) {
     return lines.join('\n');
 }
 export async function runVersion(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getVersionHelp(lang));
         return 0;
     }
-    const supported = new Set(['--check']);
-    const unsupported = args.filter((arg) => !supported.has(arg));
-    if (unsupported.length > 0) {
-        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf version --help', getVersionHelp(lang), lang);
+    const options = parseCliOptions(args, VERSION_OPTIONS);
+    if (options.error) {
+        printUsageError(reporter, formatCliOptionParseError(options.error, lang), 'mf version --help', getVersionHelp(lang), lang);
         return 1;
     }
     const metadata = readPackageMetadata();
-    if (!args.includes('--check')) {
+    if (!hasParsedCliOption(options, '--check')) {
         reporter.stdout(metadata.version);
         return 0;
     }