mustflow 2.18.2 → 2.18.7

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

@@ -0,0 +1,262 @@
+export const DEFAULT_VERIFY_PARALLELISM = 1;
+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;
+    let parallelism = DEFAULT_VERIFY_PARALLELISM;
+    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;
+            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;
+            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}`,
+        };
+    }
+    return {
+        json,
+        planOnly,
+        changed,
+        reason,
+        fromClassification,
+        fromPlan,
+        writePlan,
+        reproEvidence,
+        externalEvidence,
+        parallelism,
+    };
+}
+function parseVerifyParallelism(value) {
+    if (!/^[1-9][0-9]*$/u.test(value)) {
+        return null;
+    }
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) ? parsed : null;
+}

package/dist/cli/commands/verify.js

@@ -13,6 +13,7 @@ import { createVerifyEvidenceModel } from '../../core/verification-evidence.js';
 import { createScopeDiffRisks } from '../../core/scope-risk.js';
 import { countValidationRatchetVerdictEffects, createValidationRatchetRisks, } from '../../core/validation-ratchet.js';
 import { readCommandContract } from '../../core/config-loading.js';
+import { DEFAULT_VERIFY_PARALLELISM, parseVerifyArgs } from './verify/args.js';
 import { printUsageError, renderHelp } from '../lib/cli-output.js';
 import { t } from '../lib/i18n.js';
 import { readLocalCommandEffectGraph, readLocalPathSurfaces, readLocalSourceAnchorVerdictRisks, } from '../lib/local-index.js';
@@ -20,7 +21,6 @@ import { resolveMustflowRoot } from '../lib/project-root.js';
 const VERIFY_SCHEMA_VERSION = '1';
 const RUN_STATE_DIR = path.join('.mustflow', 'state', 'runs');
 const LATEST_RUN_RECEIPT_PATH = path.join(RUN_STATE_DIR, 'latest.json');
-const DEFAULT_VERIFY_PARALLELISM = 1;
 function createBufferedOutput() {
     const stdout = [];
     const stderr = [];
@@ -73,267 +73,6 @@ export function getVerifyHelp(lang = 'en') {
         ],
     }, lang);
 }
-function parseVerifyArgs(args) {
-    let reason;
-    let fromClassification;
-    let fromPlan;
-    let writePlan;
-    let reproEvidence;
-    let externalEvidence;
-    let json = false;
-    let planOnly = false;
-    let changed = false;
-    let parallelism = DEFAULT_VERIFY_PARALLELISM;
-    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;
-            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;
-            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}`,
-        };
-    }
-    return {
-        json,
-        planOnly,
-        changed,
-        reason,
-        fromClassification,
-        fromPlan,
-        writePlan,
-        reproEvidence,
-        externalEvidence,
-        parallelism,
-    };
-}
-function parseVerifyParallelism(value) {
-    if (!/^[1-9][0-9]*$/u.test(value)) {
-        return null;
-    }
-    const parsed = Number(value);
-    return Number.isSafeInteger(parsed) ? parsed : null;
-}
 function uniqueStrings(values) {
     return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))];
 }

package/dist/cli/i18n/en.js

@@ -672,6 +672,7 @@ Read these files before working:
     "run.error.maxOutputBytesDetail": "The output limit must stay within the allowed maximum.",
     "run.error.conflictingPreviewModes": "Use either --dry-run or --plan-only, not both",
     "run.error.timedOut": 'Command "{intent}" timed out after {seconds} seconds',
+    "run.error.outputLimitExceeded": 'Command "{intent}" exceeded max_output_bytes: {message}',
     "run.error.startFailed": 'Command "{intent}" failed to start: {message}',
     "search.help.summary": "Search the local SQLite index for the mustflow workflow.",
     "search.help.option.limit": "Set the number of results to print. Default: 10, max: 50",

package/dist/cli/i18n/es.js

@@ -672,6 +672,7 @@ Lee estos archivos antes de trabajar:
     "run.error.maxOutputBytesDetail": "El límite de salida debe permanecer dentro del máximo permitido.",
     "run.error.conflictingPreviewModes": "Usa --dry-run o --plan-only, no ambos",
     "run.error.timedOut": 'El comando "{intent}" agotó el tiempo después de {seconds} segundos',
+    "run.error.outputLimitExceeded": 'El comando "{intent}" superó max_output_bytes: {message}',
     "run.error.startFailed": 'No se pudo iniciar el comando "{intent}": {message}',
     "search.help.summary": "Busca en el índice SQLite local del flujo de trabajo mustflow.",
     "search.help.option.limit": "Define la cantidad de resultados que se imprimen. Predeterminado: 10, máximo: 50",

package/dist/cli/i18n/fr.js

@@ -672,6 +672,7 @@ Lisez ces fichiers avant de travailler :
     "run.error.maxOutputBytesDetail": "La limite de sortie doit rester dans le maximum autorisé.",
     "run.error.conflictingPreviewModes": "Utilisez --dry-run ou --plan-only, pas les deux",
     "run.error.timedOut": 'La commande "{intent}" a expiré après {seconds} secondes',
+    "run.error.outputLimitExceeded": 'La commande "{intent}" a dépassé max_output_bytes : {message}',
     "run.error.startFailed": 'Impossible de démarrer la commande "{intent}" : {message}',
     "search.help.summary": "Recherche dans l'index SQLite local du flux de travail mustflow.",
     "search.help.option.limit": "Définit le nombre de résultats à imprimer. Par défaut : 10, max : 50",

package/dist/cli/i18n/hi.js

@@ -672,6 +672,7 @@ export const hiMessages = {
     "run.error.maxOutputBytesDetail": "Output limit अनुमत maximum के अंदर रहनी चाहिए।",
     "run.error.conflictingPreviewModes": "--dry-run या --plan-only में से एक इस्तेमाल करें, दोनों नहीं",
     "run.error.timedOut": 'कमांड "{intent}" {seconds} सेकंड बाद time out हुई',
+    "run.error.outputLimitExceeded": 'कमांड "{intent}" ने max_output_bytes सीमा पार की: {message}',
     "run.error.startFailed": 'कमांड "{intent}" शुरू नहीं हो सकी: {message}',
     "search.help.summary": "mustflow वर्कफ़्लो के लिए स्थानीय SQLite इंडेक्स में खोजें।",
     "search.help.option.limit": "प्रिंट किए जाने वाले परिणामों की संख्या सेट करें। डिफ़ॉल्ट: 10, अधिकतम: 50",

package/dist/cli/i18n/ko.js

@@ -672,6 +672,7 @@ export const koMessages = {
     "run.error.maxOutputBytesDetail": "출력 상한은 허용된 최댓값 안에 있어야 합니다.",
     "run.error.conflictingPreviewModes": "--dry-run과 --plan-only 중 하나만 사용하세요",
     "run.error.timedOut": '명령 "{intent}"가 {seconds}초 뒤 시간 초과되었습니다',
+    "run.error.outputLimitExceeded": '명령 "{intent}"가 max_output_bytes 제한을 넘었습니다: {message}',
     "run.error.startFailed": '명령 "{intent}"를 시작하지 못했습니다: {message}',
     "search.help.summary": "로컬 SQLite 색인에서 mustflow 워크플로우를 검색합니다.",
     "search.help.option.limit": "출력할 검색 결과 수를 설정합니다. 기본값: 10, 최대: 50",

package/dist/cli/i18n/zh.js

@@ -672,6 +672,7 @@ export const zhMessages = {
     "run.error.maxOutputBytesDetail": "输出限制必须保持在允许的最大值内。",
     "run.error.conflictingPreviewModes": "只能使用 --dry-run 或 --plan-only，不能同时使用",
     "run.error.timedOut": '命令 "{intent}" 在 {seconds} 秒后超时',
+    "run.error.outputLimitExceeded": '命令 "{intent}" 超过 max_output_bytes：{message}',
     "run.error.startFailed": '命令 "{intent}" 启动失败：{message}',
     "search.help.summary": "搜索本地 SQLite 索引中的 mustflow 工作流。",
     "search.help.option.limit": "设置要输出的结果数量。默认值：10，最大：50",