cool-workflow 0.1.98 → 0.2.0

package/dist/pipeline-runner.js

@@ -1,285 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPipelineRunner = createPipelineRunner;
-exports.getRunContract = getRunContract;
-exports.getRunNode = getRunNode;
-exports.findRunnablePipelineStages = findRunnablePipelineStages;
-exports.advancePipeline = advancePipeline;
-exports.runPipelineStage = runPipelineStage;
-exports.failPipelineStage = failPipelineStage;
-const pipeline_contract_1 = require("./pipeline-contract");
-const state_1 = require("./state");
-const error_feedback_1 = require("./error-feedback");
-const state_node_1 = require("./state-node");
-function createPipelineRunner(defaultOptions = {}) {
-    return {
-        getRunContract: (run, contractId) => getRunContract(run, contractId || defaultOptions.contractId),
-        getRunNode,
-        findRunnablePipelineStages: (run, contract) => findRunnablePipelineStages(run, contract),
-        runPipelineStage: (run, stageId, inputNodeId, options = {}) => runPipelineStage(run, stageId, inputNodeId, { ...defaultOptions, ...options }),
-        advancePipeline: (run, options = {}) => advancePipeline(run, { ...defaultOptions, ...options }),
-        failPipelineStage
-    };
-}
-function getRunContract(run, contractId) {
-    const id = contractId || pipeline_contract_1.DEFAULT_PIPELINE_CONTRACT_ID;
-    const existing = (run.contracts || []).find((candidate) => candidate.id === id);
-    if (existing) {
-        (0, state_node_1.validatePipelineContract)(existing);
-        return existing;
-    }
-    if (id !== pipeline_contract_1.DEFAULT_PIPELINE_CONTRACT_ID) {
-        throw new Error(`Unknown pipeline contract for run ${run.id}: ${id}`);
-    }
-    return (0, state_node_1.upsertRunContract)(run, (0, pipeline_contract_1.createDefaultPipelineContract)());
-}
-function getRunNode(run, nodeId) {
-    const node = (run.nodes || []).find((candidate) => candidate.id === nodeId);
-    if (!node)
-        throw new Error(`Unknown state node for run ${run.id}: ${nodeId}`);
-    return node;
-}
-function findRunnablePipelineStages(run, contract = getRunContract(run)) {
-    (0, state_node_1.validatePipelineContract)(contract);
-    const runnable = [];
-    for (const node of run.nodes || []) {
-        for (const stage of contract.stages) {
-            if (!stage.acceptedInputKinds.includes(node.kind))
-                continue;
-            if (!stage.acceptedInputStatuses.includes(node.status))
-                continue;
-            if (!hasRequiredArtifacts(node, stage))
-                continue;
-            if (!hasRequiredEvidence(node, stage, contract))
-                continue;
-            if (!hasVerifierGate(node, stage, contract))
-                continue;
-            runnable.push({
-                runId: run.id,
-                contractId: contract.id,
-                stageId: stage.id,
-                inputNodeId: node.id,
-                outputKind: stage.producedOutputKind
-            });
-        }
-    }
-    return runnable;
-}
-function advancePipeline(run, options = {}) {
-    const contract = getRunContract(run, options.contractId);
-    const runnable = findRunnablePipelineStages(run, contract);
-    if (!runnable.length) {
-        return {
-            runId: run.id,
-            contractId: contract.id,
-            status: "idle",
-            stages: [],
-            runnable
-        };
-    }
-    const stages = [];
-    const autoAdvance = contract.failurePolicy?.autoAdvance ?? false;
-    for (const next of runnable) {
-        const result = runPipelineStage(run, next.stageId, next.inputNodeId, { ...options, contractId: contract.id });
-        stages.push(result);
-        if (result.status === "advanced") {
-            return { runId: run.id, contractId: contract.id, status: "advanced", stages, runnable };
-        }
-        if (!autoAdvance) {
-            return { runId: run.id, contractId: contract.id, status: "failed", stages, runnable };
-        }
-    }
-    return {
-        runId: run.id,
-        contractId: contract.id,
-        status: "failed",
-        stages,
-        runnable
-    };
-}
-function runPipelineStage(run, stageId, inputNodeId, options = {}) {
-    const contract = getRunContract(run, options.contractId);
-    const inputNode = getRunNode(run, inputNodeId);
-    const stage = getContractStage(contract, stageId);
-    try {
-        (0, state_node_1.assertNodeSatisfiesContract)(inputNode, contract, stageId);
-        const targetStatus = options.outputStatus || defaultOutputStatus(stage);
-        const outputNode = (0, state_node_1.createStateNode)({
-            id: options.outputNodeId,
-            kind: stage.producedOutputKind,
-            status: targetStatus === "committed" ? "verified" : "pending",
-            loopStage: options.loopStage || inputNode.loopStage,
-            inputs: {
-                inputNodeId: inputNode.id,
-                stageId: stage.id
-            },
-            outputs: options.outputs,
-            artifacts: options.artifacts,
-            evidence: options.evidence,
-            parents: [inputNode.id],
-            contractId: contract.id,
-            metadata: {
-                ...(options.metadata || {}),
-                pipelineStage: stage.id
-            }
-        });
-        const transitioned = (0, state_node_1.transitionStateNode)(outputNode, {
-            status: targetStatus,
-            loopStage: options.loopStage || outputNode.loopStage,
-            outputs: options.outputs,
-            artifacts: options.artifacts,
-            evidence: options.evidence,
-            metadata: options.metadata
-        });
-        const [linkedInput, linkedOutput] = (0, state_node_1.linkStateNodes)(inputNode, transitioned);
-        (0, state_node_1.appendRunNode)(run, linkedInput);
-        (0, state_node_1.appendRunNode)(run, linkedOutput);
-        if (shouldPersist(options))
-            (0, state_1.saveCheckpoint)(run);
-        return {
-            runId: run.id,
-            contractId: contract.id,
-            stageId,
-            inputNodeId,
-            outputNodeId: linkedOutput.id,
-            status: "advanced",
-            artifacts: linkedOutput.artifacts,
-            evidence: linkedOutput.evidence
-        };
-    }
-    catch (error) {
-        if (!isStructuredPipelineError(error))
-            throw error;
-        return failPipelineStage(run, stageId, inputNode, error, { ...options, contractId: contract.id });
-    }
-}
-function failPipelineStage(run, stageId, inputNode, error, options = {}) {
-    const contract = getRunContract(run, options.contractId);
-    const stage = getContractStage(contract, stageId);
-    const structured = toStateNodeError(error, inputNode.id, shouldRetry(stage, contract));
-    const preserve = options.preserveFailureNode ??
-        stage.failure?.preserveFailureNode ??
-        contract.failurePolicy?.preserveFailureNodes ??
-        false;
-    let failedNode = (0, state_node_1.recordNodeError)((0, state_node_1.createStateNode)({
-        id: options.outputNodeId,
-        kind: stage.failure?.failureKind || "error",
-        status: "pending",
-        loopStage: options.loopStage || inputNode.loopStage,
-        inputs: {
-            inputNodeId: inputNode.id,
-            stageId: stage.id
-        },
-        outputs: options.outputs,
-        artifacts: options.artifacts,
-        evidence: options.evidence,
-        parents: [inputNode.id],
-        contractId: contract.id,
-        metadata: {
-            ...(options.metadata || {}),
-            pipelineStage: stage.id,
-            preserved: preserve
-        }
-    }), structured);
-    if (preserve) {
-        const [linkedInput, linkedFailure] = (0, state_node_1.linkStateNodes)(inputNode, failedNode);
-        (0, state_node_1.appendRunNode)(run, linkedInput);
-        failedNode = (0, state_node_1.appendRunNode)(run, linkedFailure);
-        (0, error_feedback_1.recordFeedback)(run, {
-            source: "pipeline-runner",
-            error: failedNode.errors[failedNode.errors.length - 1],
-            nodeId: failedNode.id,
-            stageId,
-            contractId: contract.id,
-            path: structured.path,
-            retryable: structured.retryable,
-            evidence: failedNode.evidence,
-            artifacts: failedNode.artifacts,
-            metadata: {
-                inputNodeId: inputNode.id,
-                preservedFailureNode: true
-            }
-        }, { persist: false });
-        if (shouldPersist(options))
-            (0, state_1.saveCheckpoint)(run);
-    }
-    return {
-        runId: run.id,
-        contractId: contract.id,
-        stageId,
-        inputNodeId: inputNode.id,
-        outputNodeId: preserve ? failedNode.id : undefined,
-        status: "failed",
-        error: failedNode.errors[failedNode.errors.length - 1],
-        artifacts: failedNode.artifacts,
-        evidence: failedNode.evidence
-    };
-}
-function getContractStage(contract, stageId) {
-    (0, state_node_1.validatePipelineContract)(contract);
-    const stage = contract.stages.find((candidate) => candidate.id === stageId);
-    if (!stage)
-        throw new Error(`Unknown pipeline stage for contract ${contract.id}: ${stageId}`);
-    return stage;
-}
-function defaultOutputStatus(stage) {
-    if (stage.producedOutputKind === "commit")
-        return "committed";
-    return "completed";
-}
-function hasRequiredArtifacts(node, stage) {
-    for (const required of stage.requiredArtifacts || []) {
-        const artifact = node.artifacts.find((candidate) => candidate.id === required || candidate.kind === required);
-        if (!artifact)
-            return false;
-    }
-    return true;
-}
-function hasRequiredEvidence(node, stage, contract) {
-    if ((stage.requiredEvidence?.length || contract.evidencePolicy?.requireEvidence) && !node.evidence.length)
-        return false;
-    for (const required of stage.requiredEvidence || []) {
-        const evidence = node.evidence.find((candidate) => candidate.id === required || candidate.source === required);
-        if (!evidence)
-            return false;
-    }
-    return true;
-}
-function hasVerifierGate(node, stage, contract) {
-    const gate = stage.verifierGate;
-    const commitRequiresGate = contract.commitPolicy?.requiresVerifierGate && stage.producedOutputKind === "commit";
-    if (!gate?.required && !commitRequiresGate)
-        return true;
-    const acceptedStatuses = gate?.acceptedStatuses || contract.commitPolicy?.acceptedVerifierStatuses || ["verified"];
-    if (!acceptedStatuses.includes(node.status))
-        return false;
-    if ((gate?.requiredEvidence || contract.evidencePolicy?.requireEvidence) && !node.evidence.length)
-        return false;
-    return true;
-}
-function shouldPersist(options) {
-    return options.persist !== false;
-}
-function shouldRetry(stage, contract) {
-    return stage.failure?.retryable ?? contract.failurePolicy?.retryableByDefault ?? false;
-}
-function isStructuredPipelineError(error) {
-    return error instanceof state_node_1.PipelineContractError;
-}
-function toStateNodeError(error, nodeId, retryable) {
-    if (error instanceof state_node_1.PipelineContractError) {
-        return {
-            ...error.structured,
-            nodeId: error.structured.nodeId || nodeId,
-            retryable: error.structured.retryable ?? retryable
-        };
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-        code: "pipeline-stage-error",
-        message,
-        at: new Date().toISOString(),
-        nodeId,
-        retryable
-    };
-}

package/dist/reclamation/hash.js

@@ -1,72 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sha256OfString = sha256OfString;
-exports.sha256OfFile = sha256OfFile;
-exports.dirBytes = dirBytes;
-exports.contentDigest = contentDigest;
-// Content addressing + byte measurement for run reclamation (NO `du` — in-process
-// only). Carved out of reclamation.ts (FreeBSD-audit god-module carve) so the pure
-// content-addressing leaf no longer sits inside the write-ahead reclamation
-// transaction. These are pure functions of their path/string inputs — no run
-// state, no module-level mutable state.
-//
-// BEHAVIOR-PRESERVING — pure code movement, zero logic change. reclamation.ts
-// re-exports the public symbols (sha256OfString/sha256OfFile/dirBytes) so the
-// module's surface stays byte-identical.
-const node_crypto_1 = __importDefault(require("node:crypto"));
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const compare_1 = require("../compare");
-function sha256Hex(value) {
-    return node_crypto_1.default.createHash("sha256").update(value).digest("hex");
-}
-function sha256OfString(value) {
-    return `sha256:${sha256Hex(value)}`;
-}
-function sha256OfFile(file) {
-    return `sha256:${sha256Hex(node_fs_1.default.readFileSync(file))}`;
-}
-/** Walk a path and sum file sizes IN-PROCESS (no `du`). Returns 0 if absent. A
- *  file returns its own size; a dir returns the recursive sum. */
-function dirBytes(p) {
-    let total = 0;
-    let stat;
-    try {
-        stat = node_fs_1.default.statSync(p);
-    }
-    catch {
-        return 0;
-    }
-    if (stat.isFile())
-        return stat.size;
-    if (!stat.isDirectory())
-        return 0;
-    for (const entry of node_fs_1.default.readdirSync(p, { withFileTypes: true })) {
-        total += dirBytes(node_path_1.default.join(p, entry.name));
-    }
-    return total;
-}
-/** Stable content digest of a path (file = its bytes; dir = digest over each
- *  member's relative path + bytes, sorted). Lets the freed-manifest record a
- *  single sha per freed dir. */
-function contentDigest(p) {
-    const stat = node_fs_1.default.statSync(p);
-    if (stat.isFile())
-        return sha256OfFile(p);
-    const parts = [];
-    const walk = (dir, rel) => {
-        for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true }).sort((a, b) => (0, compare_1.compareBytes)(a.name, b.name))) {
-            const abs = node_path_1.default.join(dir, entry.name);
-            const r = node_path_1.default.join(rel, entry.name);
-            if (entry.isDirectory())
-                walk(abs, r);
-            else
-                parts.push(`${r}:${sha256OfFile(abs)}`);
-        }
-    };
-    walk(p, "");
-    return sha256OfString(parts.join("\n"));
-}