agentweaver 0.1.0 → 0.1.2

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

@@ -0,0 +1,71 @@
+import { toExecutorContext } from "../types.js";
+const DEFAULT_CLAUDE_SUMMARY_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 claudeSummaryModel(env) {
+    return env.CLAUDE_SUMMARY_MODEL?.trim() || DEFAULT_CLAUDE_SUMMARY_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 = claudeSummaryModel(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-summary-node.js

@@ -0,0 +1,32 @@
+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-summary");
+        const value = await executor.execute(toExecutorContext(context), {
+            prompt: params.prompt,
+            outputFile: params.outputFile,
+            command: params.claudeCmd,
+            env: { ...context.env },
+            verbose: params.verbose,
+        }, executor.defaultConfig);
+        printSummary(params.summaryTitle, value.artifactText);
+        return {
+            value,
+            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,31 @@
+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,
+        }, 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/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/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.",
+            },
+        ];
+    },
+};

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/task-summary-node.js

@@ -0,0 +1,36 @@
+import { taskSummaryFile } 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-summary");
+        const value = await executor.execute(toExecutorContext(context), {
+            prompt,
+            outputFile,
+            command: params.claudeCmd,
+            env: { ...context.env },
+            verbose: params.verbose,
+        }, executor.defaultConfig);
+        context.setSummary?.(value.artifactText);
+        return {
+            value,
+            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/registry.js

@@ -0,0 +1,25 @@
+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";
+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,
+    "claude-summary": claudeSummaryExecutor,
+    "verify-build": verifyBuildExecutor,
+};
+export function createExecutorRegistry() {
+    return {
+        get(id) {
+            return builtInExecutors[id];
+        },
+    };
+}

package/dist/pipeline/types.js

@@ -0,0 +1,10 @@
+export function toExecutorContext(context) {
+    return {
+        cwd: context.cwd,
+        env: context.env,
+        ui: context.ui,
+        dryRun: context.dryRun,
+        verbose: context.verbose,
+        runtime: context.runtime,
+    };
+}

package/dist/runtime/command-resolution.js

@@ -0,0 +1,139 @@
+import { accessSync, constants } from "node:fs";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { TaskRunnerError } from "../errors.js";
+function splitArgs(input) {
+    const result = [];
+    let current = "";
+    let quote = null;
+    for (let index = 0; index < input.length; index += 1) {
+        const char = input[index] ?? "";
+        if (quote) {
+            if (char === quote) {
+                quote = null;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current) {
+                result.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (quote) {
+        throw new TaskRunnerError("Cannot parse command: unterminated quote");
+    }
+    if (current) {
+        result.push(current);
+    }
+    return result;
+}
+export function shellQuote(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+export function isExecutable(filePath) {
+    try {
+        accessSync(filePath, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function commandExists(commandName) {
+    const result = spawnSync("bash", ["-lc", `command -v ${shellQuote(commandName)}`], { stdio: "ignore" });
+    return result.status === 0;
+}
+export function findCmdPath(commandName, envVarName) {
+    const configuredPath = process.env[envVarName];
+    if (configuredPath && isExecutable(configuredPath)) {
+        return configuredPath;
+    }
+    const direct = spawnSync("bash", ["-lc", `command -v ${shellQuote(commandName)}`], { encoding: "utf8" });
+    if (direct.status === 0) {
+        const candidate = direct.stdout.trim().split(/\r?\n/)[0] ?? "";
+        if (candidate && !candidate.includes("alias") && isExecutable(candidate)) {
+            return candidate;
+        }
+    }
+    const interactive = spawnSync("bash", ["-ic", `type -a -- ${shellQuote(commandName)}`], {
+        encoding: "utf8",
+    });
+    if (interactive.status !== 0) {
+        return null;
+    }
+    for (const rawLine of interactive.stdout.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line) {
+            continue;
+        }
+        if (line.startsWith(`${commandName} is aliased to `)) {
+            const aliasValue = line.split(" is aliased to ", 2)[1]?.replace(/^['`]|['`]$/g, "") ?? "";
+            if (aliasValue && isExecutable(aliasValue)) {
+                return aliasValue;
+            }
+            continue;
+        }
+        if (line.startsWith("/")) {
+            const candidate = line.split(/\s+/)[0] ?? "";
+            if (candidate && isExecutable(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+export function resolveCmd(commandName, envVarName) {
+    const candidate = findCmdPath(commandName, envVarName);
+    if (candidate) {
+        return candidate;
+    }
+    throw new TaskRunnerError(`Missing required command: ${commandName}`);
+}
+export function requireDockerCompose() {
+    if (!commandExists("docker")) {
+        throw new TaskRunnerError("Missing required command: docker");
+    }
+    const result = spawnSync("docker", ["compose", "version"], { stdio: "ignore" });
+    if (result.status !== 0) {
+        throw new TaskRunnerError("Missing required docker compose plugin");
+    }
+}
+export function resolveDockerComposeCmd() {
+    const configured = process.env.DOCKER_COMPOSE_BIN?.trim() ?? "";
+    if (configured) {
+        const parts = splitArgs(configured);
+        if (parts.length === 0) {
+            throw new TaskRunnerError("DOCKER_COMPOSE_BIN is set but empty.");
+        }
+        const executable = parts[0] ?? "";
+        try {
+            if (path.isAbsolute(executable)) {
+                accessSync(executable, constants.X_OK);
+                return parts;
+            }
+        }
+        catch {
+            throw new TaskRunnerError(`Configured docker compose command is not executable: ${configured}`);
+        }
+        if (commandExists(executable)) {
+            return parts;
+        }
+        throw new TaskRunnerError(`Configured docker compose command is not executable: ${configured}`);
+    }
+    if (commandExists("docker-compose")) {
+        return ["docker-compose"];
+    }
+    requireDockerCompose();
+    return ["docker", "compose"];
+}

package/dist/runtime/docker-runtime.js

@@ -0,0 +1,51 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function agentweaverHome(packageRoot) {
+    const configured = process.env.AGENTWEAVER_HOME?.trim();
+    if (configured) {
+        return path.resolve(configured);
+    }
+    return packageRoot;
+}
+export function defaultDockerComposeFile(packageRoot) {
+    return path.join(agentweaverHome(packageRoot), "docker-compose.yml");
+}
+function defaultCodexHomeDir(packageRoot) {
+    return path.join(agentweaverHome(packageRoot), ".codex-home");
+}
+function ensureRuntimeBindPath(targetPath, isDir) {
+    mkdirSync(path.dirname(targetPath), { recursive: true });
+    if (isDir) {
+        mkdirSync(targetPath, { recursive: true });
+    }
+    else if (!existsSync(targetPath)) {
+        writeFileSync(targetPath, "", "utf8");
+    }
+    return targetPath;
+}
+function defaultHostSshDir(packageRoot) {
+    const candidate = path.join(os.homedir(), ".ssh");
+    if (existsSync(candidate)) {
+        return candidate;
+    }
+    return ensureRuntimeBindPath(path.join(agentweaverHome(packageRoot), ".runtime", "ssh"), true);
+}
+function defaultHostGitconfig(packageRoot) {
+    const candidate = path.join(os.homedir(), ".gitconfig");
+    if (existsSync(candidate)) {
+        return candidate;
+    }
+    return ensureRuntimeBindPath(path.join(agentweaverHome(packageRoot), ".runtime", "gitconfig"), false);
+}
+export function dockerRuntimeEnv(packageRoot) {
+    const env = { ...process.env };
+    env.AGENTWEAVER_HOME ??= agentweaverHome(packageRoot);
+    env.PROJECT_DIR ??= process.cwd();
+    env.CODEX_HOME_DIR ??= ensureRuntimeBindPath(defaultCodexHomeDir(packageRoot), true);
+    env.HOST_SSH_DIR ??= defaultHostSshDir(packageRoot);
+    env.HOST_GITCONFIG ??= defaultHostGitconfig(packageRoot);
+    env.LOCAL_UID ??= typeof process.getuid === "function" ? String(process.getuid()) : "1000";
+    env.LOCAL_GID ??= typeof process.getgid === "function" ? String(process.getgid()) : "1000";
+    return env;
+}