mustflow 2.22.4 → 2.22.9

package/dist/cli/commands/verify/evidence-input.js

@@ -0,0 +1,269 @@
+import { readVerifyJsonInputFile } from './input.js';
+function isPlainRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function isExternalEvidenceStatus(value) {
+    return value === 'passed' || value === 'failed' || value === 'cancelled' || value === 'unknown';
+}
+function isLegacyReproEvidenceStatus(value) {
+    return value === 'present' || value === 'unavailable' || value === 'missing';
+}
+function isReproBeforeFixStatus(value) {
+    return value === 'reproduced' || value === 'unavailable' || value === 'missing';
+}
+function isReproBeforeFixOutcome(value) {
+    return value === 'failed_as_expected' || value === 'failed_differently' || value === 'passed_unexpectedly' || value === null;
+}
+function isReproAfterFixStatus(value) {
+    return value === 'passed' || value === 'failed' || value === 'unavailable' || value === 'missing';
+}
+function isReproAfterFixOutcome(value) {
+    return value === 'passed_expected_behavior' || value === 'failed_same_route' || value === 'failed_differently' || value === null;
+}
+function isReproRegressionGuardStatus(value) {
+    return value === 'passed' || value === 'failed' || value === 'unavailable' || value === 'missing';
+}
+function isReproRouteKind(value) {
+    return (value === 'test' ||
+        value === 'cli' ||
+        value === 'browser' ||
+        value === 'api' ||
+        value === 'manual' ||
+        value === 'unknown' ||
+        value === null);
+}
+function readOptionalString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function readRouteStep(value, index) {
+    if (!isPlainRecord(value)) {
+        return {
+            ordinal: index + 1,
+            action: null,
+            target: null,
+            input_digest: null,
+            observation_digest: null,
+            summary: null,
+        };
+    }
+    const ordinal = typeof value.ordinal === 'number' && Number.isInteger(value.ordinal) && value.ordinal > 0 ? value.ordinal : index + 1;
+    return {
+        ordinal,
+        action: readOptionalString(value.action),
+        target: readOptionalString(value.target),
+        input_digest: readOptionalString(value.input_digest),
+        observation_digest: readOptionalString(value.observation_digest),
+        summary: readOptionalString(value.summary),
+    };
+}
+function readReproductionRoute(value) {
+    if (!isPlainRecord(value)) {
+        return {
+            route_id: null,
+            route_kind: null,
+            route_digest: null,
+            failure_oracle_hash: null,
+            steps: [],
+        };
+    }
+    const routeKind = value.route_kind ?? null;
+    if (!isReproRouteKind(routeKind)) {
+        throw new Error('invalid_repro_evidence_file');
+    }
+    const rawSteps = Array.isArray(value.steps) ? value.steps : [];
+    return {
+        route_id: readOptionalString(value.route_id),
+        route_kind: routeKind,
+        route_digest: readOptionalString(value.route_digest),
+        failure_oracle_hash: readOptionalString(value.failure_oracle_hash),
+        steps: rawSteps.map((step, index) => readRouteStep(step, index)),
+    };
+}
+function readLegacyReproEvidenceItem(value) {
+    if (!isPlainRecord(value)) {
+        return {
+            status: 'missing',
+            summary: null,
+            reason: null,
+        };
+    }
+    if (!isLegacyReproEvidenceStatus(value.status)) {
+        throw new Error('invalid_repro_evidence_file');
+    }
+    return {
+        status: value.status,
+        summary: readOptionalString(value.summary),
+        reason: readOptionalString(value.reason),
+    };
+}
+function legacyBeforeFixEvidence(value) {
+    const item = readLegacyReproEvidenceItem(value);
+    return {
+        status: item.status === 'present' ? 'reproduced' : item.status,
+        outcome: item.status === 'present' ? 'failed_as_expected' : null,
+        receipt_path: null,
+        receipt_sha256: null,
+        verification_plan_id: null,
+        summary: item.summary,
+        reason: item.reason,
+    };
+}
+function legacyAfterFixEvidence(value) {
+    const item = readLegacyReproEvidenceItem(value);
+    return {
+        status: item.status === 'present' ? 'passed' : item.status,
+        outcome: item.status === 'present' ? 'passed_expected_behavior' : null,
+        same_route_as: null,
+        receipt_path: null,
+        receipt_sha256: null,
+        verification_plan_id: null,
+        summary: item.summary,
+        reason: item.reason,
+    };
+}
+function legacyRegressionGuardEvidence(value) {
+    const item = readLegacyReproEvidenceItem(value);
+    return {
+        status: item.status === 'present' ? 'passed' : item.status,
+        intent: null,
+        test_path: null,
+        receipt_path: null,
+        receipt_sha256: null,
+        verification_plan_id: null,
+        summary: item.summary,
+        reason: item.reason,
+    };
+}
+function readBeforeFixEvidence(value) {
+    if (!isPlainRecord(value)) {
+        return {
+            status: 'missing',
+            outcome: null,
+            receipt_path: null,
+            receipt_sha256: null,
+            verification_plan_id: null,
+            summary: null,
+            reason: null,
+        };
+    }
+    const outcome = value.outcome ?? null;
+    if (!isReproBeforeFixStatus(value.status) || !isReproBeforeFixOutcome(outcome)) {
+        throw new Error('invalid_repro_evidence_file');
+    }
+    return {
+        status: value.status,
+        outcome,
+        receipt_path: readOptionalString(value.receipt_path),
+        receipt_sha256: readOptionalString(value.receipt_sha256),
+        verification_plan_id: readOptionalString(value.verification_plan_id),
+        summary: readOptionalString(value.summary),
+        reason: readOptionalString(value.reason),
+    };
+}
+function readAfterFixEvidence(value) {
+    if (!isPlainRecord(value)) {
+        return {
+            status: 'missing',
+            outcome: null,
+            same_route_as: null,
+            receipt_path: null,
+            receipt_sha256: null,
+            verification_plan_id: null,
+            summary: null,
+            reason: null,
+        };
+    }
+    const outcome = value.outcome ?? null;
+    if (!isReproAfterFixStatus(value.status) || !isReproAfterFixOutcome(outcome)) {
+        throw new Error('invalid_repro_evidence_file');
+    }
+    return {
+        status: value.status,
+        outcome,
+        same_route_as: readOptionalString(value.same_route_as),
+        receipt_path: readOptionalString(value.receipt_path),
+        receipt_sha256: readOptionalString(value.receipt_sha256),
+        verification_plan_id: readOptionalString(value.verification_plan_id),
+        summary: readOptionalString(value.summary),
+        reason: readOptionalString(value.reason),
+    };
+}
+function readRegressionGuardEvidence(value) {
+    if (!isPlainRecord(value)) {
+        return {
+            status: 'missing',
+            intent: null,
+            test_path: null,
+            receipt_path: null,
+            receipt_sha256: null,
+            verification_plan_id: null,
+            summary: null,
+            reason: null,
+        };
+    }
+    if (!isReproRegressionGuardStatus(value.status)) {
+        throw new Error('invalid_repro_evidence_file');
+    }
+    return {
+        status: value.status,
+        intent: readOptionalString(value.intent),
+        test_path: readOptionalString(value.test_path),
+        receipt_path: readOptionalString(value.receipt_path),
+        receipt_sha256: readOptionalString(value.receipt_sha256),
+        verification_plan_id: readOptionalString(value.verification_plan_id),
+        summary: readOptionalString(value.summary),
+        reason: readOptionalString(value.reason),
+    };
+}
+export function readReproEvidenceFile(projectRoot, inputPath) {
+    const parsed = readVerifyJsonInputFile(projectRoot, inputPath, 'invalid_repro_evidence_file');
+    if (!isPlainRecord(parsed) || parsed.schema_version !== '1' || parsed.command !== 'repro-evidence') {
+        throw new Error('unsupported_repro_evidence_source');
+    }
+    const regressionGuard = isPlainRecord(parsed.regression_guard) && isReproRegressionGuardStatus(parsed.regression_guard.status)
+        ? readRegressionGuardEvidence(parsed.regression_guard)
+        : legacyRegressionGuardEvidence(parsed.regression_guard);
+    return {
+        source: 'repro_first_debug',
+        authority: 'claim_evidence',
+        reported_symptom: readOptionalString(parsed.reported_symptom),
+        expected_behavior: readOptionalString(parsed.expected_behavior),
+        observed_behavior: readOptionalString(parsed.observed_behavior),
+        reproduction_route: readReproductionRoute(parsed.reproduction_route),
+        before_fix: isPlainRecord(parsed.before_fix)
+            ? readBeforeFixEvidence(parsed.before_fix)
+            : legacyBeforeFixEvidence(parsed.evidence_before_fix),
+        after_fix: isPlainRecord(parsed.after_fix)
+            ? readAfterFixEvidence(parsed.after_fix)
+            : legacyAfterFixEvidence(parsed.evidence_after_fix),
+        regression_guard: regressionGuard,
+    };
+}
+export function readExternalEvidenceFile(projectRoot, inputPath) {
+    const parsed = readVerifyJsonInputFile(projectRoot, inputPath, 'invalid_external_evidence_file');
+    if (!isPlainRecord(parsed) || parsed.schema_version !== '1' || parsed.command !== 'external-evidence') {
+        throw new Error('unsupported_external_evidence_source');
+    }
+    if (!Array.isArray(parsed.checks)) {
+        throw new Error('invalid_external_evidence_file');
+    }
+    return parsed.checks.map((check) => {
+        if (!isPlainRecord(check) ||
+            typeof check.provider !== 'string' ||
+            check.provider.length === 0 ||
+            typeof check.name !== 'string' ||
+            check.name.length === 0 ||
+            !isExternalEvidenceStatus(check.status)) {
+            throw new Error('invalid_external_evidence_file');
+        }
+        return {
+            source: 'external_ci',
+            authority: 'supporting_only',
+            provider: check.provider,
+            name: check.name,
+            status: check.status,
+            url: readOptionalString(check.url),
+            summary: readOptionalString(check.summary),
+        };
+    });
+}

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

@@ -0,0 +1,212 @@
+import path from 'node:path';
+import { createClassifyOutput } from '../classify.js';
+import { createCorrelationId, isCorrelationId } from '../../../core/correlation-id.js';
+import { readUtf8FileInsideWithoutSymlinks, writeJsonFileInsideWithoutSymlinks } from '../../../core/safe-filesystem.js';
+function uniqueStrings(values) {
+    return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))];
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function isPlainRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function isUpdatePolicy(value) {
+    return value === 'update' || value === 'update_or_mark_stale' || value === 'not_applicable';
+}
+function isUpdatePolicyArray(value) {
+    return Array.isArray(value) && value.every((item) => isUpdatePolicy(item));
+}
+function readPlanRoot(value) {
+    if (!isPlainRecord(value)) {
+        return null;
+    }
+    const root = value.mustflow_root;
+    return typeof root === 'string' && root.length > 0 ? root : null;
+}
+function readPlanCorrelationId(value) {
+    if (!isPlainRecord(value)) {
+        return null;
+    }
+    return isCorrelationId(value.correlation_id) ? value.correlation_id : null;
+}
+function readStrictClassificationSummary(value) {
+    if (!isPlainRecord(value)) {
+        return null;
+    }
+    if (!Number.isInteger(value.fileCount) ||
+        Number(value.fileCount) < 0 ||
+        !Number.isInteger(value.publicSurfaceCount) ||
+        Number(value.publicSurfaceCount) < 0 ||
+        !isStringArray(value.changeKinds) ||
+        !isStringArray(value.validationReasons) ||
+        !isUpdatePolicyArray(value.updatePolicies) ||
+        !isStringArray(value.driftChecks) ||
+        !isStringArray(value.affectedContracts)) {
+        return null;
+    }
+    return {
+        fileCount: Number(value.fileCount),
+        publicSurfaceCount: Number(value.publicSurfaceCount),
+        changeKinds: [...value.changeKinds],
+        validationReasons: uniqueStrings(value.validationReasons),
+        updatePolicies: [...value.updatePolicies],
+        driftChecks: [...value.driftChecks],
+        affectedContracts: [...value.affectedContracts],
+    };
+}
+function readStrictClassification(value) {
+    if (!isPlainRecord(value) || typeof value.path !== 'string' || !isStringArray(value.changeKinds)) {
+        return null;
+    }
+    const surface = value.surface;
+    if (!isPlainRecord(surface)) {
+        return null;
+    }
+    if (typeof surface.kind !== 'string' ||
+        typeof surface.category !== 'string' ||
+        typeof surface.isPublicSurface !== 'boolean' ||
+        !isStringArray(surface.validationReasons) ||
+        !isStringArray(surface.affectedContracts) ||
+        !isUpdatePolicy(surface.updatePolicy) ||
+        !isStringArray(surface.driftChecks)) {
+        return null;
+    }
+    return {
+        path: value.path,
+        changeKinds: [...value.changeKinds],
+        surface: {
+            kind: surface.kind,
+            category: surface.category,
+            isPublicSurface: surface.isPublicSurface,
+            validationReasons: [...surface.validationReasons],
+            affectedContracts: [...surface.affectedContracts],
+            updatePolicy: surface.updatePolicy,
+            driftChecks: [...surface.driftChecks],
+        },
+    };
+}
+function readStrictClassifications(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    const classifications = value.map(readStrictClassification);
+    return classifications.every((classification) => classification !== null)
+        ? classifications
+        : null;
+}
+function readStrictClassifyPlan(projectRoot, plan) {
+    if (!isPlainRecord(plan)) {
+        throw new Error('unsupported_plan_source');
+    }
+    if (plan.schema_version !== '1' || plan.command !== 'classify') {
+        throw new Error('unsupported_plan_source');
+    }
+    if (readPlanRoot(plan) !== projectRoot) {
+        throw new Error('plan_root_mismatch');
+    }
+    const source = plan.source;
+    const files = plan.files;
+    const classifications = readStrictClassifications(plan.classifications);
+    const summary = readStrictClassificationSummary(plan.summary);
+    if ((source !== 'changed' && source !== 'paths') || !isStringArray(files) || !classifications || !summary) {
+        throw new Error('invalid_plan_file');
+    }
+    if (summary.validationReasons.length === 0) {
+        throw new Error('missing_plan_reasons');
+    }
+    return {
+        source,
+        files: [...files],
+        classifications,
+        summary,
+    };
+}
+function emptyClassificationSummary(validationReasons) {
+    return {
+        fileCount: 0,
+        publicSurfaceCount: 0,
+        changeKinds: [],
+        validationReasons,
+        updatePolicies: [],
+        driftChecks: [],
+        affectedContracts: [],
+    };
+}
+export function createSyntheticClassificationReport(reasons, source = 'paths', files = []) {
+    return {
+        source,
+        files,
+        classifications: [],
+        summary: emptyClassificationSummary(reasons),
+    };
+}
+export function resolveVerifyInputPath(projectRoot, inputPath) {
+    const resolved = path.resolve(projectRoot, inputPath);
+    const relative = path.relative(projectRoot, resolved);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error('plan_path_outside_root');
+    }
+    return resolved;
+}
+export function readVerifyJsonInputFile(projectRoot, inputPath, invalidCode) {
+    const inputFilePath = resolveVerifyInputPath(projectRoot, inputPath);
+    let content;
+    try {
+        content = readUtf8FileInsideWithoutSymlinks(projectRoot, inputFilePath);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('Path must not contain symlinks:')) {
+            throw new Error('input_path_contains_symlink');
+        }
+        throw new Error(invalidCode);
+    }
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        throw new Error(invalidCode);
+    }
+}
+export function readInputFromClassificationReport(projectRoot, inputPath) {
+    const parsed = readVerifyJsonInputFile(projectRoot, inputPath, 'invalid_plan_file');
+    const classificationReport = readStrictClassifyPlan(projectRoot, parsed);
+    return {
+        correlationId: readPlanCorrelationId(parsed) ?? createCorrelationId('verify'),
+        reasons: classificationReport.summary.validationReasons,
+        classificationReport,
+    };
+}
+export function createInputFromChanged(projectRoot) {
+    const plan = createClassifyOutput(projectRoot, 'changed', []);
+    return {
+        plan,
+        input: {
+            correlationId: plan.correlation_id,
+            reasons: plan.summary.validationReasons,
+            classificationReport: plan,
+        },
+    };
+}
+export function writeChangedPlan(projectRoot, inputPath, plan) {
+    const planPath = resolveVerifyInputPath(projectRoot, inputPath);
+    writeJsonFileInsideWithoutSymlinks(projectRoot, planPath, plan);
+}
+export function planErrorMessageKey(code) {
+    switch (code) {
+        case 'plan_path_outside_root':
+            return 'verify.error.plan_path_outside_root';
+        case 'input_path_contains_symlink':
+            return 'verify.error.input_path_contains_symlink';
+        case 'missing_plan_reasons':
+            return 'verify.error.missing_plan_reasons';
+        case 'unsupported_plan_source':
+            return 'verify.error.unsupported_plan_source';
+        case 'plan_root_mismatch':
+            return 'verify.error.plan_root_mismatch';
+        case 'git_changed_files_unavailable':
+            return 'verify.error.changed_files_unavailable';
+        default:
+            return 'verify.error.invalid_plan_file';
+    }
+}