@diff-review-system/drs 4.0.1 → 4.1.0

package/dist/lib/workflow/planning.js

@@ -0,0 +1,814 @@
+export function getNodeNeeds(node) {
+    if (node.needs === undefined) {
+        return [];
+    }
+    if (!Array.isArray(node.needs)) {
+        throw new Error('Workflow node "needs" must be an array of node ids.');
+    }
+    return node.needs;
+}
+export function getControlTargets(node) {
+    const targets = [];
+    if (node.target)
+        targets.push(node.target);
+    if (node.exit)
+        targets.push(node.exit);
+    if (node.default)
+        targets.push(node.default);
+    if (node.cases)
+        targets.push(...Object.values(node.cases));
+    return targets;
+}
+export function validateWorkflowControlTargets(nodes) {
+    for (const [nodeId, node] of Object.entries(nodes)) {
+        for (const target of getControlTargets(node)) {
+            if (!nodes[target]) {
+                throw new Error(`Workflow node "${nodeId}" targets unknown node "${target}".`);
+            }
+        }
+    }
+}
+export function validateWorkflowControlRouteDirection(nodes, executionOrder) {
+    const segments = splitWorkflowSegments(nodes, executionOrder);
+    for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex++) {
+        const segment = segments[segmentIndex];
+        if (segment.type !== 'control') {
+            continue;
+        }
+        const node = nodes[segment.nodeId];
+        if (!node || node.control === 'loop') {
+            continue;
+        }
+        for (const target of getControlTargets(node)) {
+            const targetIndex = findWorkflowSegmentIndex(segments, target);
+            if (targetIndex <= segmentIndex) {
+                throw new Error(`Workflow control node "${segment.nodeId}" cannot jump backward to "${target}". Use control: loop with maxIterations for repeated execution.`);
+            }
+        }
+    }
+}
+export function validateWorkflowPassThroughShape(nodeId, node) {
+    if (node.control !== 'passThrough') {
+        return;
+    }
+    if (!node.target) {
+        throw new Error(`Workflow passThrough node "${nodeId}" must define "target".`);
+    }
+    const forbiddenKeys = [
+        'if',
+        'then',
+        'else',
+        'exit',
+        'cases',
+        'default',
+        'maxIterations',
+        'onMaxIterations',
+        'value',
+    ];
+    const extraFields = forbiddenKeys.filter((key) => key in node);
+    if (extraFields.length > 0) {
+        throw new Error(`Workflow passThrough node "${nodeId}" must not define extra control logic: ${extraFields.join(', ')}.`);
+    }
+}
+export const WORKFLOW_NODE_FIELDS = new Set([
+    'agent',
+    'agentsFrom',
+    'control',
+    'action',
+    'with',
+    'needs',
+    'if',
+    'target',
+    'exit',
+    'maxIterations',
+    'onMaxIterations',
+    'value',
+    'cases',
+    'default',
+    'input',
+    'output',
+    'writes',
+    'json',
+]);
+export const EXECUTABLE_NODE_FIELDS = new Set([
+    'agent',
+    'agentsFrom',
+    'action',
+    'with',
+    'needs',
+    'if',
+    'input',
+    'output',
+    'writes',
+    'json',
+]);
+export const CONTROL_NODE_FIELDS = {
+    loop: new Set([
+        'control',
+        'needs',
+        'if',
+        'target',
+        'exit',
+        'maxIterations',
+        'onMaxIterations',
+        'output',
+    ]),
+    switch: new Set(['control', 'needs', 'value', 'cases', 'default', 'output']),
+    end: new Set(['control', 'needs', 'output']),
+    passThrough: new Set(['control', 'needs', 'target', 'output']),
+};
+export const ACTION_OPTION_FIELDS = {
+    write: new Set(),
+    'git-diff': new Set(['staged']),
+    'git-add': new Set(['path', 'paths']),
+    'git-branch': new Set(['name', 'from', 'force']),
+    'git-commit': new Set(['message', 'path', 'paths']),
+    'git-push': new Set(['remote', 'branch', 'remoteBranch', 'setUpstream', 'force']),
+    'has-diff': new Set(['path', 'paths']),
+    'stack-guard': new Set(['source', 'allowStackedSource', 'reservedPrefixes']),
+    'review-threshold': new Set(['review', 'severity', 'minIssues']),
+    'save-artifact': new Set([
+        'kind',
+        'source',
+        'artifact',
+        'payload',
+        'platform',
+        'project',
+        'projectId',
+        'owner',
+        'repo',
+        'subject',
+        'changeKind',
+        'changeNumber',
+        'pr',
+        'mr',
+        'branch',
+    ]),
+    'load-artifact': new Set([
+        'kind',
+        'source',
+        'id',
+        'platform',
+        'project',
+        'projectId',
+        'owner',
+        'repo',
+        'subject',
+        'changeKind',
+        'changeNumber',
+        'pr',
+        'mr',
+        'branch',
+    ]),
+    'artifact-exists': new Set([
+        'kind',
+        'source',
+        'id',
+        'platform',
+        'project',
+        'projectId',
+        'owner',
+        'repo',
+        'subject',
+        'changeKind',
+        'changeNumber',
+        'pr',
+        'mr',
+        'branch',
+    ]),
+    'create-review-artifact': new Set(['source', 'review']),
+    'review-artifact-status': new Set(['artifact']),
+    'review-artifact-add-finding': new Set(['artifact', 'issue', 'source']),
+    'review-artifact-update-findings': new Set([
+        'artifact',
+        'state',
+        'disposition',
+        'ids',
+        'fingerprints',
+        'severity',
+    ]),
+    'review-artifact-promote-finding': new Set(['artifact', 'ids', 'fingerprints', 'severity']),
+    'review-artifact-resolve-finding': new Set(['artifact', 'ids', 'fingerprints', 'severity']),
+    'verify-fix': new Set(['artifact', 'review', 'fixChange', 'severity', 'minIssues']),
+    'create-change-request': new Set([
+        'platform',
+        'owner',
+        'repo',
+        'project',
+        'projectId',
+        'sourceBranch',
+        'head',
+        'targetBranch',
+        'base',
+        'title',
+        'body',
+        'draft',
+        'reuseExisting',
+    ]),
+    'create-pr': new Set([
+        'platform',
+        'owner',
+        'repo',
+        'project',
+        'projectId',
+        'sourceBranch',
+        'head',
+        'targetBranch',
+        'base',
+        'title',
+        'body',
+        'draft',
+        'reuseExisting',
+    ]),
+    'create-mr': new Set([
+        'platform',
+        'owner',
+        'repo',
+        'project',
+        'projectId',
+        'sourceBranch',
+        'head',
+        'targetBranch',
+        'base',
+        'title',
+        'body',
+        'draft',
+        'reuseExisting',
+    ]),
+    'change-source': new Set([
+        'type',
+        'staged',
+        'from',
+        'to',
+        'includePrereleaseFrom',
+        'owner',
+        'repo',
+        'pr',
+        'project',
+        'projectId',
+        'mr',
+        'mrIid',
+        'source',
+        'fixChange',
+    ]),
+    review: new Set(['source', 'reviewArtifact', 'severity', 'artifact']),
+    'review-context': new Set(['source', 'file', 'baseBranch']),
+    describe: new Set(['source', 'post', 'postDescription']),
+    'code-quality-report': new Set(['review', 'path']),
+    'post-comment': new Set([
+        'source',
+        'platform',
+        'owner',
+        'repo',
+        'project',
+        'projectId',
+        'pr',
+        'mr',
+        'prNumber',
+        'mrIid',
+        'body',
+        'marker',
+    ]),
+    'post-review-comments': new Set(['source', 'review', 'removeErrorComment']),
+    'post-fix-status': new Set([
+        'platform',
+        'owner',
+        'repo',
+        'project',
+        'projectId',
+        'pr',
+        'mr',
+        'source',
+        'reviewArtifact',
+        'fixReview',
+        'fixChange',
+        'severity',
+        'stackedPrUrl',
+        'marker',
+    ]),
+};
+export function validateAllowedFields(nodeId, value, allowed, subject) {
+    const unknownFields = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unknownFields.length > 0) {
+        throw new Error(`Workflow ${subject} "${nodeId}" has unsupported field(s): ${unknownFields.join(', ')}.`);
+    }
+}
+export function validateWorkflowNodeShape(nodeId, node) {
+    validateAllowedFields(nodeId, node, WORKFLOW_NODE_FIELDS, 'node');
+    const kind = getNodeKind(node);
+    if (kind === 'control') {
+        const control = node.control;
+        if (!control || !CONTROL_NODE_FIELDS[control]) {
+            throw new Error(`Workflow control node "${nodeId}" has unsupported control "${String(control)}".`);
+        }
+        validateAllowedFields(nodeId, node, CONTROL_NODE_FIELDS[control], 'control node');
+        return;
+    }
+    validateAllowedFields(nodeId, node, EXECUTABLE_NODE_FIELDS, 'node');
+    if (node.action && node.with) {
+        const allowed = ACTION_OPTION_FIELDS[node.action];
+        if (!allowed) {
+            throw new Error(`Workflow action node "${nodeId}" has unsupported action "${node.action}".`);
+        }
+        validateAllowedFields(nodeId, node.with, allowed, `node "${nodeId}" with`);
+    }
+}
+export function validateWorkflowNodeKinds(nodes) {
+    for (const [nodeId, node] of Object.entries(nodes)) {
+        validateWorkflowNodeShape(nodeId, node);
+        validateWorkflowPassThroughShape(nodeId, node);
+    }
+}
+export function hasWorkflowControlNodes(nodes) {
+    return Object.values(nodes).some((node) => node.control !== undefined);
+}
+export function getWorkflowExecutionOrder(nodes) {
+    const nodeIds = Object.keys(nodes);
+    const visiting = new Set();
+    const visited = new Set();
+    const order = [];
+    function visit(nodeId) {
+        if (visited.has(nodeId)) {
+            return;
+        }
+        if (visiting.has(nodeId)) {
+            throw new Error(`Workflow contains a dependency cycle at node "${nodeId}".`);
+        }
+        const node = nodes[nodeId];
+        if (!node) {
+            throw new Error(`Workflow references unknown node "${nodeId}".`);
+        }
+        visiting.add(nodeId);
+        for (const dependency of getNodeNeeds(node)) {
+            if (!nodes[dependency]) {
+                throw new Error(`Workflow node "${nodeId}" needs unknown node "${dependency}".`);
+            }
+            visit(dependency);
+        }
+        visiting.delete(nodeId);
+        visited.add(nodeId);
+        order.push(nodeId);
+    }
+    for (const nodeId of nodeIds) {
+        visit(nodeId);
+    }
+    validateWorkflowNodeKinds(nodes);
+    validateWorkflowControlTargets(nodes);
+    const standaloneEndNodes = order.filter((nodeId) => nodes[nodeId]?.control === 'end' && getNodeNeeds(nodes[nodeId] ?? {}).length === 0);
+    const nonStandaloneEndNodes = order.filter((nodeId) => !standaloneEndNodes.includes(nodeId));
+    const executionOrder = [...nonStandaloneEndNodes, ...standaloneEndNodes];
+    validateWorkflowControlRouteDirection(nodes, executionOrder);
+    return executionOrder;
+}
+export function getWorkflowNodes(workflowName, workflow) {
+    const nodes = workflow.nodes;
+    if (typeof nodes !== 'object' ||
+        nodes === null ||
+        Array.isArray(nodes) ||
+        Object.keys(nodes).length === 0) {
+        throw new Error(`Workflow "${workflowName}" must define at least one node.`);
+    }
+    return nodes;
+}
+export function getWorkflowExecutionWaves(nodes, executionOrder) {
+    const depthByNode = new Map();
+    const waves = [];
+    for (const nodeId of executionOrder) {
+        const node = nodes[nodeId];
+        if (!node) {
+            throw new Error(`Workflow references unknown node "${nodeId}".`);
+        }
+        const depth = getNodeNeeds(node).reduce((maxDepth, dependency) => {
+            return Math.max(maxDepth, (depthByNode.get(dependency) ?? 0) + 1);
+        }, 0);
+        depthByNode.set(nodeId, depth);
+        waves[depth] = waves[depth] ?? [];
+        waves[depth].push(nodeId);
+    }
+    return waves;
+}
+export function getPathValue(root, path) {
+    return path.split('.').reduce((current, part) => {
+        if (current === undefined || current === null) {
+            return undefined;
+        }
+        if (typeof current !== 'object') {
+            return undefined;
+        }
+        return current[part];
+    }, root);
+}
+export function stringifyTemplateValue(value) {
+    if (value === undefined) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    return JSON.stringify(value, null, 2);
+}
+export function renderTemplate(template, context) {
+    return template.replace(/\{\{\s*([^}]+?)\s*\}\}/g, (_match, rawPath) => {
+        const path = rawPath.trim();
+        const value = getPathValue(context, path);
+        if (value === undefined) {
+            throw new Error(`Unknown workflow template value "{{${path}}}".`);
+        }
+        return stringifyTemplateValue(value);
+    });
+}
+export function getNodeKind(node) {
+    const configuredKinds = [node.agent, node.agentsFrom, node.action, node.control].filter((value) => value !== undefined).length;
+    if (configuredKinds !== 1) {
+        throw new Error('Workflow node must define exactly one of agent, agentsFrom, action, or control.');
+    }
+    if (node.agent !== undefined)
+        return 'agent';
+    if (node.agentsFrom !== undefined)
+        return 'agents';
+    if (node.control !== undefined)
+        return 'control';
+    return 'action';
+}
+export function parseWorkflowExpressionValue(value, context) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return '';
+    const templateReference = trimmed.match(/^\{\{\s*([^}]+?)\s*\}\}$/);
+    if (templateReference && context) {
+        const path = templateReference[1]?.trim() ?? '';
+        const resolved = getPathValue(context, path);
+        if (resolved === undefined) {
+            throw new Error(`Unknown workflow template value "{{${path}}}".`);
+        }
+        return resolved;
+    }
+    if (trimmed === 'true')
+        return true;
+    if (trimmed === 'false')
+        return false;
+    if (trimmed === 'null')
+        return null;
+    if (/^-?\d+(\.\d+)?$/.test(trimmed))
+        return Number(trimmed);
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        const inner = trimmed.slice(1, -1);
+        return context ? renderTemplate(inner, context) : inner;
+    }
+    if (context && /^(inputs|nodes|artifacts|loop)\.[A-Za-z0-9_.-]+$/.test(trimmed)) {
+        const resolved = getPathValue(context, trimmed);
+        if (resolved === undefined) {
+            throw new Error(`Unknown workflow expression value "${trimmed}".`);
+        }
+        return resolved;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return trimmed;
+    }
+}
+export function isWorkflowTruthy(value) {
+    if (value === undefined || value === null)
+        return false;
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return value !== 0;
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        return (normalized.length > 0 && normalized !== 'false' && normalized !== '0' && normalized !== 'no');
+    }
+    if (Array.isArray(value))
+        return value.length > 0;
+    if (typeof value === 'object')
+        return Object.keys(value).length > 0;
+    return true;
+}
+export function normalizeWorkflowBooleanLike(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number') {
+        if (value === 1)
+            return true;
+        if (value === 0)
+            return false;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'true' || normalized === '1' || normalized === 'yes')
+            return true;
+        if (normalized === 'false' || normalized === '0' || normalized === 'no')
+            return false;
+    }
+    return undefined;
+}
+export function compareWorkflowValues(left, operator, right) {
+    if (operator === '==' || operator === '!=') {
+        const leftBoolean = normalizeWorkflowBooleanLike(left);
+        const rightBoolean = normalizeWorkflowBooleanLike(right);
+        const matches = leftBoolean !== undefined || rightBoolean !== undefined
+            ? leftBoolean === rightBoolean
+            : String(left) === String(right);
+        return operator === '==' ? matches : !matches;
+    }
+    const leftNumber = Number(left);
+    const rightNumber = Number(right);
+    if (!Number.isFinite(leftNumber) || !Number.isFinite(rightNumber)) {
+        throw new Error(`Workflow expression operator "${operator}" requires numeric values.`);
+    }
+    if (operator === '>')
+        return leftNumber > rightNumber;
+    if (operator === '>=')
+        return leftNumber >= rightNumber;
+    if (operator === '<')
+        return leftNumber < rightNumber;
+    if (operator === '<=')
+        return leftNumber <= rightNumber;
+    throw new Error(`Unsupported workflow expression operator "${operator}".`);
+}
+export function splitWorkflowExpressionOperator(expression, operator) {
+    const parts = [];
+    let current = '';
+    let quote;
+    let depth = 0;
+    for (let i = 0; i < expression.length; i++) {
+        const char = expression[i] ?? '';
+        if ((char === '"' || char === "'") && expression[i - 1] !== '\\') {
+            quote = quote === char ? undefined : (quote ?? char);
+            current += char;
+            continue;
+        }
+        if (!quote && char === '(') {
+            depth += 1;
+            current += char;
+            continue;
+        }
+        if (!quote && char === ')' && depth > 0) {
+            depth -= 1;
+            current += char;
+            continue;
+        }
+        if (!quote && depth === 0 && expression.slice(i, i + operator.length) === operator) {
+            parts.push(current.trim());
+            current = '';
+            i += operator.length - 1;
+            continue;
+        }
+        current += char;
+    }
+    parts.push(current.trim());
+    return parts;
+}
+export function stripWorkflowExpressionParens(expression) {
+    const trimmed = expression.trim();
+    if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) {
+        return trimmed;
+    }
+    let quote;
+    let depth = 0;
+    for (let i = 0; i < trimmed.length; i++) {
+        const char = trimmed[i] ?? '';
+        if ((char === '"' || char === "'") && trimmed[i - 1] !== '\\') {
+            quote = quote === char ? undefined : (quote ?? char);
+            continue;
+        }
+        if (quote)
+            continue;
+        if (char === '(')
+            depth += 1;
+        if (char === ')')
+            depth -= 1;
+        if (depth === 0 && i < trimmed.length - 1) {
+            return trimmed;
+        }
+    }
+    return trimmed.slice(1, -1).trim();
+}
+export function evaluateWorkflowExpressionText(rendered, context) {
+    rendered = stripWorkflowExpressionParens(rendered);
+    const orParts = splitWorkflowExpressionOperator(rendered, '||');
+    if (orParts.length > 1) {
+        return orParts.some((part) => evaluateWorkflowExpressionText(part, context));
+    }
+    const andParts = splitWorkflowExpressionOperator(rendered, '&&');
+    if (andParts.length > 1) {
+        return andParts.every((part) => evaluateWorkflowExpressionText(part, context));
+    }
+    const match = rendered.match(/^(.+?)\s*(==|!=|>=|<=|>|<)\s*(.+)$/);
+    if (!match) {
+        return isWorkflowTruthy(parseWorkflowExpressionValue(rendered, context));
+    }
+    return compareWorkflowValues(parseWorkflowExpressionValue(match[1] ?? '', context), match[2] ?? '', parseWorkflowExpressionValue(match[3] ?? '', context));
+}
+export function evaluateWorkflowExpression(expression, context) {
+    return evaluateWorkflowExpressionText(expression.trim(), context);
+}
+export function splitWorkflowSegments(workflowNodes, executionOrder) {
+    const segments = [];
+    let currentDag = [];
+    for (const nodeId of executionOrder) {
+        const node = workflowNodes[nodeId];
+        if (!node) {
+            throw new Error(`Workflow references unknown node "${nodeId}".`);
+        }
+        if (node.control !== undefined) {
+            if (currentDag.length > 0) {
+                segments.push({ type: 'dag', nodeIds: currentDag });
+                currentDag = [];
+            }
+            segments.push({ type: 'control', nodeId });
+        }
+        else {
+            currentDag.push(nodeId);
+        }
+    }
+    if (currentDag.length > 0) {
+        segments.push({ type: 'dag', nodeIds: currentDag });
+    }
+    return segments;
+}
+export function findWorkflowSegmentIndex(segments, targetNodeId) {
+    return segments.findIndex((segment) => segment.type === 'control'
+        ? segment.nodeId === targetNodeId
+        : segment.nodeIds.includes(targetNodeId));
+}
+export function computeActiveWorkflowNodes(workflowNodes, nodeIds, rootNodeId, includeRootDependencies = true) {
+    const segmentNodeIds = new Set(nodeIds);
+    const downstream = new Set([rootNodeId]);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const nodeId of nodeIds) {
+            if (downstream.has(nodeId))
+                continue;
+            const needs = getNodeNeeds(workflowNodes[nodeId] ?? {});
+            if (needs.some((dependency) => downstream.has(dependency))) {
+                downstream.add(nodeId);
+                changed = true;
+            }
+        }
+    }
+    const active = new Set(downstream);
+    const includeDependencies = (nodeId) => {
+        const node = workflowNodes[nodeId];
+        if (!node)
+            return;
+        for (const dependency of getNodeNeeds(node)) {
+            if (!segmentNodeIds.has(dependency) || active.has(dependency))
+                continue;
+            active.add(dependency);
+            includeDependencies(dependency);
+        }
+    };
+    if (includeRootDependencies) {
+        for (const nodeId of downstream) {
+            includeDependencies(nodeId);
+        }
+    }
+    return active;
+}
+export function runControlWorkflowNode(nodeId, node, context) {
+    if (node.control === 'loop') {
+        const expression = node.if;
+        if (!expression) {
+            throw new Error(`Workflow loop node "${nodeId}" must define if.`);
+        }
+        if (!node.target || !node.exit) {
+            throw new Error(`Workflow loop node "${nodeId}" must define target and exit.`);
+        }
+        const rawMaxIterations = node.maxIterations;
+        const renderedMaxIterations = typeof rawMaxIterations === 'string'
+            ? renderTemplate(rawMaxIterations, context).trim()
+            : String(rawMaxIterations ?? '');
+        const configuredMaxIterations = Number.parseInt(renderedMaxIterations, 10);
+        if (renderedMaxIterations === '' ||
+            !Number.isInteger(configuredMaxIterations) ||
+            configuredMaxIterations <= 0) {
+            throw new Error(`Workflow loop node "${nodeId}" must define a positive maxIterations.`);
+        }
+        const maxIterations = configuredMaxIterations;
+        const shouldLoop = evaluateWorkflowExpression(expression, context);
+        const current = context.loop[nodeId] ?? { iteration: 1, maxIterations };
+        let nextNodeId = node.exit;
+        let decision = 'exit';
+        if (shouldLoop) {
+            if (current.iteration >= maxIterations) {
+                if (node.onMaxIterations === 'exit') {
+                    nextNodeId = node.exit;
+                }
+                else {
+                    throw new Error(`Workflow loop node "${nodeId}" reached maxIterations (${maxIterations}).`);
+                }
+            }
+            else {
+                decision = 'loop';
+                nextNodeId = node.target;
+                current.iteration += 1;
+            }
+        }
+        current.maxIterations = maxIterations;
+        current.lastDecision = decision;
+        context.loop[nodeId] = current;
+        return {
+            nextNodeId,
+            result: {
+                id: nodeId,
+                type: 'control',
+                status: 'success',
+                control: node.control,
+                decision,
+                target: nextNodeId,
+                response: decision,
+                output: {
+                    matched: shouldLoop,
+                    target: nextNodeId,
+                    iteration: current.iteration,
+                    maxIterations,
+                },
+            },
+        };
+    }
+    if (node.control === 'switch') {
+        if (!node.value || !node.cases) {
+            throw new Error(`Workflow switch node "${nodeId}" must define value and cases.`);
+        }
+        const value = renderTemplate(node.value, context).trim();
+        const nextNodeId = node.cases[value] ?? node.default;
+        if (!nextNodeId) {
+            throw new Error(`Workflow switch node "${nodeId}" has no case for "${value}" or default.`);
+        }
+        return {
+            nextNodeId,
+            result: {
+                id: nodeId,
+                type: 'control',
+                status: 'success',
+                control: node.control,
+                decision: value,
+                target: nextNodeId,
+                response: value,
+                output: { value, target: nextNodeId },
+            },
+        };
+    }
+    if (node.control === 'end') {
+        return {
+            ended: true,
+            result: {
+                id: nodeId,
+                type: 'control',
+                status: 'success',
+                control: node.control,
+                decision: 'end',
+                response: 'end',
+                output: { ended: true },
+            },
+        };
+    }
+    if (node.control === 'passThrough') {
+        const result = {
+            id: nodeId,
+            type: 'control',
+            control: 'passThrough',
+            target: node.target,
+            decision: 'pass',
+            response: `passed through to ${node.target}`,
+        };
+        return { result, nextNodeId: node.target };
+    }
+    throw new Error(`Unsupported workflow control "${node.control}" in node "${nodeId}".`);
+}
+export function createSkippedWorkflowNodeResult(nodeId) {
+    const timestamp = new Date().toISOString();
+    return {
+        id: nodeId,
+        type: 'skipped',
+        status: 'skipped',
+        startedAt: timestamp,
+        completedAt: timestamp,
+        durationMs: 0,
+        response: '',
+        output: undefined,
+    };
+}
+export function getWorkflowNodeRunCondition(node) {
+    return node.if;
+}
+export function getSkippedWorkflowDependencies(node, nodes) {
+    return getNodeNeeds(node).filter((dependency) => nodes[dependency]?.status === 'skipped');
+}
+export function getWorkflowNodeSkipReason(node, context) {
+    const skippedDependencies = getSkippedWorkflowDependencies(node, context.nodes);
+    if (skippedDependencies.length > 0) {
+        return `dependency skipped: ${skippedDependencies.join(', ')}`;
+    }
+    const ifExpression = getWorkflowNodeRunCondition(node);
+    if (ifExpression !== undefined && !evaluateWorkflowExpression(ifExpression, context)) {
+        return `if false: ${ifExpression}`;
+    }
+    return undefined;
+}
+//# sourceMappingURL=planning.js.map