mustflow 2.23.0 → 2.24.2

package/dist/cli/commands/explain-verify.js

@@ -6,64 +6,6 @@ import { createVerificationSchedule } from '../../core/verification-scheduler.js
 import { t } from '../lib/i18n.js';
 import { readLatestLocalVerificationReadModelQueries, readLocalCommandEffectGraphs, } from '../lib/local-index.js';
 import { planErrorMessageKey, readInputFromClassificationReport } from './verify.js';
-export function parseExplainVerifyArgs(args) {
-    let reason;
-    let fromPlan;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === '--reason') {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                return { reason, fromPlan, error: 'missing_reason_value' };
-            }
-            reason = value;
-            index += 1;
-            continue;
-        }
-        if (arg === '--from-plan') {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                return { reason, fromPlan, error: 'missing_from_plan_value' };
-            }
-            fromPlan = value;
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith('--reason=')) {
-            const value = arg.slice('--reason='.length);
-            if (value.length === 0) {
-                return { reason, fromPlan, error: 'missing_reason_value' };
-            }
-            reason = value;
-            continue;
-        }
-        if (arg.startsWith('--from-plan=')) {
-            const value = arg.slice('--from-plan='.length);
-            if (value.length === 0) {
-                return { reason, fromPlan, error: 'missing_from_plan_value' };
-            }
-            fromPlan = value;
-            continue;
-        }
-        if (arg.startsWith('-')) {
-            return { reason, fromPlan, error: arg };
-        }
-        return { reason, fromPlan, error: `unexpected:${arg}` };
-    }
-    return { reason, fromPlan };
-}
-export function explainVerifyArgErrorMessage(error, lang) {
-    if (error === 'missing_reason_value') {
-        return t(lang, 'cli.error.missingValue', { option: '--reason' });
-    }
-    if (error === 'missing_from_plan_value') {
-        return t(lang, 'cli.error.missingValue', { option: '--from-plan' });
-    }
-    if (error.startsWith('unexpected:')) {
-        return t(lang, 'cli.error.unexpectedArgument', { argument: error.slice('unexpected:'.length) });
-    }
-    return t(lang, 'cli.error.unknownOption', { option: error });
-}
 export function explainVerifyPlanErrorMessage(error, lang) {
     const code = error instanceof Error ? error.message : 'invalid_plan_file';
     return t(lang, planErrorMessageKey(code));
@@ -73,7 +15,7 @@ export function readExplainVerifyPlanReasons(projectRoot, planPath) {
 }
 export async function getVerifyExplainOutput(schemaVersion, projectRoot, reasons, inputReason, planSource) {
     const contract = readCommandContract(projectRoot);
-    const plans = reasons.map((reason) => createVerificationPlan(contract, reason));
+    const plans = reasons.map((reason) => createVerificationPlan(contract, reason, projectRoot));
     const graphRequirements = reasons.map((reason) => ({
         reason,
         files: [],

package/dist/cli/commands/explain.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
 import { MUSTFLOW_JSON_MAX_BYTES, readMustflowTextFile } from '../lib/mustflow-read.js';
+import { formatCliOptionParseError, getParsedCliStringOption, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 import { explainAssetOptimization, explainCommandIntent, } from '../../core/command-explanation.js';
 import { readCommandContract, readMustflowConfigIfExists } from '../../core/config-loading.js';
@@ -14,10 +15,16 @@ import { explainPublicSurface } from '../../core/public-surface-explanation.js';
 import { explainSourceAnchor } from '../../core/source-anchor-explanation.js';
 import { checkMustflowProject } from '../lib/validation.js';
 import { readLocalCommandEffectGraph, readLocalPathSurface, } from '../lib/local-index.js';
-import { explainVerifyArgErrorMessage, explainVerifyPlanErrorMessage, getVerifyExplainOutput, parseExplainVerifyArgs, readExplainVerifyPlanReasons, renderVerifyExplainDecision, } from './explain-verify.js';
+import { explainVerifyPlanErrorMessage, getVerifyExplainOutput, readExplainVerifyPlanReasons, renderVerifyExplainDecision, } from './explain-verify.js';
 import { createRunPlan, } from '../lib/run-plan.js';
 const EXPLAIN_SCHEMA_VERSION = '1';
 const LATEST_RUN_RECEIPT_RELATIVE_PATH = '.mustflow/state/runs/latest.json';
+const EXPLAIN_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--why-blocked', kind: 'boolean' },
+    { name: '--reason', kind: 'string' },
+    { name: '--from-plan', kind: 'string' },
+];
 export function getExplainHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf explain <topic> [target] [options] | mf explain verify --reason <event> [options] | mf explain why <target> [options] | mf explain --why-blocked <intent> [options]',
@@ -322,10 +329,30 @@ function getLatestFailureExplainOutput(projectRoot) {
 function withWhyTopic(output) {
     return { ...output, topic: 'why' };
 }
-async function getWhyExplainOutput(projectRoot, targetArg, rest, lang, reporter) {
+function firstVerifyOnlyOption(options) {
+    if (options.reason !== null) {
+        return '--reason';
+    }
+    if (options.fromPlan !== null) {
+        return '--from-plan';
+    }
+    return null;
+}
+function rejectVerifyOnlyOption(options, reporter, lang) {
+    const option = firstVerifyOnlyOption(options);
+    if (!option) {
+        return false;
+    }
+    printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option }), 'mf explain --help', getExplainHelp(lang), lang);
+    return true;
+}
+async function getWhyExplainOutput(projectRoot, targetArg, rest, options, lang, reporter) {
     switch (targetArg) {
         case 'command':
         case 'intent': {
+            if (rejectVerifyOnlyOption(options, reporter, lang)) {
+                return null;
+            }
             const [commandName, ...extra] = rest;
             if (!commandName) {
                 printUsageError(reporter, t(lang, 'explain.error.missingCommand'), 'mf explain --help', getExplainHelp(lang), lang);
@@ -338,12 +365,11 @@ async function getWhyExplainOutput(projectRoot, targetArg, rest, lang, reporter)
             return withWhyTopic(await getCommandExplainOutput(projectRoot, commandName));
         }
         case 'verify': {
-            const parsed = parseExplainVerifyArgs([...rest]);
-            if (parsed.error) {
-                printUsageError(reporter, explainVerifyArgErrorMessage(parsed.error, lang), 'mf explain --help', getExplainHelp(lang), lang);
+            if (rest.length > 0) {
+                printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: rest[0] }), 'mf explain --help', getExplainHelp(lang), lang);
                 return null;
             }
-            const selectedInputCount = [parsed.reason, parsed.fromPlan].filter(Boolean).length;
+            const selectedInputCount = [options.reason, options.fromPlan].filter(Boolean).length;
             if (selectedInputCount > 1) {
                 printUsageError(reporter, t(lang, 'verify.error.conflictingInputs'), 'mf explain --help', getExplainHelp(lang), lang);
                 return null;
@@ -353,11 +379,11 @@ async function getWhyExplainOutput(projectRoot, targetArg, rest, lang, reporter)
                 return null;
             }
             try {
-                if (parsed.fromPlan) {
-                    const reasons = readExplainVerifyPlanReasons(projectRoot, parsed.fromPlan);
-                    return withWhyTopic(await getVerifyExplainOutput(EXPLAIN_SCHEMA_VERSION, projectRoot, reasons, null, parsed.fromPlan));
+                if (options.fromPlan) {
+                    const reasons = readExplainVerifyPlanReasons(projectRoot, options.fromPlan);
+                    return withWhyTopic(await getVerifyExplainOutput(EXPLAIN_SCHEMA_VERSION, projectRoot, reasons, null, options.fromPlan));
                 }
-                return withWhyTopic(await getVerifyExplainOutput(EXPLAIN_SCHEMA_VERSION, projectRoot, [parsed.reason], parsed.reason, null));
+                return withWhyTopic(await getVerifyExplainOutput(EXPLAIN_SCHEMA_VERSION, projectRoot, [options.reason], options.reason, null));
             }
             catch (error) {
                 printUsageError(reporter, explainVerifyPlanErrorMessage(error, lang), 'mf explain --help', getExplainHelp(lang), lang);
@@ -365,6 +391,9 @@ async function getWhyExplainOutput(projectRoot, targetArg, rest, lang, reporter)
             }
         }
         case 'skill': {
+            if (rejectVerifyOnlyOption(options, reporter, lang)) {
+                return null;
+            }
             const [skillName, ...extra] = rest;
             if (!skillName) {
                 printUsageError(reporter, t(lang, 'explain.error.missingSkill'), 'mf explain --help', getExplainHelp(lang), lang);
@@ -377,12 +406,18 @@ async function getWhyExplainOutput(projectRoot, targetArg, rest, lang, reporter)
             return withWhyTopic(getSkillExplainOutput(projectRoot, skillName));
         }
         case 'skills':
+            if (rejectVerifyOnlyOption(options, reporter, lang)) {
+                return null;
+            }
             if (rest.length > 0) {
                 printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: rest[0] }), 'mf explain --help', getExplainHelp(lang), lang);
                 return null;
             }
             return withWhyTopic(getSkillsExplainOutput(projectRoot));
         case 'surface': {
+            if (rejectVerifyOnlyOption(options, reporter, lang)) {
+                return null;
+            }
             const [pathArg, ...extra] = rest;
             if (extra.length > 0) {
                 printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: extra[0] }), 'mf explain --help', getExplainHelp(lang), lang);
@@ -392,6 +427,9 @@ async function getWhyExplainOutput(projectRoot, targetArg, rest, lang, reporter)
         }
         case 'latest-failure':
         case 'latest-run':
+            if (rejectVerifyOnlyOption(options, reporter, lang)) {
+                return null;
+            }
             if (rest.length > 0) {
                 printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: rest[0] }), 'mf explain --help', getExplainHelp(lang), lang);
                 return null;
@@ -549,24 +587,38 @@ function renderExplainDecision(output, lang) {
     return lines.join('\n');
 }
 export async function runExplain(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getExplainHelp(lang));
         return 0;
     }
-    const json = args.includes('--json');
-    const positional = args.filter((arg) => arg !== '--json');
-    const [topic, targetArg, ...rest] = positional;
-    if (topic === '--why-blocked') {
-        if (!targetArg) {
+    const parsed = parseCliOptions(args, EXPLAIN_OPTIONS, { allowPositionals: true });
+    if (parsed.error) {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf explain --help', getExplainHelp(lang), lang);
+        return 1;
+    }
+    const options = {
+        json: hasParsedCliOption(parsed, '--json'),
+        whyBlocked: hasParsedCliOption(parsed, '--why-blocked'),
+        reason: getParsedCliStringOption(parsed, '--reason'),
+        fromPlan: getParsedCliStringOption(parsed, '--from-plan'),
+        positionals: parsed.positionals,
+    };
+    const [topic, targetArg, ...rest] = options.positionals;
+    if (options.whyBlocked) {
+        const [commandName, ...extra] = options.positionals;
+        if (rejectVerifyOnlyOption(options, reporter, lang)) {
+            return 1;
+        }
+        if (!commandName) {
             printUsageError(reporter, t(lang, 'explain.error.missingCommand'), 'mf explain --help', getExplainHelp(lang), lang);
             return 1;
         }
-        if (rest.length > 0) {
-            printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: rest[0] }), 'mf explain --help', getExplainHelp(lang), lang);
+        if (extra.length > 0) {
+            printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: extra[0] }), 'mf explain --help', getExplainHelp(lang), lang);
             return 1;
         }
-        const output = getWhyBlockedExplainOutput(resolveMustflowRoot(), targetArg);
-        if (json) {
+        const output = getWhyBlockedExplainOutput(resolveMustflowRoot(), commandName);
+        if (options.json) {
             reporter.stdout(JSON.stringify(output, null, 2));
             return 0;
         }
@@ -575,11 +627,11 @@ export async function runExplain(args, reporter, lang = 'en') {
     }
     if (topic === 'why') {
         const projectRoot = resolveMustflowRoot();
-        const output = await getWhyExplainOutput(projectRoot, targetArg, rest, lang, reporter);
+        const output = await getWhyExplainOutput(projectRoot, targetArg, rest, options, lang, reporter);
         if (!output) {
             return 1;
         }
-        if (json) {
+        if (options.json) {
             reporter.stdout(JSON.stringify(output, null, 2));
             return 0;
         }
@@ -587,13 +639,11 @@ export async function runExplain(args, reporter, lang = 'en') {
         return 0;
     }
     if (topic === 'verify') {
-        const verifyArgs = targetArg === undefined ? rest : [targetArg, ...rest];
-        const parsed = parseExplainVerifyArgs(verifyArgs);
-        if (parsed.error) {
-            printUsageError(reporter, explainVerifyArgErrorMessage(parsed.error, lang), 'mf explain --help', getExplainHelp(lang), lang);
+        if (targetArg) {
+            printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: targetArg }), 'mf explain --help', getExplainHelp(lang), lang);
             return 1;
         }
-        const selectedInputCount = [parsed.reason, parsed.fromPlan].filter(Boolean).length;
+        const selectedInputCount = [options.reason, options.fromPlan].filter(Boolean).length;
         if (selectedInputCount > 1) {
             printUsageError(reporter, t(lang, 'verify.error.conflictingInputs'), 'mf explain --help', getExplainHelp(lang), lang);
             return 1;
@@ -605,28 +655,26 @@ export async function runExplain(args, reporter, lang = 'en') {
         const projectRoot = resolveMustflowRoot();
         let output;
         try {
-            if (parsed.fromPlan) {
-                const reasons = readExplainVerifyPlanReasons(projectRoot, parsed.fromPlan);
-                output = await getVerifyExplainOutput(EXPLAIN_SCHEMA_VERSION, projectRoot, reasons, null, parsed.fromPlan);
+            if (options.fromPlan) {
+                const reasons = readExplainVerifyPlanReasons(projectRoot, options.fromPlan);
+                output = await getVerifyExplainOutput(EXPLAIN_SCHEMA_VERSION, projectRoot, reasons, null, options.fromPlan);
             }
             else {
-                output = await getVerifyExplainOutput(EXPLAIN_SCHEMA_VERSION, projectRoot, [parsed.reason], parsed.reason, null);
+                output = await getVerifyExplainOutput(EXPLAIN_SCHEMA_VERSION, projectRoot, [options.reason], options.reason, null);
             }
         }
         catch (error) {
             printUsageError(reporter, explainVerifyPlanErrorMessage(error, lang), 'mf explain --help', getExplainHelp(lang), lang);
             return 1;
         }
-        if (json) {
+        if (options.json) {
             reporter.stdout(JSON.stringify(output, null, 2));
             return 0;
         }
         reporter.stdout(renderExplainDecision(output, lang));
         return 0;
     }
-    const unsupported = args.filter((arg) => arg.startsWith('-') && arg !== '--json');
-    if (unsupported.length > 0) {
-        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf explain --help', getExplainHelp(lang), lang);
+    if (rejectVerifyOnlyOption(options, reporter, lang)) {
         return 1;
     }
     if (topic !== 'asset-optimization' &&
@@ -700,7 +748,7 @@ export async function runExplain(args, reporter, lang = 'en') {
             output = getSkillsExplainOutput(projectRoot);
             break;
     }
-    if (json) {
+    if (options.json) {
         reporter.stdout(JSON.stringify(output, null, 2));
         return 0;
     }

package/dist/cli/commands/handoff.js

@@ -4,7 +4,9 @@ import { MAX_HANDOFF_RECORD_BYTES, validateHandoffRecordJson, } from '../../core
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { ensureInsideWithoutSymlinks, readUtf8FileInsideWithoutSymlinks } from '../lib/filesystem.js';
 import { t } from '../lib/i18n.js';
+import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
+const HANDOFF_OPTIONS = [{ name: '--json', kind: 'boolean' }];
 export function getHandoffHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf handoff validate <path> [options]',
@@ -25,26 +27,20 @@ export function getHandoffHelp(lang = 'en') {
 }
 function parseHandoffArgs(args, lang) {
     const [action, ...rest] = args;
-    let json = false;
-    let recordPath;
     if (!action) {
-        return { action: 'validate', json, error: t(lang, 'handoff.error.missingAction') };
+        return { action: 'validate', json: false, error: t(lang, 'handoff.error.missingAction') };
     }
     if (action !== 'validate') {
-        return { action: 'validate', json, error: t(lang, 'handoff.error.unknownAction', { action }) };
+        return { action: 'validate', json: false, error: t(lang, 'handoff.error.unknownAction', { action }) };
     }
-    for (const arg of rest) {
-        if (arg === '--json') {
-            json = true;
-            continue;
-        }
-        if (arg.startsWith('-')) {
-            return { action, path: recordPath, json, error: t(lang, 'cli.error.unknownOption', { option: arg }) };
-        }
-        if (recordPath) {
-            return { action, path: recordPath, json, error: t(lang, 'cli.error.unexpectedArgument', { argument: arg }) };
-        }
-        recordPath = arg;
+    const parsed = parseCliOptions(rest, HANDOFF_OPTIONS, { allowPositionals: true });
+    const json = hasParsedCliOption(parsed, '--json');
+    const [recordPath, unexpectedArgument] = parsed.positionals;
+    if (unexpectedArgument) {
+        return { action, path: recordPath, json, error: t(lang, 'cli.error.unexpectedArgument', { argument: unexpectedArgument }) };
+    }
+    if (parsed.error) {
+        return { action, path: recordPath, json, error: formatCliOptionParseError(parsed.error, lang) };
     }
     if (!recordPath) {
         return { action, json, error: t(lang, 'handoff.error.missingPath') };
@@ -94,7 +90,7 @@ function renderHandoffReport(report, lang) {
 }
 export function runHandoff(args, reporter, lang = 'en') {
     const helpText = getHandoffHelp(lang);
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(helpText);
         return 0;
     }

package/dist/cli/commands/impact.js

@@ -4,10 +4,15 @@ import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { isRecord } from '../lib/command-contract.js';
 import { requireGitChangedFiles } from '../lib/git-changes.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 IMPACT_SCHEMA_VERSION = '1';
+const IMPACT_OPTIONS = [
+    { name: '--json', kind: 'boolean' },
+    { name: '--changed', kind: 'boolean' },
+];
 export function getImpactHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf impact --changed [options] | mf impact <path...> [options]',
@@ -25,24 +30,13 @@ export function getImpactHelp(lang = 'en') {
     }, lang);
 }
 function parseImpactArgs(args) {
-    const paths = [];
-    let json = false;
-    let changed = false;
-    for (const arg of args) {
-        if (arg === '--json') {
-            json = true;
-            continue;
-        }
-        if (arg === '--changed') {
-            changed = true;
-            continue;
-        }
-        if (arg.startsWith('-')) {
-            return { json, changed, paths, error: arg };
-        }
-        paths.push(arg);
-    }
-    return { json, changed, paths };
+    const parsed = parseCliOptions(args, IMPACT_OPTIONS, { allowPositionals: true });
+    return {
+        json: hasParsedCliOption(parsed, '--json'),
+        changed: hasParsedCliOption(parsed, '--changed'),
+        paths: parsed.positionals,
+        error: parsed.error,
+    };
 }
 function readPreferences(projectRoot) {
     try {
@@ -92,13 +86,13 @@ function renderImpactOutput(output, lang) {
     return lines.join('\n');
 }
 export function runImpact(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getImpactHelp(lang));
         return 0;
     }
     const parsed = parseImpactArgs(args);
     if (parsed.error) {
-        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: parsed.error }), 'mf impact --help', getImpactHelp(lang), lang);
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf impact --help', getImpactHelp(lang), lang);
         return 1;
     }
     if (parsed.changed && parsed.paths.length > 0) {

package/dist/cli/commands/index.js

@@ -1,7 +1,14 @@
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
 import { createLocalIndex } from '../lib/local-index.js';
+import { formatCliOptionParseError, hasCliOptionToken, hasParsedCliOption, parseCliOptions, } from '../lib/option-parser.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
+const INDEX_OPTIONS = [
+    { name: '--dry-run', kind: 'boolean' },
+    { name: '--json', kind: 'boolean' },
+    { name: '--source', kind: 'boolean' },
+    { name: '--incremental', kind: 'boolean' },
+];
 export function getIndexHelp(lang = 'en') {
     return renderHelp({
         usage: 'mf index [options]',
@@ -67,22 +74,21 @@ function renderIndexSummary(result, lang) {
     return lines.join('\n');
 }
 export async function runIndex(args, reporter, lang = 'en') {
-    if (args.includes('--help') || args.includes('-h')) {
+    if (hasCliOptionToken(args, '--help', ['-h'])) {
         reporter.stdout(getIndexHelp(lang));
         return 0;
     }
-    const supported = new Set(['--dry-run', '--json', '--source', '--incremental']);
-    const unsupported = args.filter((arg) => !supported.has(arg));
-    if (unsupported.length > 0) {
-        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf index --help', getIndexHelp(lang), lang);
+    const parsed = parseCliOptions(args, INDEX_OPTIONS);
+    if (parsed.error) {
+        printUsageError(reporter, formatCliOptionParseError(parsed.error, lang), 'mf index --help', getIndexHelp(lang), lang);
         return 1;
     }
     const result = await createLocalIndex(resolveMustflowRoot(), {
-        dryRun: args.includes('--dry-run'),
-        includeSource: args.includes('--source'),
-        incremental: args.includes('--incremental'),
+        dryRun: hasParsedCliOption(parsed, '--dry-run'),
+        includeSource: hasParsedCliOption(parsed, '--source'),
+        incremental: hasParsedCliOption(parsed, '--incremental'),
     });
-    if (args.includes('--json')) {
+    if (hasParsedCliOption(parsed, '--json')) {
         reporter.stdout(JSON.stringify(result, null, 2));
         return 0;
     }