mustflow 2.69.0 → 2.74.0

package/dist/core/failure-replay-capsule.js

@@ -0,0 +1,213 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+function stableJson(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => stableJson(entry)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+        return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function sha256(value) {
+    return `sha256:${createHash('sha256').update(value).digest('hex')}`;
+}
+function sha256Json(value) {
+    return sha256(stableJson(value));
+}
+function uniqueSorted(values) {
+    return [...new Set([...values].filter((value) => typeof value === 'string' && value.length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function numberArray(values) {
+    return [...new Set([...values].filter((value) => typeof value === 'number' && Number.isFinite(value)))]
+        .sort((left, right) => left - right);
+}
+function objectField(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function stringField(record, key) {
+    const value = record?.[key];
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function numberField(record, key) {
+    const value = record?.[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function booleanField(record, key) {
+    return record?.[key] === true;
+}
+function stringArrayField(record, key) {
+    const value = record?.[key];
+    return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string' && entry.length > 0) : [];
+}
+function hashTail(output) {
+    const tail = stringField(output, 'tail');
+    return tail === null ? null : sha256(tail);
+}
+function isFailedResult(result) {
+    return (!result.skipped &&
+        result.intent !== null &&
+        (result.status === 'failed' ||
+            result.status === 'timed_out' ||
+            result.status === 'start_failed' ||
+            result.status === 'output_limit_exceeded'));
+}
+function createFailedResult(result) {
+    const receipt = result.receipt;
+    const performance = objectField(receipt?.performance);
+    const resultSummary = objectField(performance?.result_summary);
+    const stdout = objectField(receipt?.stdout);
+    const stderr = objectField(receipt?.stderr);
+    const stdoutTruncated = booleanField(stdout, 'truncated');
+    const stderrTruncated = booleanField(stderr, 'truncated');
+    const intent = result.intent;
+    return {
+        intent,
+        status: result.status,
+        exit_code: result.exit_code,
+        exit_code_class: stringField(resultSummary, 'exit_code_class'),
+        error_kind: stringField(resultSummary, 'error_kind'),
+        timed_out: result.status === 'timed_out' || booleanField(resultSummary, 'timed_out'),
+        receipt_path: result.receipt_path,
+        receipt_sha256: result.receipt_sha256,
+        command_fingerprint: stringField(performance, 'command_fingerprint'),
+        contract_fingerprint: stringField(performance, 'contract_fingerprint'),
+        stdout_tail_hash: hashTail(stdout),
+        stderr_tail_hash: hashTail(stderr),
+        output_truncated: stdoutTruncated || stderrTruncated,
+        replay_command: `mf run ${intent}`,
+    };
+}
+function fileFingerprint(projectRoot, relativePath) {
+    const normalized = relativePath.split(path.sep).join('/');
+    const absolute = path.resolve(projectRoot, ...normalized.split('/'));
+    const relativeToRoot = path.relative(projectRoot, absolute);
+    if (relativeToRoot.startsWith('..') || path.isAbsolute(relativeToRoot)) {
+        return {
+            path: normalized,
+            status: 'outside_root',
+            sha256: null,
+            bytes: null,
+        };
+    }
+    if (!existsSync(absolute)) {
+        return {
+            path: normalized,
+            status: 'missing',
+            sha256: null,
+            bytes: null,
+        };
+    }
+    try {
+        const stats = statSync(absolute);
+        if (!stats.isFile()) {
+            return {
+                path: normalized,
+                status: 'unreadable',
+                sha256: null,
+                bytes: null,
+            };
+        }
+        const content = readFileSync(absolute);
+        return {
+            path: normalized,
+            status: 'present',
+            sha256: sha256(content),
+            bytes: content.byteLength,
+        };
+    }
+    catch {
+        return {
+            path: normalized,
+            status: 'unreadable',
+            sha256: null,
+            bytes: null,
+        };
+    }
+}
+function changedFileFingerprints(projectRoot, report) {
+    return uniqueSorted(report.files)
+        .map((filePath) => fileFingerprint(projectRoot, filePath))
+        .sort((left, right) => left.path.localeCompare(right.path));
+}
+function redactionSummary(results) {
+    const redactionRecords = results
+        .map((result) => objectField(result.receipt?.redaction))
+        .filter((record) => record !== null);
+    const redactionCount = redactionRecords.reduce((sum, record) => sum + (numberField(record, 'redaction_count') ?? 0), 0);
+    return {
+        raw_output_included: false,
+        env_values_included: false,
+        receipt_paths_only: true,
+        redacted: redactionRecords.some((record) => booleanField(record, 'redacted')),
+        redaction_count: redactionCount,
+        redaction_kinds: uniqueSorted(redactionRecords.flatMap((record) => stringArrayField(record, 'redaction_kinds'))),
+        redaction_fields: uniqueSorted(redactionRecords.flatMap((record) => stringArrayField(record, 'fields'))),
+    };
+}
+function environmentSummary(results) {
+    const receipts = results.map((result) => result.receipt).filter((receipt) => receipt !== null);
+    const runners = receipts
+        .map((receipt) => objectField(objectField(receipt.performance)?.runner))
+        .filter((runner) => runner !== null);
+    return {
+        platform_family: uniqueSorted(runners.map((runner) => stringField(runner, 'platform_family')))[0] ?? null,
+        arch_family: uniqueSorted(runners.map((runner) => stringField(runner, 'arch_family')))[0] ?? null,
+        runtimes: uniqueSorted(runners.map((runner) => {
+            const runtime = stringField(runner, 'runtime');
+            const major = numberField(runner, 'runtime_major');
+            return runtime === null ? null : `${runtime}${major === null ? '' : `@${major}`}`;
+        })),
+        env_policies: uniqueSorted(receipts.map((receipt) => stringField(receipt, 'env_policy'))),
+        env_allowlist: uniqueSorted(receipts.flatMap((receipt) => stringArrayField(receipt, 'env_allowlist'))),
+        timeout_seconds: numberArray(receipts.map((receipt) => numberField(receipt, 'timeout_seconds'))),
+    };
+}
+function riskCodes(report) {
+    return uniqueSorted([
+        ...report.risk_assessment.reasons,
+        ...report.risk_assessment.blocking_gaps,
+        ...report.gaps.map((gap) => gap.reason),
+    ]);
+}
+export function createFailureReplayCapsule(input) {
+    const failedResults = input.results.filter(isFailedResult).map(createFailedResult);
+    if (failedResults.length === 0) {
+        return null;
+    }
+    const affectedFiles = changedFileFingerprints(input.projectRoot, input.report);
+    const affectedSurfaces = uniqueSorted(input.report.requirements.flatMap((requirement) => requirement.surfaces));
+    const replayCommands = uniqueSorted([
+        ...failedResults.map((result) => result.replay_command),
+        `mf verify --reason ${input.reasons[0] ?? 'unknown'} --json`,
+    ]);
+    const base = {
+        schema_version: '1',
+        source: 'mf_verify_failure',
+        authority: 'replay_supporting_evidence',
+        created_at: (input.createdAt ?? new Date()).toISOString(),
+        verification_plan_id: input.verificationPlanId,
+        failure_fingerprint: input.failureFingerprint?.fingerprint ?? null,
+        reasons: uniqueSorted(input.reasons),
+        status: input.status,
+        replay_commands: replayCommands,
+        failed_results: failedResults,
+        affected_files: affectedFiles,
+        affected_surfaces: affectedSurfaces,
+        risk_codes: riskCodes(input.report),
+        environment: environmentSummary(input.results),
+        privacy: redactionSummary(input.results),
+    };
+    return {
+        ...base,
+        hashes: {
+            capsule_fingerprint: sha256Json(base),
+            changed_files_hash: sha256Json(affectedFiles),
+            failed_results_hash: sha256Json(failedResults),
+            command_fingerprints_hash: sha256Json(failedResults.map((result) => result.command_fingerprint)),
+            output_tails_hash: sha256Json(failedResults.flatMap((result) => [result.stdout_tail_hash, result.stderr_tail_hash])),
+        },
+    };
+}

package/dist/core/public-json-contracts.js

@@ -207,6 +207,33 @@ const PUBLIC_JSON_SCHEMA_CONTRACTS = [
         installedCommand: ['mf', 'quality', 'check', '--json'],
         expectedExitCodes: [0, 1],
     },
+    {
+        id: 'script-pack-catalog',
+        schemaFile: 'script-pack-catalog.schema.json',
+        producer: 'mf script-pack list --json',
+        packaged: true,
+        documented: true,
+        installedCommand: ['mf', 'script-pack', 'list', '--json'],
+    },
+    {
+        id: 'text-budget-report',
+        schemaFile: 'text-budget-report.schema.json',
+        producer: 'mf script-pack run core/text-budget check <path...> --json',
+        packaged: true,
+        documented: true,
+        installedCommand: [
+            'mf',
+            'script-pack',
+            'run',
+            'core/text-budget',
+            'check',
+            'AGENTS.md',
+            '--max',
+            '1000000',
+            '--json',
+        ],
+        expectedExitCodes: [0, 1],
+    },
     {
         id: 'skill-route-report',
         schemaFile: 'skill-route-report.schema.json',

package/dist/core/risk-priced-evidence.js

@@ -0,0 +1,213 @@
+import { isRecord, readString, readStringArray } from './config-loading.js';
+const LEVEL_RANK = {
+    low: 0,
+    medium: 1,
+    high: 2,
+    critical: 3,
+};
+const HIGH_RISK_REASONS = new Set([
+    'public_api_change',
+    'package_metadata_change',
+    'template_version_change',
+    'packaging_change',
+    'release_risk',
+    'before_publish',
+    'security_change',
+    'privacy_change',
+    'data_change',
+    'mustflow_config_change',
+    'mustflow_docs_change',
+    'auth_permission_change',
+    'deployment_change',
+]);
+const CRITICAL_RISK_REASONS = new Set([
+    'database_migration',
+    'database_migration_change',
+    'migration_change',
+    'secret_exposure',
+    'secret_change',
+    'destructive_change',
+]);
+const MEDIUM_RISK_REASONS = new Set([
+    'code_change',
+    'behavior_change',
+    'test_change',
+    'unknown_change',
+    'performance_change',
+    'ui_change',
+    'build_config_change',
+    'dependency_change',
+]);
+const HIGH_RISK_TEXT = [
+    'auth',
+    'authorization',
+    'permission',
+    'security',
+    'privacy',
+    'pii',
+    'token',
+    'credential',
+    'payment',
+    'refund',
+    'ledger',
+    'billing',
+    'public api',
+    'json schema',
+    'machine-readable output',
+    'package',
+    'release',
+    'deployment',
+    'production',
+    'data contract',
+];
+const CRITICAL_RISK_TEXT = [
+    'destructive',
+    'delete',
+    'drop table',
+    'secret',
+    'credential',
+    'private key',
+    'database migration',
+    'payment settlement',
+    'ledger mutation',
+];
+function uniqueSorted(values) {
+    return [...new Set([...values].filter((value) => typeof value === 'string' && value.length > 0))].sort((left, right) => left.localeCompare(right));
+}
+function maxLevel(left, right) {
+    return LEVEL_RANK[right] > LEVEL_RANK[left] ? right : left;
+}
+function includesAnySignal(values, signals) {
+    const normalizedValues = values.map((value) => value.toLowerCase());
+    return signals.some((signal) => normalizedValues.some((value) => value.includes(signal)));
+}
+function readBoolean(record, key) {
+    return typeof record[key] === 'boolean' ? record[key] : null;
+}
+function selectedIntentRecords(input) {
+    return input.selectedIntents
+        .map((intent) => input.commandContract.intents[intent])
+        .filter((intent) => isRecord(intent));
+}
+function intentHasDeleteEffect(intent) {
+    if (!Array.isArray(intent.effects)) {
+        return false;
+    }
+    return intent.effects.some((effect) => isRecord(effect) && readString(effect, 'mode') === 'delete_recreate');
+}
+function classifyReasonSignals(input) {
+    let level = 'low';
+    const reasons = [];
+    const validationReasons = input.classificationSummary.validationReasons;
+    const signalText = uniqueSorted([
+        ...validationReasons,
+        ...input.classificationSummary.changeKinds,
+        ...input.classificationSummary.affectedContracts,
+        ...input.classificationSummary.driftChecks,
+        ...input.requirements.flatMap((requirement) => [
+            requirement.reason,
+            ...requirement.surfaces,
+            ...requirement.affectedContracts,
+            ...requirement.driftChecks,
+        ]),
+    ]);
+    for (const reason of validationReasons) {
+        if (CRITICAL_RISK_REASONS.has(reason)) {
+            level = maxLevel(level, 'critical');
+            reasons.push(`critical validation reason: ${reason}`);
+        }
+        else if (HIGH_RISK_REASONS.has(reason)) {
+            level = maxLevel(level, 'high');
+            reasons.push(`high validation reason: ${reason}`);
+        }
+        else if (MEDIUM_RISK_REASONS.has(reason)) {
+            level = maxLevel(level, 'medium');
+            reasons.push(`medium validation reason: ${reason}`);
+        }
+    }
+    if (includesAnySignal(signalText, CRITICAL_RISK_TEXT)) {
+        level = maxLevel(level, 'critical');
+        reasons.push('critical contract or surface signal');
+    }
+    else if (includesAnySignal(signalText, HIGH_RISK_TEXT)) {
+        level = maxLevel(level, 'high');
+        reasons.push('high contract or surface signal');
+    }
+    if (input.gaps.length > 0) {
+        level = maxLevel(level, 'high');
+        reasons.push('verification gaps exist');
+    }
+    if (level === 'low' && input.classificationSummary.publicSurfaceCount > 0 && validationReasons.length > 0) {
+        reasons.push('public surface changed but no high-risk trigger matched');
+    }
+    return { level, reasons: uniqueSorted(reasons) };
+}
+function classifyCommandSignals(input) {
+    let level = 'low';
+    const reasons = [];
+    for (const intent of selectedIntentRecords(input)) {
+        const intentName = readString(intent, 'name') ?? null;
+        const label = intentName ?? 'selected intent';
+        if (readBoolean(intent, 'destructive') === true) {
+            level = maxLevel(level, 'critical');
+            reasons.push(`${label} is destructive`);
+        }
+        if (readBoolean(intent, 'network') === true) {
+            level = maxLevel(level, 'high');
+            reasons.push(`${label} uses network`);
+        }
+        if (intentHasDeleteEffect(intent)) {
+            level = maxLevel(level, 'medium');
+            reasons.push(`${label} rewrites declared output paths`);
+        }
+        if ((readStringArray(intent, 'writes') ?? []).length > 0) {
+            level = maxLevel(level, 'medium');
+            reasons.push(`${label} writes files`);
+        }
+    }
+    return { level, reasons: uniqueSorted(reasons) };
+}
+function requiredEvidence(level) {
+    if (level === 'critical') {
+        return [
+            'configured_mf_run_receipt',
+            'receipt_bound_to_current_plan',
+            'synchronized_contract_surfaces',
+            'rollback_or_recovery_plan',
+            'manual_approval_record',
+            'remaining_risk_review',
+        ];
+    }
+    if (level === 'high') {
+        return [
+            'configured_mf_run_receipt',
+            'receipt_bound_to_current_plan',
+            'synchronized_contract_surfaces',
+            'remaining_risk_review',
+        ];
+    }
+    if (level === 'medium') {
+        return ['configured_mf_run_receipt', 'related_or_declared_verification'];
+    }
+    return ['changed_file_review'];
+}
+export function riskPricedEvidenceRiskCount(assessment) {
+    return assessment.level === 'high' || assessment.level === 'critical' ? 1 : 0;
+}
+export function createVerificationRiskAssessment(input) {
+    const reasonSignals = classifyReasonSignals(input);
+    const commandSignals = classifyCommandSignals(input);
+    const level = maxLevel(reasonSignals.level, commandSignals.level);
+    const blockingGaps = input.gaps.map((gap) => `${gap.reason}: ${gap.detail}`);
+    return {
+        schema_version: '1',
+        source: 'change_classification_and_command_contract',
+        level,
+        reasons: uniqueSorted([...reasonSignals.reasons, ...commandSignals.reasons]),
+        required_evidence: requiredEvidence(level),
+        blocking_gaps: blockingGaps,
+        rollback_required: level === 'critical',
+        human_approval_required: level === 'critical',
+        manual_review_required: level === 'high' || level === 'critical',
+    };
+}

package/dist/core/script-check-result.js

@@ -0,0 +1 @@
+export {};