agentweaver 0.1.10 → 0.1.11

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

@@ -0,0 +1,41 @@
+import { readFileSync } from "node:fs";
+import { printInfo, printPrompt, printSummary } from "../../tui.js";
+import { toExecutorContext } from "../types.js";
+export const codexPromptNode = {
+    kind: "codex-prompt",
+    version: 1,
+    async run(context, params) {
+        printInfo(params.labelText);
+        printPrompt("Codex", params.prompt);
+        const executor = context.executors.get("codex");
+        const value = await executor.execute(toExecutorContext(context), {
+            prompt: params.prompt,
+            ...(params.model ? { model: params.model } : {}),
+            env: { ...context.env },
+        }, executor.defaultConfig);
+        const outputPaths = Array.from(new Set([...(params.requiredArtifacts ?? []), ...(params.outputFile ? [params.outputFile] : [])]));
+        if (params.outputFile && params.summaryTitle) {
+            const summaryText = readFileSync(params.outputFile, "utf8").trim();
+            context.setSummary?.(summaryText);
+            printSummary(params.summaryTitle, summaryText);
+        }
+        return {
+            value,
+            outputs: outputPaths.map((path) => ({ kind: "artifact", path, required: true })),
+        };
+    },
+    checks(_context, params) {
+        const requiredPaths = Array.from(new Set([...(params.requiredArtifacts ?? []), ...(params.outputFile ? [params.outputFile] : [])]));
+        if (requiredPaths.length === 0) {
+            return [];
+        }
+        return [
+            {
+                kind: "require-artifacts",
+                paths: requiredPaths,
+                message: params.missingArtifactsMessage
+                    ?? (params.outputFile ? `Codex node did not produce ${params.outputFile}.` : "Codex node did not produce required artifacts."),
+            },
+        ];
+    },
+};

package/dist/pipeline/nodes/commit-message-form-node.js

@@ -0,0 +1,79 @@
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { TaskRunnerError } from "../../errors.js";
+import { validateUserInputValues } from "../../user-input.js";
+function parseCommitMessage(content) {
+    try {
+        const parsed = JSON.parse(content);
+        if (typeof parsed === "object" && parsed !== null) {
+            return {
+                subject: typeof parsed.subject === "string" ? parsed.subject : "",
+            };
+        }
+    }
+    catch {
+        // Fallback to plain text
+    }
+    return { subject: content.trim() };
+}
+export const commitMessageFormNode = {
+    kind: "commit-message-form",
+    version: 1,
+    async run(context, params) {
+        let commitMessage;
+        try {
+            const messageContent = readFileSync(params.commitMessageFile, "utf8");
+            commitMessage = parseCommitMessage(messageContent);
+        }
+        catch (error) {
+            throw new TaskRunnerError(`Failed to read commit message from ${params.commitMessageFile}: ${error.message}`);
+        }
+        const form = {
+            formId: params.formId,
+            title: params.title,
+            ...(params.description ? { description: params.description } : {}),
+            submitLabel: "Commit",
+            fields: [
+                {
+                    id: "commit_message",
+                    type: "text",
+                    label: "Commit message",
+                    help: "Format: {taskKey}: {taskDescription}. Subject ≤72 chars.",
+                    required: true,
+                    multiline: false,
+                    default: commitMessage.subject,
+                },
+            ],
+        };
+        const requester = context.requestUserInput ?? (await import("../../user-input.js")).requestUserInputInTerminal;
+        const result = await requester(form);
+        const commitMessageValue = result.values.commit_message;
+        if (typeof commitMessageValue !== "string" || commitMessageValue.trim().length === 0) {
+            throw new TaskRunnerError("Commit message is required.");
+        }
+        validateUserInputValues(form, result.values);
+        const outputDir = path.dirname(params.outputFile);
+        mkdirSync(outputDir, { recursive: true });
+        const outputContent = {
+            form_id: result.formId,
+            submitted_at: result.submittedAt,
+            values: result.values,
+        };
+        writeFileSync(params.outputFile, `${JSON.stringify(outputContent, null, 2)}\n`, "utf8");
+        return {
+            value: {
+                formId: result.formId,
+                submittedAt: result.submittedAt,
+                values: result.values,
+                outputFile: params.outputFile,
+            },
+            outputs: [
+                {
+                    kind: "artifact",
+                    path: params.outputFile,
+                    required: true,
+                },
+            ],
+        };
+    },
+};

package/dist/pipeline/nodes/git-commit-form-node.js

@@ -0,0 +1,138 @@
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import { TaskRunnerError } from "../../errors.js";
+import { validateUserInputValues } from "../../user-input.js";
+function parseCommitMessage(content) {
+    try {
+        const parsed = JSON.parse(content);
+        if (typeof parsed === "object" && parsed !== null) {
+            const result = {
+                subject: typeof parsed.subject === "string" ? parsed.subject : "",
+            };
+            if (typeof parsed.body === "string" && parsed.body.trim().length > 0) {
+                result.body = parsed.body.trim();
+            }
+            return result;
+        }
+    }
+    catch {
+        // Fallback to plain text
+    }
+    return { subject: content.trim(), body: "" };
+}
+export const gitCommitFormNode = {
+    kind: "git-commit-form",
+    version: 1,
+    async run(context, params) {
+        let gitStatusFiles;
+        try {
+            const statusContent = readFileSync(params.gitStatusJsonFile, "utf8");
+            const statusParsed = JSON.parse(statusContent);
+            gitStatusFiles = (statusParsed.files ?? []);
+        }
+        catch (error) {
+            throw new TaskRunnerError(`Failed to read git status from ${params.gitStatusJsonFile}: ${error.message}`);
+        }
+        let commitMessage;
+        try {
+            const messageContent = readFileSync(params.commitMessageFile, "utf8");
+            commitMessage = parseCommitMessage(messageContent);
+        }
+        catch (error) {
+            throw new TaskRunnerError(`Failed to read commit message from ${params.commitMessageFile}: ${error.message}`);
+        }
+        const fileOptions = gitStatusFiles.map((file) => ({
+            value: file.file,
+            label: file.originalFile
+                ? `${file.xy} ${file.originalFile} -> ${file.file}`
+                : `${file.xy} ${file.file}`,
+        }));
+        const defaultCommitMessage = commitMessage.body
+            ? `${commitMessage.subject}\n\n${commitMessage.body}`
+            : commitMessage.subject;
+        const form = {
+            formId: params.formId,
+            title: params.title,
+            ...(params.description ? { description: params.description } : {}),
+            submitLabel: "Commit",
+            fields: [
+                {
+                    id: "selected_files",
+                    type: "multi-select",
+                    label: "Select files to commit",
+                    help: "Choose the files you want to include in this commit",
+                    required: true,
+                    options: fileOptions,
+                    default: gitStatusFiles.map((f) => f.file),
+                },
+                {
+                    id: "commit_message",
+                    type: "text",
+                    label: "Commit message",
+                    help: "Edit the commit message if needed. Subject ≤72 chars, conventional commits format.",
+                    required: true,
+                    multiline: true,
+                    rows: 8,
+                    default: defaultCommitMessage,
+                },
+                {
+                    id: "edit_in_editor",
+                    type: "boolean",
+                    label: "Edit message in editor",
+                    help: "Open your EDITOR to edit the commit message before committing",
+                    required: false,
+                    default: false,
+                },
+                {
+                    id: "confirm",
+                    type: "boolean",
+                    label: "Confirm commit",
+                    help: "Set to true to proceed with the commit",
+                    required: true,
+                    default: true,
+                },
+            ],
+        };
+        const requester = context.requestUserInput ?? (await import("../../user-input.js")).requestUserInputInTerminal;
+        const result = await requester(form);
+        const commitMessageValue = result.values.commit_message;
+        const selectedFilesValue = result.values.selected_files;
+        const confirmValue = result.values.confirm;
+        if (!Array.isArray(selectedFilesValue) || selectedFilesValue.length === 0) {
+            throw new TaskRunnerError("At least one file must be selected for commit.");
+        }
+        if (typeof commitMessageValue !== "string" || commitMessageValue.trim().length === 0) {
+            throw new TaskRunnerError("Commit message is required.");
+        }
+        if (typeof confirmValue !== "boolean" || !confirmValue) {
+            throw new TaskRunnerError("Commit must be confirmed.");
+        }
+        validateUserInputValues(form, result.values);
+        const outputDir = path.dirname(params.outputFile);
+        mkdirSync(outputDir, { recursive: true });
+        const editInEditorValue = result.values.edit_in_editor === true;
+        const outputContent = {
+            form_id: result.formId,
+            submitted_at: result.submittedAt,
+            values: result.values,
+            edit_in_editor: editInEditorValue,
+        };
+        writeFileSync(params.outputFile, `${JSON.stringify(outputContent, null, 2)}\n`, "utf8");
+        return {
+            value: {
+                formId: result.formId,
+                submittedAt: result.submittedAt,
+                values: result.values,
+                outputFile: params.outputFile,
+                editInEditor: editInEditorValue,
+            },
+            outputs: [
+                {
+                    kind: "artifact",
+                    path: params.outputFile,
+                    required: true,
+                },
+            ],
+        };
+    },
+};

package/dist/pipeline/nodes/git-commit-node.js

@@ -0,0 +1,28 @@
+import { printInfo } from "../../tui.js";
+import { toExecutorContext } from "../types.js";
+export const gitCommitNode = {
+    kind: "git-commit",
+    version: 1,
+    async run(context, params) {
+        printInfo(params.labelText ?? "Committing changes");
+        if (context.dryRun) {
+            printInfo("DRY RUN: git commit не выполнен");
+            return {
+                value: {
+                    output: "",
+                    commitHash: null,
+                },
+            };
+        }
+        const executor = context.executors.get("git-commit");
+        const executorInput = {
+            message: params.message,
+            files: params.files,
+        };
+        if (params.editInEditor) {
+            executorInput.editEnabled = true;
+        }
+        const value = await executor.execute(toExecutorContext(context), executorInput, executor.defaultConfig);
+        return { value };
+    },
+};

package/dist/pipeline/nodes/git-status-node.js

@@ -0,0 +1,221 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { TaskRunnerError } from "../../errors.js";
+import { printInfo } from "../../tui.js";
+function unquoteGitPath(s) {
+    if (s.length < 2 || s[0] !== '"' || s[s.length - 1] !== '"') {
+        return s;
+    }
+    const inner = s.slice(1, -1);
+    const decoder = new TextDecoder();
+    let result = "";
+    const byteBuf = [];
+    const flushBytes = () => {
+        if (byteBuf.length > 0) {
+            result += decoder.decode(new Uint8Array(byteBuf));
+            byteBuf.length = 0;
+        }
+    };
+    for (let i = 0; i < inner.length; i++) {
+        if (inner[i] === "\\" && i + 1 < inner.length) {
+            const next = inner[i + 1];
+            switch (next) {
+                case "\\":
+                    flushBytes();
+                    result += "\\";
+                    i++;
+                    break;
+                case '"':
+                    flushBytes();
+                    result += '"';
+                    i++;
+                    break;
+                case "a":
+                    flushBytes();
+                    result += "\x07";
+                    i++;
+                    break;
+                case "b":
+                    flushBytes();
+                    result += "\b";
+                    i++;
+                    break;
+                case "f":
+                    flushBytes();
+                    result += "\f";
+                    i++;
+                    break;
+                case "n":
+                    flushBytes();
+                    result += "\n";
+                    i++;
+                    break;
+                case "r":
+                    flushBytes();
+                    result += "\r";
+                    i++;
+                    break;
+                case "t":
+                    flushBytes();
+                    result += "\t";
+                    i++;
+                    break;
+                case "v":
+                    flushBytes();
+                    result += "\v";
+                    i++;
+                    break;
+                default: {
+                    if (next >= "0" && next <= "7") {
+                        let octal = next;
+                        let consumed = 0;
+                        for (let j = 1; j <= 2 && i + 1 + j < inner.length; j++) {
+                            const ch = inner[i + 1 + j];
+                            if (ch !== undefined && ch >= "0" && ch <= "7") {
+                                octal += ch;
+                                consumed = j;
+                            }
+                            else {
+                                break;
+                            }
+                        }
+                        byteBuf.push(parseInt(octal, 8) & 0xff);
+                        i += 1 + consumed;
+                    }
+                    else {
+                        flushBytes();
+                        result += inner[i];
+                    }
+                    break;
+                }
+            }
+        }
+        else {
+            flushBytes();
+            result += inner[i];
+        }
+    }
+    flushBytes();
+    return result;
+}
+function splitRename(raw) {
+    let inQuote = false;
+    for (let i = 0; i <= raw.length - 4; i++) {
+        if (raw[i] === "\\" && inQuote) {
+            i++;
+            continue;
+        }
+        if (raw[i] === '"') {
+            inQuote = !inQuote;
+            continue;
+        }
+        if (!inQuote && raw.slice(i, i + 4) === " -> ") {
+            return { original: raw.slice(0, i), file: raw.slice(i + 4) };
+        }
+    }
+    return null;
+}
+export function parsePorcelain(output) {
+    const lines = output.split(/\r?\n/);
+    const files = [];
+    for (const line of lines) {
+        if (!line.trim()) {
+            continue;
+        }
+        const xy = line.slice(0, 2);
+        const rawFile = line.slice(3);
+        const indexStatus = xy[0] ?? " ";
+        const workTreeStatus = xy[1] ?? " ";
+        const staged = indexStatus !== " " && indexStatus !== "?";
+        let type;
+        if (indexStatus === "A" || workTreeStatus === "A") {
+            type = "added";
+        }
+        else if (indexStatus === "D" || workTreeStatus === "D") {
+            type = "deleted";
+        }
+        else if (indexStatus === "R") {
+            type = "renamed";
+        }
+        else if (indexStatus === "?" && workTreeStatus === "?") {
+            type = "untracked";
+        }
+        else {
+            type = "modified";
+        }
+        let file;
+        let originalFile;
+        if (indexStatus === "R" || indexStatus === "C") {
+            const parts = splitRename(rawFile);
+            if (parts) {
+                originalFile = unquoteGitPath(parts.original);
+                file = unquoteGitPath(parts.file);
+            }
+            else {
+                file = unquoteGitPath(rawFile);
+            }
+        }
+        else {
+            file = unquoteGitPath(rawFile);
+        }
+        files.push({
+            xy,
+            indexStatus,
+            workTreeStatus,
+            file,
+            ...(originalFile !== undefined ? { originalFile } : {}),
+            staged,
+            type,
+        });
+    }
+    return files;
+}
+function persistGitStatus(filePath, result) {
+    const dir = path.dirname(filePath);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(result, null, 2)}\n`, "utf8");
+}
+export const gitStatusNode = {
+    kind: "git-status",
+    version: 1,
+    async run(context, params) {
+        printInfo(params.labelText ?? "Collecting git status");
+        const porcelainOutput = await context.runtime.runCommand(["git", "status", "--porcelain"], {
+            dryRun: context.dryRun,
+            verbose: context.verbose,
+            label: "git status",
+        });
+        const files = parsePorcelain(porcelainOutput);
+        if (files.length === 0) {
+            throw new TaskRunnerError("Нет изменённых файлов для коммита.");
+        }
+        const diff = await context.runtime.runCommand(["git", "diff"], {
+            dryRun: context.dryRun,
+            verbose: context.verbose,
+            label: "git diff",
+        });
+        const stagedDiff = await context.runtime.runCommand(["git", "diff", "--cached"], {
+            dryRun: context.dryRun,
+            verbose: context.verbose,
+            label: "git diff --cached",
+        });
+        const fullDiff = stagedDiff + diff;
+        const diffStat = await context.runtime.runCommand(["git", "diff", "--stat"], {
+            dryRun: context.dryRun,
+            verbose: context.verbose,
+            label: "git diff --stat",
+        });
+        const result = {
+            files,
+            diff: fullDiff,
+            diffStat,
+        };
+        writeFileSync(params.outputFile, `${JSON.stringify(result, null, 2)}\n`, "utf8");
+        if (params.diffOutputFile) {
+            writeFileSync(params.diffOutputFile, fullDiff, "utf8");
+        }
+        return {
+            value: result,
+        };
+    },
+};

package/dist/pipeline/nodes/gitlab-review-artifacts-node.js

@@ -1,6 +1,9 @@
 import { writeFileSync } from "node:fs";
 import { readFileSync } from "node:fs";
 import { TaskRunnerError } from "../../errors.js";
+function normalizeMarkdownLanguage(mdLang) {
+    return mdLang === "en" ? "en" : "ru";
+}
 function commentLine(comment) {
     if (typeof comment.new_line === "number") {
         return comment.new_line;
@@ -44,7 +47,7 @@ function toReviewFinding(comment, index) {
             .join("\n"),
     };
 }
-function renderReviewMarkdown(artifact) {
+function renderReviewMarkdown(artifact, mdLang) {
     const lines = [
         "# Review",
         "",
@@ -54,7 +57,7 @@ function renderReviewMarkdown(artifact) {
         "",
     ];
     if (artifact.findings.length === 0) {
-        lines.push("Замечаний не найдено.");
+        lines.push(mdLang === "en" ? "No findings found." : "Замечаний не найдено.");
         return lines.join("\n");
     }
     artifact.findings.forEach((finding, index) => {
@@ -70,7 +73,7 @@ function renderReviewMarkdown(artifact) {
 export const gitlabReviewArtifactsNode = {
     kind: "gitlab-review-artifacts",
     version: 1,
-    async run(_context, params) {
+    async run(context, params) {
         let parsed;
         try {
             parsed = JSON.parse(readFileSync(params.gitlabReviewJsonFile, "utf8"));
@@ -84,13 +87,14 @@ export const gitlabReviewArtifactsNode = {
             .filter((finding) => finding !== null);
         const artifact = {
             summary: findings.length > 0
-                ? `Импортировано ${findings.length} комментариев код-ревью из GitLab.`
-                : "Комментарии код-ревью в GitLab не найдены.",
+                ? `Imported ${findings.length} GitLab code review comments.`
+                : "No GitLab code review comments found.",
             ready_to_merge: findings.length === 0,
             findings,
         };
+        const mdLang = normalizeMarkdownLanguage(context.mdLang);
         writeFileSync(params.reviewJsonFile, `${JSON.stringify(artifact, null, 2)}\n`, "utf8");
-        writeFileSync(params.reviewFile, `${renderReviewMarkdown(artifact)}\n`, "utf8");
+        writeFileSync(params.reviewFile, `${renderReviewMarkdown(artifact, mdLang)}\n`, "utf8");
         return {
             value: {
                 findingsCount: findings.length,

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

@@ -0,0 +1,10 @@
+import { parseJiraContext } from "../../scope.js";
+export const jiraContextNode = {
+    kind: "jira-context",
+    version: 1,
+    async run(_context, params) {
+        return {
+            value: parseJiraContext(params.jiraRef),
+        };
+    },
+};

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

@@ -0,0 +1,62 @@
+import { TaskRunnerError } from "../../errors.js";
+import { printInfo, printPrompt } from "../../tui.js";
+import { isAllowedModelForExecutor, isLlmExecutorId, } from "../launch-profile-config.js";
+import { toExecutorContext } from "../types.js";
+export const llmPromptNode = {
+    kind: "llm-prompt",
+    version: 1,
+    async run(context, params) {
+        if (!isLlmExecutorId(params.executor)) {
+            throw new TaskRunnerError(`Unsupported llm executor '${params.executor}'.`);
+        }
+        if (params.model && !isAllowedModelForExecutor(params.executor, params.model)) {
+            throw new TaskRunnerError(`Model '${params.model}' is not allowed for executor '${params.executor}'.`);
+        }
+        printInfo(params.labelText);
+        printPrompt(`LLM:${params.executor}`, params.prompt);
+        const executorContext = toExecutorContext(context);
+        if (params.executor === "codex") {
+            const executor = context.executors.get("codex");
+            const value = await executor.execute(executorContext, {
+                prompt: params.prompt,
+                ...(params.model ? { model: params.model } : {}),
+                env: { ...context.env },
+            }, executor.defaultConfig);
+            return {
+                value: {
+                    ...value,
+                    executor: "codex",
+                },
+                outputs: (params.requiredArtifacts ?? []).map((path) => ({ kind: "artifact", path, required: true })),
+            };
+        }
+        if (params.executor === "opencode") {
+            const executor = context.executors.get("opencode");
+            const value = await executor.execute(executorContext, {
+                prompt: params.prompt,
+                ...(params.model ? { model: params.model } : {}),
+                env: { ...context.env },
+            }, executor.defaultConfig);
+            return {
+                value: {
+                    ...value,
+                    executor: "opencode",
+                },
+                outputs: (params.requiredArtifacts ?? []).map((path) => ({ kind: "artifact", path, required: true })),
+            };
+        }
+        throw new TaskRunnerError(`Unsupported llm executor '${params.executor}'.`);
+    },
+    checks(_context, params) {
+        if (!params.requiredArtifacts || params.requiredArtifacts.length === 0) {
+            return [];
+        }
+        return [
+            {
+                kind: "require-artifacts",
+                paths: params.requiredArtifacts,
+                message: params.missingArtifactsMessage ?? "LLM prompt node did not produce required artifacts.",
+            },
+        ];
+    },
+};

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

@@ -6,7 +6,7 @@ export const planCodexNode = {
     async run(context, params) {
         printInfo("Running Codex planning mode");
         printPrompt("Codex", params.prompt);
-        const executor = context.executors.get("codex-local");
+        const executor = context.executors.get("codex");
         const input = {
             prompt: params.prompt,
             env: { ...context.env },

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

@@ -0,0 +1,11 @@
+import { readFileSync } from "node:fs";
+export const readFileNode = {
+    kind: "read-file",
+    version: 1,
+    async run(_context, params) {
+        const text = readFileSync(params.path, "utf8").trim();
+        return {
+            value: { text },
+        };
+    },
+};