agentweaver 0.1.0 → 0.1.3

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

@@ -0,0 +1,62 @@
+import { artifactFile, planArtifacts, requireArtifacts } from "../../artifacts.js";
+import { TaskRunnerError } from "../../errors.js";
+import { REVIEW_FIX_PROMPT_TEMPLATE, formatPrompt, formatTemplate } from "../../prompts.js";
+import { runFlow } from "../flow-runner.js";
+import { runNode } from "../node-runner.js";
+import { codexLocalPromptNode } from "../nodes/codex-local-prompt-node.js";
+import { verifyBuildNode } from "../nodes/verify-build-node.js";
+export function createReviewFixFlowDefinition(iteration) {
+    return {
+        kind: "review-fix-flow",
+        version: 1,
+        steps: [
+            {
+                id: "run_codex_review_fix",
+                async run(stepContext, stepParams) {
+                    const reviewReplyFile = artifactFile("review-reply", stepParams.taskKey, iteration);
+                    const reviewFixFile = artifactFile("review-fix", stepParams.taskKey, iteration);
+                    const prompt = formatPrompt(formatTemplate(REVIEW_FIX_PROMPT_TEMPLATE, {
+                        review_reply_file: reviewReplyFile,
+                        items: stepParams.reviewFixPoints ?? "",
+                        review_fix_file: reviewFixFile,
+                    }), stepParams.extraPrompt);
+                    await runNode(codexLocalPromptNode, stepContext, {
+                        prompt,
+                        labelText: `Running Codex review-fix mode locally (iteration ${iteration})`,
+                        requiredArtifacts: stepContext.dryRun ? [] : [reviewFixFile],
+                        missingArtifactsMessage: "Review-fix mode did not produce the required review-fix artifact.",
+                    });
+                    return { completed: true, metadata: { iteration } };
+                },
+            },
+            {
+                id: "verify_build_after_review_fix",
+                async run(stepContext, stepParams) {
+                    if (!stepParams.runFollowupVerify) {
+                        return { completed: true, metadata: { skipped: true } };
+                    }
+                    try {
+                        await runNode(verifyBuildNode, stepContext, {
+                            dockerComposeFile: stepParams.dockerComposeFile,
+                            labelText: "Running build verification in isolated Docker",
+                        });
+                    }
+                    catch (error) {
+                        if (stepParams.onVerifyBuildFailure) {
+                            await stepParams.onVerifyBuildFailure(String(error.output ?? ""));
+                        }
+                        throw error;
+                    }
+                    return { completed: true };
+                },
+            },
+        ],
+    };
+}
+export async function runReviewFixFlow(context, params) {
+    requireArtifacts(planArtifacts(params.taskKey), "Review-fix mode requires plan artifacts from the planning phase.");
+    if (params.latestIteration === null) {
+        throw new TaskRunnerError(`Review-fix mode requires at least one review-reply-${params.taskKey}-N.md artifact.`);
+    }
+    await runFlow(createReviewFixFlowDefinition(params.latestIteration), context, params);
+}

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

@@ -0,0 +1,124 @@
+import { existsSync, readdirSync } from "node:fs";
+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";
+import { runNode } from "../node-runner.js";
+import { claudeSummaryNode } from "../nodes/claude-summary-node.js";
+import { reviewClaudeNode } from "../nodes/review-claude-node.js";
+import { reviewReplyCodexNode } from "../nodes/review-reply-codex-node.js";
+function nextReviewIterationForTask(taskKey) {
+    let maxIndex = 0;
+    const workspaceDir = taskWorkspaceDir(taskKey);
+    if (!existsSync(workspaceDir)) {
+        return 1;
+    }
+    for (const entry of readdirSync(workspaceDir, { withFileTypes: true })) {
+        if (!entry.isFile()) {
+            continue;
+        }
+        const match = REVIEW_REPLY_FILE_RE.exec(entry.name);
+        if (match && match[1] === taskKey) {
+            const current = Number.parseInt(match[2] ?? "0", 10);
+            maxIndex = Math.max(maxIndex, current);
+        }
+    }
+    return maxIndex + 1;
+}
+export function createReviewFlowDefinition(iteration) {
+    return {
+        kind: "review-flow",
+        version: 1,
+        steps: [
+            {
+                id: "run_claude_review",
+                async run(stepContext, stepParams) {
+                    await runNode(reviewClaudeNode, stepContext, {
+                        jiraTaskFile: stepParams.jiraTaskFile,
+                        taskKey: stepParams.taskKey,
+                        iteration,
+                        claudeCmd: stepParams.claudeCmd,
+                        ...(stepParams.extraPrompt !== undefined ? { extraPrompt: stepParams.extraPrompt } : {}),
+                    });
+                    return { completed: true, metadata: { iteration } };
+                },
+            },
+            {
+                id: "summarize_review",
+                async run(stepContext, stepParams) {
+                    const reviewFile = artifactFile("review", stepParams.taskKey, iteration);
+                    const reviewSummaryFile = artifactFile("review-summary", stepParams.taskKey, iteration);
+                    if (stepContext.dryRun) {
+                        return { completed: true, metadata: { skipped: true } };
+                    }
+                    await runNode(claudeSummaryNode, stepContext, {
+                        claudeCmd: stepParams.claudeCmd,
+                        outputFile: reviewSummaryFile,
+                        prompt: formatTemplate(REVIEW_SUMMARY_PROMPT_TEMPLATE, {
+                            review_file: reviewFile,
+                            review_summary_file: reviewSummaryFile,
+                        }),
+                        summaryTitle: "Claude Comments",
+                        verbose: stepContext.verbose,
+                    });
+                    return { completed: true };
+                },
+            },
+            {
+                id: "run_codex_review_reply",
+                async run(stepContext, stepParams) {
+                    await runNode(reviewReplyCodexNode, stepContext, {
+                        jiraTaskFile: stepParams.jiraTaskFile,
+                        taskKey: stepParams.taskKey,
+                        iteration,
+                        codexCmd: stepParams.codexCmd,
+                        ...(stepParams.extraPrompt !== undefined ? { extraPrompt: stepParams.extraPrompt } : {}),
+                    });
+                    return { completed: true };
+                },
+            },
+            {
+                id: "summarize_review_reply",
+                async run(stepContext, stepParams) {
+                    const reviewReplyFile = artifactFile("review-reply", stepParams.taskKey, iteration);
+                    const reviewReplySummaryFile = artifactFile("review-reply-summary", stepParams.taskKey, iteration);
+                    if (stepContext.dryRun) {
+                        return { completed: true, metadata: { skipped: true } };
+                    }
+                    await runNode(claudeSummaryNode, stepContext, {
+                        claudeCmd: stepParams.claudeCmd,
+                        outputFile: reviewReplySummaryFile,
+                        prompt: formatTemplate(REVIEW_REPLY_SUMMARY_PROMPT_TEMPLATE, {
+                            review_reply_file: reviewReplyFile,
+                            review_reply_summary_file: reviewReplySummaryFile,
+                        }),
+                        summaryTitle: "Codex Reply Summary",
+                        verbose: stepContext.verbose,
+                    });
+                    return { completed: true };
+                },
+            },
+            {
+                id: "check_ready_to_merge",
+                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");
+                    }
+                    return { completed: true, metadata: { readyToMerge } };
+                },
+            },
+        ],
+    };
+}
+async function runReviewFlowInternal(context, params, iteration) {
+    requireArtifacts(planArtifacts(params.taskKey), "Review mode requires plan artifacts from the planning phase.");
+    const result = await runFlow(createReviewFlowDefinition(iteration), context, params);
+    const readyToMerge = result.steps.find((step) => step.id === "check_ready_to_merge")?.result.metadata?.readyToMerge === true;
+    return { readyToMerge };
+}
+export async function runReviewFlow(context, params) {
+    const iteration = nextReviewIterationForTask(params.taskKey);
+    const result = await runReviewFlowInternal(context, params, iteration);
+    return { readyToMerge: result.readyToMerge, iteration };
+}

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

@@ -0,0 +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 { 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(codexLocalPromptNode, context, {
+        prompt,
+        labelText: `Running Codex ${params.command} mode locally`,
+    });
+}

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

@@ -0,0 +1,32 @@
+import { planArtifacts, requireArtifacts } from "../../artifacts.js";
+import { runFlow } from "../flow-runner.js";
+import { runNode } from "../node-runner.js";
+import { verifyBuildNode } from "../nodes/verify-build-node.js";
+export const testFlowDefinition = {
+    kind: "test-flow",
+    version: 1,
+    steps: [
+        {
+            id: "verify_build",
+            async run(context, params) {
+                try {
+                    await runNode(verifyBuildNode, context, {
+                        dockerComposeFile: params.dockerComposeFile,
+                        labelText: "Running build verification in isolated Docker",
+                    });
+                }
+                catch (error) {
+                    if (params.onVerifyBuildFailure) {
+                        await params.onVerifyBuildFailure(String(error.output ?? ""));
+                    }
+                    throw error;
+                }
+                return { completed: true };
+            },
+        },
+    ],
+};
+export async function runTestFlow(context, params) {
+    requireArtifacts(planArtifacts(params.taskKey), "Test mode requires plan artifacts from the planning phase.");
+    await runFlow(testFlowDefinition, context, params);
+}

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

@@ -0,0 +1,20 @@
+import { setCurrentNode } from "../tui.js";
+import { runNodeChecks } from "./checks.js";
+export async function runNode(node, context, params, options = {}) {
+    setCurrentNode(node.kind);
+    try {
+        const result = await node.run(context, params);
+        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

@@ -0,0 +1,71 @@
+import { toExecutorContext } from "../types.js";
+const DEFAULT_CLAUDE_MODEL = "haiku";
+function truncateText(text, maxChars = 12000) {
+    return text.length <= maxChars ? text.trim() : text.trim().slice(-maxChars);
+}
+function fallbackBuildFailureSummary(output) {
+    const lines = output
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const tail = lines.length > 0 ? lines.slice(-8) : ["No build output captured."];
+    return `Не удалось получить summary через Claude.\n\nПоследние строки лога:\n${tail.join("\n")}`;
+}
+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",
+    version: 1,
+    async run(context, params) {
+        if (!params.output.trim()) {
+            return {
+                value: {
+                    summaryText: "Build verification failed, but no output was captured.",
+                },
+            };
+        }
+        let claudeCmd;
+        try {
+            claudeCmd = context.runtime.resolveCmd("claude", "CLAUDE_BIN");
+        }
+        catch {
+            return {
+                value: {
+                    summaryText: fallbackBuildFailureSummary(params.output),
+                },
+            };
+        }
+        const model = claudeModel(context.env);
+        const prompt = "Ниже лог упавшей build verification.\n" +
+            "Сделай краткое резюме на русском языке, без воды.\n" +
+            "Нужно обязательно выделить:\n" +
+            "1. Где именно упало.\n" +
+            "2. Главную причину падения.\n" +
+            "3. Что нужно исправить дальше, если это очевидно.\n" +
+            "Ответ дай максимум 5 короткими пунктами.\n\n" +
+            `Лог:\n${truncateText(params.output)}`;
+        try {
+            const executor = context.executors.get("process");
+            const result = await executor.execute(toExecutorContext(context), {
+                argv: [claudeCmd, "--model", model, "-p", prompt],
+                env: { ...context.env },
+                dryRun: false,
+                verbose: false,
+                label: `claude:${model}`,
+            }, executor.defaultConfig);
+            return {
+                value: {
+                    summaryText: result.output.trim() || fallbackBuildFailureSummary(params.output),
+                },
+            };
+        }
+        catch {
+            return {
+                value: {
+                    summaryText: fallbackBuildFailureSummary(params.output),
+                },
+            };
+        }
+    },
+};

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

@@ -0,0 +1,38 @@
+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 = {
+    kind: "claude-summary",
+    version: 1,
+    async run(context, params) {
+        printInfo(`Preparing summary in ${params.outputFile}`);
+        printPrompt("Claude", params.prompt);
+        const executor = context.executors.get("claude");
+        const value = await executor.execute(toExecutorContext(context), {
+            prompt: params.prompt,
+            ...(params.model ? { model: params.model } : {}),
+            ...(params.claudeCmd ? { command: params.claudeCmd } : {}),
+            env: { ...context.env },
+        }, executor.defaultConfig);
+        requireArtifacts([params.outputFile], `Claude summary did not produce ${params.outputFile}.`);
+        const artifactText = readFileSync(params.outputFile, "utf8").trim();
+        printSummary(params.summaryTitle, artifactText);
+        return {
+            value: {
+                ...value,
+                artifactText,
+            },
+            outputs: [{ kind: "artifact", path: params.outputFile, required: true }],
+        };
+    },
+    checks(_context, params) {
+        return [
+            {
+                kind: "require-artifacts",
+                paths: [params.outputFile],
+                message: `Claude summary did not produce ${params.outputFile}.`,
+            },
+        ];
+    },
+};

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

@@ -0,0 +1,32 @@
+import { printInfo, printPrompt } from "../../tui.js";
+import { toExecutorContext } from "../types.js";
+export const codexDockerPromptNode = {
+    kind: "codex-docker-prompt",
+    version: 1,
+    async run(context, params) {
+        printInfo(params.labelText);
+        printPrompt("Codex", params.prompt);
+        const executor = context.executors.get("codex-docker");
+        const value = await executor.execute(toExecutorContext(context), {
+            dockerComposeFile: params.dockerComposeFile,
+            prompt: params.prompt,
+            ...(params.model ? { model: params.model } : {}),
+        }, 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 docker node did not produce required artifacts.",
+            },
+        ];
+    },
+};

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/command-check-node.js

@@ -0,0 +1,10 @@
+import { toExecutorContext } from "../types.js";
+export const commandCheckNode = {
+    kind: "command-check",
+    version: 1,
+    async run(context, params) {
+        const executor = context.executors.get("command-check");
+        const value = await executor.execute(toExecutorContext(context), params, executor.defaultConfig);
+        return { value };
+    },
+};

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/implement-codex-node.js

@@ -0,0 +1,16 @@
+import { printInfo, printPrompt } from "../../tui.js";
+import { toExecutorContext } from "../types.js";
+export const implementCodexNode = {
+    kind: "implement-codex",
+    version: 1,
+    async run(context, params) {
+        printInfo(params.labelText);
+        printPrompt("Codex", params.prompt);
+        const executor = context.executors.get("codex-docker");
+        const value = await executor.execute(toExecutorContext(context), {
+            dockerComposeFile: params.dockerComposeFile,
+            prompt: params.prompt,
+        }, executor.defaultConfig);
+        return { value };
+    },
+};

package/dist/pipeline/nodes/jira-fetch-node.js

@@ -0,0 +1,25 @@
+import { toExecutorContext } from "../types.js";
+export const jiraFetchNode = {
+    kind: "jira-fetch",
+    version: 1,
+    async run(context, params) {
+        const executor = context.executors.get("jira-fetch");
+        const value = await executor.execute(toExecutorContext(context), {
+            jiraApiUrl: params.jiraApiUrl,
+            outputFile: params.outputFile,
+        }, executor.defaultConfig);
+        return {
+            value,
+            outputs: [{ kind: "file", path: params.outputFile, required: true }],
+        };
+    },
+    checks(_context, params) {
+        return [
+            {
+                kind: "require-file",
+                path: params.outputFile,
+                message: `Jira fetch node did not produce ${params.outputFile}.`,
+            },
+        ];
+    },
+};

package/dist/pipeline/nodes/plan-codex-node.js

@@ -0,0 +1,32 @@
+import { printInfo, printPrompt } from "../../tui.js";
+import { toExecutorContext } from "../types.js";
+export const planCodexNode = {
+    kind: "plan-codex",
+    version: 1,
+    async run(context, params) {
+        printInfo("Running Codex planning mode");
+        printPrompt("Codex", params.prompt);
+        const executor = context.executors.get("codex-local");
+        const input = {
+            prompt: params.prompt,
+            env: { ...context.env },
+        };
+        if (params.command) {
+            input.command = params.command;
+        }
+        const value = await executor.execute(toExecutorContext(context), input, executor.defaultConfig);
+        return {
+            value,
+            outputs: params.requiredArtifacts.map((path) => ({ kind: "artifact", path, required: true })),
+        };
+    },
+    checks(_context, params) {
+        return [
+            {
+                kind: "require-artifacts",
+                paths: params.requiredArtifacts,
+                message: "Plan mode did not produce the required artifacts.",
+            },
+        ];
+    },
+};