agentweaver 0.1.2 → 0.1.3

package/dist/pipeline/flows/review-flow.js

@@ -1,5 +1,5 @@
 import { existsSync, readdirSync } from "node:fs";
-import { READY_TO_MERGE_FILE, REVIEW_REPLY_FILE_RE, artifactFile, planArtifacts, requireArtifacts, } from "../../artifacts.js";
+import { REVIEW_REPLY_FILE_RE, artifactFile, planArtifacts, readyToMergeFile, requireArtifacts, taskWorkspaceDir, } from "../../artifacts.js";
 import { REVIEW_REPLY_SUMMARY_PROMPT_TEMPLATE, REVIEW_SUMMARY_PROMPT_TEMPLATE, formatTemplate } from "../../prompts.js";
 import { printPanel } from "../../tui.js";
 import { runFlow } from "../flow-runner.js";
@@ -9,7 +9,11 @@ import { reviewClaudeNode } from "../nodes/review-claude-node.js";
 import { reviewReplyCodexNode } from "../nodes/review-reply-codex-node.js";
 function nextReviewIterationForTask(taskKey) {
     let maxIndex = 0;
-    for (const entry of readdirSync(process.cwd(), { withFileTypes: true })) {
+    const workspaceDir = taskWorkspaceDir(taskKey);
+    if (!existsSync(workspaceDir)) {
+        return 1;
+    }
+    for (const entry of readdirSync(workspaceDir, { withFileTypes: true })) {
         if (!entry.isFile()) {
             continue;
         }
@@ -96,8 +100,8 @@ export function createReviewFlowDefinition(iteration) {
             },
             {
                 id: "check_ready_to_merge",
-                async run(stepContext) {
-                    const readyToMerge = !stepContext.dryRun && existsSync(READY_TO_MERGE_FILE);
+                async run(stepContext, stepParams) {
+                    const readyToMerge = !stepContext.dryRun && existsSync(readyToMergeFile(stepParams.taskKey));
                     if (readyToMerge) {
                         printPanel("Ready To Merge", "Изменения готовы к merge\nФайл ready-to-merge.md создан.", "green");
                     }

package/dist/pipeline/flows/test-fix-flow.js

@@ -1,13 +1,12 @@
 import { planArtifacts, requireArtifacts } from "../../artifacts.js";
 import { TEST_FIX_PROMPT_TEMPLATE, TEST_LINTER_FIX_PROMPT_TEMPLATE, formatPrompt } from "../../prompts.js";
 import { runNode } from "../node-runner.js";
-import { codexDockerPromptNode } from "../nodes/codex-docker-prompt-node.js";
+import { codexLocalPromptNode } from "../nodes/codex-local-prompt-node.js";
 export async function runTestFixFlow(context, params) {
     requireArtifacts(planArtifacts(params.taskKey), `${params.command} mode requires plan artifacts from the planning phase.`);
     const prompt = formatPrompt(params.command === "test-fix" ? TEST_FIX_PROMPT_TEMPLATE : TEST_LINTER_FIX_PROMPT_TEMPLATE, params.extraPrompt);
-    await runNode(codexDockerPromptNode, context, {
-        dockerComposeFile: params.dockerComposeFile,
+    await runNode(codexLocalPromptNode, context, {
         prompt,
-        labelText: `Running Codex ${params.command} mode in isolated Docker`,
+        labelText: `Running Codex ${params.command} mode locally`,
     });
 }

package/dist/pipeline/node-registry.js

@@ -0,0 +1,71 @@
+import { buildFailureSummaryNode } from "./nodes/build-failure-summary-node.js";
+import { claudePromptNode } from "./nodes/claude-prompt-node.js";
+import { codexDockerPromptNode } from "./nodes/codex-docker-prompt-node.js";
+import { codexLocalPromptNode } from "./nodes/codex-local-prompt-node.js";
+import { commandCheckNode } from "./nodes/command-check-node.js";
+import { fileCheckNode } from "./nodes/file-check-node.js";
+import { jiraFetchNode } from "./nodes/jira-fetch-node.js";
+import { planCodexNode } from "./nodes/plan-codex-node.js";
+import { reviewClaudeNode } from "./nodes/review-claude-node.js";
+import { reviewReplyCodexNode } from "./nodes/review-reply-codex-node.js";
+import { summaryFileLoadNode } from "./nodes/summary-file-load-node.js";
+import { verifyBuildNode } from "./nodes/verify-build-node.js";
+const builtInNodes = {
+    "build-failure-summary": buildFailureSummaryNode,
+    "claude-prompt": claudePromptNode,
+    "codex-docker-prompt": codexDockerPromptNode,
+    "codex-local-prompt": codexLocalPromptNode,
+    "command-check": commandCheckNode,
+    "file-check": fileCheckNode,
+    "jira-fetch": jiraFetchNode,
+    "plan-codex": planCodexNode,
+    "review-claude": reviewClaudeNode,
+    "review-reply-codex": reviewReplyCodexNode,
+    "summary-file-load": summaryFileLoadNode,
+    "verify-build": verifyBuildNode,
+};
+const builtInNodeMetadata = {
+    "build-failure-summary": { kind: "build-failure-summary", version: 1, prompt: "forbidden", requiredParams: ["output"] },
+    "claude-prompt": { kind: "claude-prompt", version: 1, prompt: "required", requiredParams: ["labelText"] },
+    "codex-docker-prompt": {
+        kind: "codex-docker-prompt",
+        version: 1,
+        prompt: "required",
+        requiredParams: ["dockerComposeFile", "labelText"],
+    },
+    "codex-local-prompt": { kind: "codex-local-prompt", version: 1, prompt: "required", requiredParams: ["labelText"] },
+    "command-check": { kind: "command-check", version: 1, prompt: "forbidden", requiredParams: ["commands"] },
+    "file-check": { kind: "file-check", version: 1, prompt: "forbidden", requiredParams: ["path"] },
+    "jira-fetch": { kind: "jira-fetch", version: 1, prompt: "forbidden", requiredParams: ["jiraApiUrl", "outputFile"] },
+    "plan-codex": { kind: "plan-codex", version: 1, prompt: "forbidden", requiredParams: ["prompt", "requiredArtifacts"] },
+    "review-claude": {
+        kind: "review-claude",
+        version: 1,
+        prompt: "forbidden",
+        requiredParams: ["jiraTaskFile", "taskKey", "iteration", "claudeCmd"],
+    },
+    "review-reply-codex": {
+        kind: "review-reply-codex",
+        version: 1,
+        prompt: "forbidden",
+        requiredParams: ["jiraTaskFile", "taskKey", "iteration", "codexCmd"],
+    },
+    "summary-file-load": { kind: "summary-file-load", version: 1, prompt: "forbidden", requiredParams: ["path"] },
+    "verify-build": { kind: "verify-build", version: 1, prompt: "forbidden", requiredParams: ["dockerComposeFile", "labelText"] },
+};
+export function createNodeRegistry() {
+    return {
+        get(kind) {
+            return builtInNodes[kind];
+        },
+        getMeta(kind) {
+            return builtInNodeMetadata[kind];
+        },
+        has(kind) {
+            return kind in builtInNodes;
+        },
+        kinds() {
+            return Object.keys(builtInNodes);
+        },
+    };
+}

package/dist/pipeline/node-runner.js

@@ -1,14 +1,20 @@
 import { setCurrentNode } from "../tui.js";
 import { runNodeChecks } from "./checks.js";
-export async function runNode(node, context, params) {
+export async function runNode(node, context, params, options = {}) {
     setCurrentNode(node.kind);
     try {
         const result = await node.run(context, params);
-        const checks = node.checks?.(context, params, result) ?? [];
-        runNodeChecks(checks);
+        if (!options.skipChecks) {
+            const checks = node.checks?.(context, params, result) ?? [];
+            runNodeChecks(checks);
+        }
         return result;
     }
     finally {
         setCurrentNode(null);
     }
 }
+export async function runNodeByKind(kind, context, params, options = {}) {
+    const node = context.nodes.get(kind);
+    return runNode(node, context, params, options);
+}

package/dist/pipeline/nodes/build-failure-summary-node.js

@@ -1,5 +1,5 @@
 import { toExecutorContext } from "../types.js";
-const DEFAULT_CLAUDE_SUMMARY_MODEL = "haiku";
+const DEFAULT_CLAUDE_MODEL = "haiku";
 function truncateText(text, maxChars = 12000) {
     return text.length <= maxChars ? text.trim() : text.trim().slice(-maxChars);
 }
@@ -11,8 +11,8 @@ function fallbackBuildFailureSummary(output) {
     const tail = lines.length > 0 ? lines.slice(-8) : ["No build output captured."];
     return `Не удалось получить summary через Claude.\n\nПоследние строки лога:\n${tail.join("\n")}`;
 }
-function claudeSummaryModel(env) {
-    return env.CLAUDE_SUMMARY_MODEL?.trim() || DEFAULT_CLAUDE_SUMMARY_MODEL;
+function claudeModel(env) {
+    return env.CLAUDE_MODEL?.trim() || env.CLAUDE_SUMMARY_MODEL?.trim() || env.CLAUDE_REVIEW_MODEL?.trim() || DEFAULT_CLAUDE_MODEL;
 }
 export const buildFailureSummaryNode = {
     kind: "build-failure-summary",
@@ -36,7 +36,7 @@ export const buildFailureSummaryNode = {
                 },
             };
         }
-        const model = claudeSummaryModel(context.env);
+        const model = claudeModel(context.env);
         const prompt = "Ниже лог упавшей build verification.\n" +
             "Сделай краткое резюме на русском языке, без воды.\n" +
             "Нужно обязательно выделить:\n" +

package/dist/pipeline/nodes/claude-prompt-node.js

@@ -0,0 +1,54 @@
+import { readFileSync } from "node:fs";
+import { requireArtifacts } from "../../artifacts.js";
+import { printInfo, printPrompt, printSummary } from "../../tui.js";
+import { toExecutorContext } from "../types.js";
+export const claudePromptNode = {
+    kind: "claude-prompt",
+    version: 1,
+    async run(context, params) {
+        printInfo(params.labelText);
+        printPrompt("Claude", params.prompt);
+        const executor = context.executors.get("claude");
+        const value = await executor.execute(toExecutorContext(context), {
+            prompt: params.prompt,
+            ...(params.command ? { command: params.command } : {}),
+            ...(params.model ? { model: params.model } : {}),
+            env: { ...context.env },
+        }, executor.defaultConfig);
+        const outputs = [
+            ...(params.requiredArtifacts ?? []).map((path) => ({ kind: "artifact", path, required: true })),
+            ...(params.outputFile ? [{ kind: "artifact", path: params.outputFile, required: true }] : []),
+        ];
+        if (!params.outputFile) {
+            return { value, outputs };
+        }
+        requireArtifacts([params.outputFile], params.missingArtifactsMessage ?? `Claude prompt did not produce ${params.outputFile}.`);
+        const artifactText = readFileSync(params.outputFile, "utf8").trim();
+        if (params.summaryTitle) {
+            printSummary(params.summaryTitle, artifactText);
+        }
+        return {
+            value: {
+                ...value,
+                artifactText,
+            },
+            outputs,
+        };
+    },
+    checks(_context, params) {
+        const requiredArtifacts = [
+            ...(params.requiredArtifacts ?? []),
+            ...(params.outputFile ? [params.outputFile] : []),
+        ];
+        if (requiredArtifacts.length === 0) {
+            return [];
+        }
+        return [
+            {
+                kind: "require-artifacts",
+                paths: requiredArtifacts,
+                message: params.missingArtifactsMessage ?? "Claude prompt node did not produce required artifacts.",
+            },
+        ];
+    },
+};

package/dist/pipeline/nodes/claude-summary-node.js

@@ -1,3 +1,5 @@
+import { readFileSync } from "node:fs";
+import { requireArtifacts } from "../../artifacts.js";
 import { printInfo, printPrompt, printSummary } from "../../tui.js";
 import { toExecutorContext } from "../types.js";
 export const claudeSummaryNode = {
@@ -6,17 +8,21 @@ export const claudeSummaryNode = {
     async run(context, params) {
         printInfo(`Preparing summary in ${params.outputFile}`);
         printPrompt("Claude", params.prompt);
-        const executor = context.executors.get("claude-summary");
+        const executor = context.executors.get("claude");
         const value = await executor.execute(toExecutorContext(context), {
             prompt: params.prompt,
-            outputFile: params.outputFile,
-            command: params.claudeCmd,
+            ...(params.model ? { model: params.model } : {}),
+            ...(params.claudeCmd ? { command: params.claudeCmd } : {}),
             env: { ...context.env },
-            verbose: params.verbose,
         }, executor.defaultConfig);
-        printSummary(params.summaryTitle, value.artifactText);
+        requireArtifacts([params.outputFile], `Claude summary did not produce ${params.outputFile}.`);
+        const artifactText = readFileSync(params.outputFile, "utf8").trim();
+        printSummary(params.summaryTitle, artifactText);
         return {
-            value,
+            value: {
+                ...value,
+                artifactText,
+            },
             outputs: [{ kind: "artifact", path: params.outputFile, required: true }],
         };
     },

package/dist/pipeline/nodes/codex-docker-prompt-node.js

@@ -10,6 +10,7 @@ export const codexDockerPromptNode = {
         const value = await executor.execute(toExecutorContext(context), {
             dockerComposeFile: params.dockerComposeFile,
             prompt: params.prompt,
+            ...(params.model ? { model: params.model } : {}),
         }, executor.defaultConfig);
         return {
             value,

package/dist/pipeline/nodes/codex-local-prompt-node.js

@@ -0,0 +1,32 @@
+import { printInfo, printPrompt } from "../../tui.js";
+import { toExecutorContext } from "../types.js";
+export const codexLocalPromptNode = {
+    kind: "codex-local-prompt",
+    version: 1,
+    async run(context, params) {
+        printInfo(params.labelText);
+        printPrompt("Codex", params.prompt);
+        const executor = context.executors.get("codex-local");
+        const value = await executor.execute(toExecutorContext(context), {
+            prompt: params.prompt,
+            ...(params.model ? { model: params.model } : {}),
+            env: { ...context.env },
+        }, executor.defaultConfig);
+        return {
+            value,
+            outputs: (params.requiredArtifacts ?? []).map((path) => ({ kind: "artifact", path, required: true })),
+        };
+    },
+    checks(_context, params) {
+        if (!params.requiredArtifacts || params.requiredArtifacts.length === 0) {
+            return [];
+        }
+        return [
+            {
+                kind: "require-artifacts",
+                paths: params.requiredArtifacts,
+                message: params.missingArtifactsMessage ?? "Codex local node did not produce required artifacts.",
+            },
+        ];
+    },
+};

package/dist/pipeline/nodes/file-check-node.js

@@ -0,0 +1,15 @@
+import { existsSync } from "node:fs";
+import { printPanel } from "../../tui.js";
+export const fileCheckNode = {
+    kind: "file-check",
+    version: 1,
+    async run(_context, params) {
+        const exists = existsSync(params.path);
+        if (exists && params.panelTitle && params.foundMessage) {
+            printPanel(params.panelTitle, params.foundMessage, params.tone ?? "green");
+        }
+        return {
+            value: { exists },
+        };
+    },
+};

package/dist/pipeline/nodes/summary-file-load-node.js

@@ -0,0 +1,16 @@
+import { readFileSync } from "node:fs";
+import { printSummary } from "../../tui.js";
+export const summaryFileLoadNode = {
+    kind: "summary-file-load",
+    version: 1,
+    async run(context, params) {
+        const text = readFileSync(params.path, "utf8").trim();
+        context.setSummary?.(text);
+        if (params.title) {
+            printSummary(params.title, text);
+        }
+        return {
+            value: { text },
+        };
+    },
+};

package/dist/pipeline/nodes/task-summary-node.js

@@ -1,4 +1,6 @@
+import { readFileSync } from "node:fs";
 import { taskSummaryFile } from "../../artifacts.js";
+import { requireArtifacts } from "../../artifacts.js";
 import { TASK_SUMMARY_PROMPT_TEMPLATE, formatTemplate } from "../../prompts.js";
 import { toExecutorContext } from "../types.js";
 export const taskSummaryNode = {
@@ -10,17 +12,21 @@ export const taskSummaryNode = {
             jira_task_file: params.jiraTaskFile,
             task_summary_file: outputFile,
         });
-        const executor = context.executors.get("claude-summary");
+        const executor = context.executors.get("claude");
         const value = await executor.execute(toExecutorContext(context), {
             prompt,
-            outputFile,
-            command: params.claudeCmd,
+            ...(params.model ? { model: params.model } : {}),
+            ...(params.claudeCmd ? { command: params.claudeCmd } : {}),
             env: { ...context.env },
-            verbose: params.verbose,
         }, executor.defaultConfig);
-        context.setSummary?.(value.artifactText);
+        requireArtifacts([outputFile], `Claude summary did not produce ${outputFile}.`);
+        const artifactText = readFileSync(outputFile, "utf8").trim();
+        context.setSummary?.(artifactText);
         return {
-            value,
+            value: {
+                ...value,
+                artifactText,
+            },
             outputs: [{ kind: "artifact", path: outputFile, required: true }],
         };
     },

package/dist/pipeline/prompt-registry.js

@@ -0,0 +1,22 @@
+import { IMPLEMENT_PROMPT_TEMPLATE, PLAN_PROMPT_TEMPLATE, REVIEW_FIX_PROMPT_TEMPLATE, REVIEW_PROMPT_TEMPLATE, REVIEW_REPLY_PROMPT_TEMPLATE, REVIEW_REPLY_SUMMARY_PROMPT_TEMPLATE, REVIEW_SUMMARY_PROMPT_TEMPLATE, TASK_SUMMARY_PROMPT_TEMPLATE, TEST_FIX_PROMPT_TEMPLATE, TEST_LINTER_FIX_PROMPT_TEMPLATE, } from "../prompts.js";
+const promptTemplates = {
+    implement: IMPLEMENT_PROMPT_TEMPLATE,
+    plan: PLAN_PROMPT_TEMPLATE,
+    review: REVIEW_PROMPT_TEMPLATE,
+    "review-fix": REVIEW_FIX_PROMPT_TEMPLATE,
+    "review-reply": REVIEW_REPLY_PROMPT_TEMPLATE,
+    "review-reply-summary": REVIEW_REPLY_SUMMARY_PROMPT_TEMPLATE,
+    "review-summary": REVIEW_SUMMARY_PROMPT_TEMPLATE,
+    "task-summary": TASK_SUMMARY_PROMPT_TEMPLATE,
+    "test-fix": TEST_FIX_PROMPT_TEMPLATE,
+    "test-linter-fix": TEST_LINTER_FIX_PROMPT_TEMPLATE,
+};
+export function isPromptTemplateRef(value) {
+    return value in promptTemplates;
+}
+export function getPromptTemplate(ref) {
+    return promptTemplates[ref];
+}
+export function promptTemplateRefs() {
+    return Object.keys(promptTemplates);
+}

package/dist/pipeline/prompt-runtime.js

@@ -0,0 +1,18 @@
+import { TaskRunnerError } from "../errors.js";
+import { formatPrompt, formatTemplate } from "../prompts.js";
+import { getPromptTemplate } from "./prompt-registry.js";
+import { resolveValue } from "./value-resolver.js";
+export function renderPrompt(binding, context) {
+    const baseTemplate = binding.inlineTemplate ?? (binding.templateRef ? getPromptTemplate(binding.templateRef) : null);
+    if (!baseTemplate) {
+        throw new TaskRunnerError("Prompt binding must define templateRef or inlineTemplate");
+    }
+    const vars = Object.fromEntries(Object.entries(binding.vars ?? {}).map(([key, value]) => [key, String(resolveValue(value, context))]));
+    const basePrompt = formatTemplate(baseTemplate, vars);
+    const resolvedExtraPrompt = binding.extraPrompt ? resolveValue(binding.extraPrompt, context) : null;
+    const extraPrompt = resolvedExtraPrompt === null || resolvedExtraPrompt === undefined ? null : String(resolvedExtraPrompt);
+    if ((binding.format ?? "task-prompt") === "plain") {
+        return basePrompt;
+    }
+    return formatPrompt(basePrompt, extraPrompt);
+}

package/dist/pipeline/registry.js

@@ -1,6 +1,5 @@
 import { commandCheckExecutor } from "../executors/command-check-executor.js";
 import { claudeExecutor } from "../executors/claude-executor.js";
-import { claudeSummaryExecutor } from "../executors/claude-summary-executor.js";
 import { codexDockerExecutor } from "../executors/codex-docker-executor.js";
 import { codexLocalExecutor } from "../executors/codex-local-executor.js";
 import { jiraFetchExecutor } from "../executors/jira-fetch-executor.js";
@@ -13,7 +12,6 @@ const builtInExecutors = {
     "codex-local": codexLocalExecutor,
     "codex-docker": codexDockerExecutor,
     claude: claudeExecutor,
-    "claude-summary": claudeSummaryExecutor,
     "verify-build": verifyBuildExecutor,
 };
 export function createExecutorRegistry() {

package/dist/pipeline/spec-compiler.js

@@ -0,0 +1,200 @@
+function interpolateText(template, repeatVars) {
+    let result = template;
+    for (const [key, value] of Object.entries(repeatVars)) {
+        result = result.replaceAll(`\${${key}}`, String(value));
+    }
+    return result;
+}
+function interpolateValueSpec(value, repeatVars) {
+    if ("const" in value || "artifact" in value || "artifactList" in value || "list" in value) {
+        if ("artifact" in value) {
+            return {
+                artifact: {
+                    ...value.artifact,
+                    taskKey: interpolateValueSpec(value.artifact.taskKey, repeatVars),
+                    ...(value.artifact.iteration ? { iteration: interpolateValueSpec(value.artifact.iteration, repeatVars) } : {}),
+                },
+            };
+        }
+        if ("artifactList" in value) {
+            return {
+                artifactList: {
+                    ...value.artifactList,
+                    taskKey: interpolateValueSpec(value.artifactList.taskKey, repeatVars),
+                },
+            };
+        }
+        if ("list" in value) {
+            return {
+                list: value.list.map((candidate) => interpolateValueSpec(candidate, repeatVars)),
+            };
+        }
+        return value;
+    }
+    if ("ref" in value) {
+        return {
+            ref: interpolateText(value.ref, repeatVars),
+        };
+    }
+    if ("template" in value) {
+        return {
+            template: interpolateText(value.template, repeatVars),
+            ...(value.vars
+                ? {
+                    vars: Object.fromEntries(Object.entries(value.vars).map(([key, candidate]) => [key, interpolateValueSpec(candidate, repeatVars)])),
+                }
+                : {}),
+        };
+    }
+    if ("appendPrompt" in value) {
+        return {
+            appendPrompt: {
+                ...(value.appendPrompt.base ? { base: interpolateValueSpec(value.appendPrompt.base, repeatVars) } : {}),
+                suffix: interpolateValueSpec(value.appendPrompt.suffix, repeatVars),
+            },
+        };
+    }
+    if ("concat" in value) {
+        return {
+            concat: value.concat.map((candidate) => interpolateValueSpec(candidate, repeatVars)),
+        };
+    }
+    return value;
+}
+function interpolateCondition(condition, repeatVars) {
+    if (!condition) {
+        return undefined;
+    }
+    if ("ref" in condition) {
+        return {
+            ref: interpolateText(condition.ref, repeatVars),
+        };
+    }
+    if ("not" in condition) {
+        return {
+            not: interpolateCondition(condition.not, repeatVars),
+        };
+    }
+    if ("all" in condition) {
+        return {
+            all: condition.all.map((candidate) => interpolateCondition(candidate, repeatVars)),
+        };
+    }
+    if ("any" in condition) {
+        return {
+            any: condition.any.map((candidate) => interpolateCondition(candidate, repeatVars)),
+        };
+    }
+    if ("equals" in condition) {
+        return {
+            equals: [
+                interpolateValueSpec(condition.equals[0], repeatVars),
+                interpolateValueSpec(condition.equals[1], repeatVars),
+            ],
+        };
+    }
+    if ("exists" in condition) {
+        return {
+            exists: interpolateValueSpec(condition.exists, repeatVars),
+        };
+    }
+    return condition;
+}
+function interpolatePrompt(prompt, repeatVars) {
+    return {
+        ...(prompt.templateRef ? { templateRef: prompt.templateRef } : {}),
+        ...(prompt.inlineTemplate ? { inlineTemplate: interpolateText(prompt.inlineTemplate, repeatVars) } : {}),
+        ...(prompt.vars
+            ? {
+                vars: Object.fromEntries(Object.entries(prompt.vars).map(([key, candidate]) => [key, interpolateValueSpec(candidate, repeatVars)])),
+            }
+            : {}),
+        ...(prompt.extraPrompt ? { extraPrompt: interpolateValueSpec(prompt.extraPrompt, repeatVars) } : {}),
+        ...(prompt.format ? { format: prompt.format } : {}),
+    };
+}
+function interpolateExpectation(expectation, repeatVars) {
+    if (expectation.kind === "require-artifacts") {
+        const when = expectation.when ? interpolateCondition(expectation.when, repeatVars) : undefined;
+        return {
+            kind: expectation.kind,
+            ...(when ? { when } : {}),
+            paths: interpolateValueSpec(expectation.paths, repeatVars),
+            message: interpolateText(expectation.message, repeatVars),
+        };
+    }
+    const when = expectation.when ? interpolateCondition(expectation.when, repeatVars) : undefined;
+    if (expectation.kind === "require-file") {
+        return {
+            kind: expectation.kind,
+            ...(when ? { when } : {}),
+            path: interpolateValueSpec(expectation.path, repeatVars),
+            message: interpolateText(expectation.message, repeatVars),
+        };
+    }
+    return {
+        kind: expectation.kind,
+        ...(when ? { when } : {}),
+        value: interpolateValueSpec(expectation.value, repeatVars),
+        ...(expectation.equals ? { equals: interpolateValueSpec(expectation.equals, repeatVars) } : {}),
+        message: interpolateText(expectation.message, repeatVars),
+    };
+}
+function interpolateAfterAction(action, repeatVars) {
+    const when = action.when ? interpolateCondition(action.when, repeatVars) : undefined;
+    return {
+        kind: action.kind,
+        ...(when ? { when } : {}),
+        path: interpolateValueSpec(action.path, repeatVars),
+    };
+}
+function expandPhase(phase, repeatVars) {
+    const phaseWhen = phase.when ? interpolateCondition(phase.when, repeatVars) : undefined;
+    return {
+        id: interpolateText(phase.id, repeatVars),
+        repeatVars,
+        ...(phaseWhen ? { when: phaseWhen } : {}),
+        steps: phase.steps.map((step) => {
+            const stepWhen = step.when ? interpolateCondition(step.when, repeatVars) : undefined;
+            const stopFlowIf = step.stopFlowIf ? interpolateCondition(step.stopFlowIf, repeatVars) : undefined;
+            return {
+                id: interpolateText(step.id, repeatVars),
+                node: step.node,
+                ...(stepWhen ? { when: stepWhen } : {}),
+                ...(step.prompt ? { prompt: interpolatePrompt(step.prompt, repeatVars) } : {}),
+                ...(step.params
+                    ? {
+                        params: Object.fromEntries(Object.entries(step.params).map(([key, value]) => [key, interpolateValueSpec(value, repeatVars)])),
+                    }
+                    : {}),
+                ...(step.expect ? { expect: step.expect.map((item) => interpolateExpectation(item, repeatVars)) } : {}),
+                ...(stopFlowIf ? { stopFlowIf } : {}),
+                ...(step.after ? { after: step.after.map((item) => interpolateAfterAction(item, repeatVars)) } : {}),
+                repeatVars,
+            };
+        }),
+    };
+}
+function expandRepeat(block) {
+    const phases = [];
+    for (let index = block.repeat.from; index <= block.repeat.to; index += 1) {
+        const repeatVars = {
+            [block.repeat.var]: index,
+        };
+        for (const phase of block.phases) {
+            phases.push(expandPhase(phase, repeatVars));
+        }
+    }
+    return phases;
+}
+export function compileFlowSpec(spec) {
+    const phases = [];
+    for (const item of spec.phases) {
+        if ("repeat" in item) {
+            phases.push(...expandRepeat(item));
+            continue;
+        }
+        phases.push(expandPhase(item, {}));
+    }
+    return phases;
+}

package/dist/pipeline/spec-loader.js

@@ -0,0 +1,14 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { TaskRunnerError } from "../errors.js";
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+export function loadFlowSpecSync(fileName) {
+    const filePath = path.join(MODULE_DIR, "flow-specs", fileName);
+    try {
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        throw new TaskRunnerError(`Failed to load flow spec ${filePath}: ${error.message}`);
+    }
+}

package/dist/pipeline/spec-types.js

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