agentweaver 0.1.0 → 0.1.3

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

@@ -0,0 +1,38 @@
+import { artifactFile, designFile, planFile } from "../../artifacts.js";
+import { REVIEW_PROMPT_TEMPLATE, formatPrompt, formatTemplate } from "../../prompts.js";
+import { printInfo, printPrompt } from "../../tui.js";
+import { toExecutorContext } from "../types.js";
+export const reviewClaudeNode = {
+    kind: "review-claude",
+    version: 1,
+    async run(context, params) {
+        const reviewFile = artifactFile("review", params.taskKey, params.iteration);
+        const prompt = formatPrompt(formatTemplate(REVIEW_PROMPT_TEMPLATE, {
+            jira_task_file: params.jiraTaskFile,
+            design_file: designFile(params.taskKey),
+            plan_file: planFile(params.taskKey),
+            review_file: reviewFile,
+        }), params.extraPrompt);
+        printInfo(`Running Claude review mode (iteration ${params.iteration})`);
+        printPrompt("Claude", prompt);
+        const executor = context.executors.get("claude");
+        const value = await executor.execute(toExecutorContext(context), {
+            prompt,
+            command: params.claudeCmd,
+            env: { ...context.env },
+        }, executor.defaultConfig);
+        return {
+            value,
+            outputs: [{ kind: "artifact", path: reviewFile, required: true }],
+        };
+    },
+    checks(_context, params) {
+        return [
+            {
+                kind: "require-artifacts",
+                paths: [artifactFile("review", params.taskKey, params.iteration)],
+                message: "Claude review did not produce the required review artifact.",
+            },
+        ];
+    },
+};

package/dist/pipeline/nodes/review-reply-codex-node.js

@@ -0,0 +1,40 @@
+import { artifactFile, designFile, planFile } from "../../artifacts.js";
+import { REVIEW_REPLY_PROMPT_TEMPLATE, formatPrompt, formatTemplate } from "../../prompts.js";
+import { printInfo, printPrompt } from "../../tui.js";
+import { toExecutorContext } from "../types.js";
+export const reviewReplyCodexNode = {
+    kind: "review-reply-codex",
+    version: 1,
+    async run(context, params) {
+        const reviewFile = artifactFile("review", params.taskKey, params.iteration);
+        const reviewReplyFile = artifactFile("review-reply", params.taskKey, params.iteration);
+        const prompt = formatPrompt(formatTemplate(REVIEW_REPLY_PROMPT_TEMPLATE, {
+            review_file: reviewFile,
+            jira_task_file: params.jiraTaskFile,
+            design_file: designFile(params.taskKey),
+            plan_file: planFile(params.taskKey),
+            review_reply_file: reviewReplyFile,
+        }), params.extraPrompt);
+        printInfo(`Running Codex review reply mode (iteration ${params.iteration})`);
+        printPrompt("Codex", prompt);
+        const executor = context.executors.get("codex-local");
+        const value = await executor.execute(toExecutorContext(context), {
+            prompt,
+            command: params.codexCmd,
+            env: { ...context.env },
+        }, executor.defaultConfig);
+        return {
+            value,
+            outputs: [{ kind: "artifact", path: reviewReplyFile, required: true }],
+        };
+    },
+    checks(_context, params) {
+        return [
+            {
+                kind: "require-artifacts",
+                paths: [artifactFile("review-reply", params.taskKey, params.iteration)],
+                message: "Codex review reply did not produce the required review-reply artifact.",
+            },
+        ];
+    },
+};

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

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

package/dist/pipeline/nodes/verify-build-node.js

@@ -0,0 +1,14 @@
+import { printInfo } from "../../tui.js";
+import { toExecutorContext } from "../types.js";
+export const verifyBuildNode = {
+    kind: "verify-build",
+    version: 1,
+    async run(context, params) {
+        printInfo(params.labelText);
+        const executor = context.executors.get("verify-build");
+        const value = await executor.execute(toExecutorContext(context), {
+            dockerComposeFile: params.dockerComposeFile,
+        }, executor.defaultConfig);
+        return { value };
+    },
+};

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

@@ -0,0 +1,23 @@
+import { commandCheckExecutor } from "../executors/command-check-executor.js";
+import { claudeExecutor } from "../executors/claude-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";
+import { processExecutor } from "../executors/process-executor.js";
+import { verifyBuildExecutor } from "../executors/verify-build-executor.js";
+const builtInExecutors = {
+    process: processExecutor,
+    "command-check": commandCheckExecutor,
+    "jira-fetch": jiraFetchExecutor,
+    "codex-local": codexLocalExecutor,
+    "codex-docker": codexDockerExecutor,
+    claude: claudeExecutor,
+    "verify-build": verifyBuildExecutor,
+};
+export function createExecutorRegistry() {
+    return {
+        get(id) {
+            return builtInExecutors[id];
+        },
+    };
+}

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 {};