agentweaver 0.1.6 → 0.1.8

package/dist/pipeline/flow-specs/run-go-linter-loop.json

@@ -0,0 +1,231 @@
+{
+  "kind": "run-go-linter-loop-flow",
+  "version": 1,
+  "phases": [
+    {
+      "id": "run_go_linter_try_1",
+      "steps": [
+        {
+          "id": "run_go_linter",
+          "node": "local-script-check",
+          "params": {
+            "argv": {
+              "list": [
+                { "ref": "params.runGoLinterScript" }
+              ]
+            },
+            "outputFile": {
+              "artifact": {
+                "kind": "run-go-linter-result-json-file",
+                "taskKey": { "ref": "params.taskKey" },
+                "iteration": { "const": 1 }
+              }
+            },
+            "labelText": {
+              "const": "Running run_go_linter.py locally (attempt 1)"
+            }
+          },
+          "expect": [
+            {
+              "kind": "require-file",
+              "when": { "not": { "ref": "context.dryRun" } },
+              "path": {
+                "artifact": {
+                  "kind": "run-go-linter-result-json-file",
+                  "taskKey": { "ref": "params.taskKey" },
+                  "iteration": { "const": 1 }
+                }
+              },
+              "message": "run-go-linter-loop did not produce the structured linter result artifact."
+            }
+          ],
+          "stopFlowIf": {
+            "equals": [
+              { "ref": "steps.run_go_linter_try_1.run_go_linter.outputs.parsed.ok" },
+              { "const": true }
+            ]
+          }
+        },
+        {
+          "id": "fix_go_linter",
+          "when": {
+            "equals": [
+              { "ref": "steps.run_go_linter_try_1.run_go_linter.outputs.parsed.ok" },
+              { "const": false }
+            ]
+          },
+          "node": "codex-local-prompt",
+          "prompt": {
+            "templateRef": "run-go-linter-loop-fix",
+            "vars": {
+              "linter_result_json_file": {
+                "artifact": {
+                  "kind": "run-go-linter-result-json-file",
+                  "taskKey": { "ref": "params.taskKey" },
+                  "iteration": { "const": 1 }
+                }
+              }
+            },
+            "extraPrompt": {
+              "appendPrompt": {
+                "base": { "ref": "params.extraPrompt" },
+                "suffix": {
+                  "template": "Последний результат run_go_linter.py сохранён в {result_file}. exitCode={exit_code}, summary={summary}.\nПолный raw-вывод последнего запуска:\n{raw_output}\nИсправь только то, что мешает успешному прохождению проверки.",
+                  "vars": {
+                    "result_file": {
+                      "artifact": {
+                        "kind": "run-go-linter-result-json-file",
+                        "taskKey": { "ref": "params.taskKey" },
+                        "iteration": { "const": 1 }
+                      }
+                    },
+                    "exit_code": { "ref": "steps.run_go_linter_try_1.run_go_linter.outputs.parsed.exitCode" },
+                    "summary": { "ref": "steps.run_go_linter_try_1.run_go_linter.outputs.parsed.summary" },
+                    "raw_output": { "ref": "steps.run_go_linter_try_1.run_go_linter.outputs.parsed.details.raw" }
+                  }
+                }
+              }
+            },
+            "format": "task-prompt"
+          },
+          "params": {
+            "labelText": {
+              "const": "Running Codex Go linter loop fix (attempt 1)"
+            },
+            "model": { "const": "gpt-5.4" }
+          }
+        }
+      ]
+    },
+    {
+      "repeat": {
+        "var": "attempt",
+        "from": 2,
+        "to": 5
+      },
+      "phases": [
+        {
+          "id": "run_go_linter_try_${attempt}",
+          "when": {
+            "equals": [
+              { "ref": "steps.run_go_linter_try_${attempt_minus_one}.run_go_linter.outputs.parsed.ok" },
+              { "const": false }
+            ]
+          },
+          "steps": [
+            {
+              "id": "run_go_linter",
+              "node": "local-script-check",
+              "params": {
+                "argv": {
+                  "list": [
+                    { "ref": "params.runGoLinterScript" }
+                  ]
+                },
+                "outputFile": {
+                  "artifact": {
+                    "kind": "run-go-linter-result-json-file",
+                    "taskKey": { "ref": "params.taskKey" },
+                    "iteration": { "ref": "repeat.attempt" }
+                  }
+                },
+                "labelText": {
+                  "template": "Running run_go_linter.py locally (attempt ${attempt})"
+                }
+              },
+              "expect": [
+                {
+                  "kind": "require-file",
+                  "when": { "not": { "ref": "context.dryRun" } },
+                  "path": {
+                    "artifact": {
+                      "kind": "run-go-linter-result-json-file",
+                      "taskKey": { "ref": "params.taskKey" },
+                      "iteration": { "ref": "repeat.attempt" }
+                    }
+                  },
+                  "message": "run-go-linter-loop did not produce the structured linter result artifact."
+                }
+              ],
+              "stopFlowIf": {
+                "equals": [
+                  { "ref": "steps.run_go_linter_try_${attempt}.run_go_linter.outputs.parsed.ok" },
+                  { "const": true }
+                ]
+              }
+            },
+            {
+              "id": "fix_go_linter",
+              "when": {
+                "equals": [
+                  { "ref": "steps.run_go_linter_try_${attempt}.run_go_linter.outputs.parsed.ok" },
+                  { "const": false }
+                ]
+              },
+              "node": "codex-local-prompt",
+              "prompt": {
+                "templateRef": "run-go-linter-loop-fix",
+                "vars": {
+                  "linter_result_json_file": {
+                    "artifact": {
+                      "kind": "run-go-linter-result-json-file",
+                      "taskKey": { "ref": "params.taskKey" },
+                      "iteration": { "ref": "repeat.attempt" }
+                    }
+                  }
+                },
+                "extraPrompt": {
+                  "appendPrompt": {
+                    "base": { "ref": "params.extraPrompt" },
+                    "suffix": {
+                      "template": "Последний результат run_go_linter.py сохранён в {result_file}. exitCode={exit_code}, summary={summary}.\nПолный raw-вывод последнего запуска:\n{raw_output}\nИсправь только то, что мешает успешному прохождению проверки.",
+                      "vars": {
+                        "result_file": {
+                          "artifact": {
+                            "kind": "run-go-linter-result-json-file",
+                            "taskKey": { "ref": "params.taskKey" },
+                            "iteration": { "ref": "repeat.attempt" }
+                          }
+                        },
+                        "exit_code": { "ref": "steps.run_go_linter_try_${attempt}.run_go_linter.outputs.parsed.exitCode" },
+                        "summary": { "ref": "steps.run_go_linter_try_${attempt}.run_go_linter.outputs.parsed.summary" },
+                        "raw_output": { "ref": "steps.run_go_linter_try_${attempt}.run_go_linter.outputs.parsed.details.raw" }
+                      }
+                    }
+                  }
+                },
+                "format": "task-prompt"
+              },
+              "params": {
+                "labelText": {
+                  "template": "Running Codex Go linter loop fix (attempt ${attempt})"
+                },
+                "model": { "const": "gpt-5.4" }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "run_go_linter_failed",
+      "steps": [
+        {
+          "id": "assert_run_go_linter_success",
+          "node": "file-check",
+          "params": {
+            "path": { "ref": "params.runGoLinterScript" }
+          },
+          "expect": [
+            {
+              "kind": "step-output",
+              "value": { "ref": "steps.run_go_linter_try_5.run_go_linter.outputs.parsed.ok" },
+              "equals": { "const": true },
+              "message": "run-go-linter-loop exhausted all attempts without a successful run_go_linter.py execution."
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

package/dist/pipeline/flow-specs/run-go-tests-loop.json

@@ -0,0 +1,231 @@
+{
+  "kind": "run-go-tests-loop-flow",
+  "version": 1,
+  "phases": [
+    {
+      "id": "run_go_tests_try_1",
+      "steps": [
+        {
+          "id": "run_go_tests",
+          "node": "local-script-check",
+          "params": {
+            "argv": {
+              "list": [
+                { "ref": "params.runGoTestsScript" }
+              ]
+            },
+            "outputFile": {
+              "artifact": {
+                "kind": "run-go-tests-result-json-file",
+                "taskKey": { "ref": "params.taskKey" },
+                "iteration": { "const": 1 }
+              }
+            },
+            "labelText": {
+              "const": "Running run_go_tests.py locally (attempt 1)"
+            }
+          },
+          "expect": [
+            {
+              "kind": "require-file",
+              "when": { "not": { "ref": "context.dryRun" } },
+              "path": {
+                "artifact": {
+                  "kind": "run-go-tests-result-json-file",
+                  "taskKey": { "ref": "params.taskKey" },
+                  "iteration": { "const": 1 }
+                }
+              },
+              "message": "run-go-tests-loop did not produce the structured tests result artifact."
+            }
+          ],
+          "stopFlowIf": {
+            "equals": [
+              { "ref": "steps.run_go_tests_try_1.run_go_tests.outputs.parsed.ok" },
+              { "const": true }
+            ]
+          }
+        },
+        {
+          "id": "fix_go_tests",
+          "when": {
+            "equals": [
+              { "ref": "steps.run_go_tests_try_1.run_go_tests.outputs.parsed.ok" },
+              { "const": false }
+            ]
+          },
+          "node": "codex-local-prompt",
+          "prompt": {
+            "templateRef": "run-go-tests-loop-fix",
+            "vars": {
+              "tests_result_json_file": {
+                "artifact": {
+                  "kind": "run-go-tests-result-json-file",
+                  "taskKey": { "ref": "params.taskKey" },
+                  "iteration": { "const": 1 }
+                }
+              }
+            },
+            "extraPrompt": {
+              "appendPrompt": {
+                "base": { "ref": "params.extraPrompt" },
+                "suffix": {
+                  "template": "Последний результат run_go_tests.py сохранён в {result_file}. exitCode={exit_code}, summary={summary}.\nПолный raw-вывод последнего запуска:\n{raw_output}\nИсправь только то, что мешает успешному прохождению проверки.",
+                  "vars": {
+                    "result_file": {
+                      "artifact": {
+                        "kind": "run-go-tests-result-json-file",
+                        "taskKey": { "ref": "params.taskKey" },
+                        "iteration": { "const": 1 }
+                      }
+                    },
+                    "exit_code": { "ref": "steps.run_go_tests_try_1.run_go_tests.outputs.parsed.exitCode" },
+                    "summary": { "ref": "steps.run_go_tests_try_1.run_go_tests.outputs.parsed.summary" },
+                    "raw_output": { "ref": "steps.run_go_tests_try_1.run_go_tests.outputs.parsed.details.raw" }
+                  }
+                }
+              }
+            },
+            "format": "task-prompt"
+          },
+          "params": {
+            "labelText": {
+              "const": "Running Codex Go tests loop fix (attempt 1)"
+            },
+            "model": { "const": "gpt-5.4" }
+          }
+        }
+      ]
+    },
+    {
+      "repeat": {
+        "var": "attempt",
+        "from": 2,
+        "to": 5
+      },
+      "phases": [
+        {
+          "id": "run_go_tests_try_${attempt}",
+          "when": {
+            "equals": [
+              { "ref": "steps.run_go_tests_try_${attempt_minus_one}.run_go_tests.outputs.parsed.ok" },
+              { "const": false }
+            ]
+          },
+          "steps": [
+            {
+              "id": "run_go_tests",
+              "node": "local-script-check",
+              "params": {
+                "argv": {
+                  "list": [
+                    { "ref": "params.runGoTestsScript" }
+                  ]
+                },
+                "outputFile": {
+                  "artifact": {
+                    "kind": "run-go-tests-result-json-file",
+                    "taskKey": { "ref": "params.taskKey" },
+                    "iteration": { "ref": "repeat.attempt" }
+                  }
+                },
+                "labelText": {
+                  "template": "Running run_go_tests.py locally (attempt ${attempt})"
+                }
+              },
+              "expect": [
+                {
+                  "kind": "require-file",
+                  "when": { "not": { "ref": "context.dryRun" } },
+                  "path": {
+                    "artifact": {
+                      "kind": "run-go-tests-result-json-file",
+                      "taskKey": { "ref": "params.taskKey" },
+                      "iteration": { "ref": "repeat.attempt" }
+                    }
+                  },
+                  "message": "run-go-tests-loop did not produce the structured tests result artifact."
+                }
+              ],
+              "stopFlowIf": {
+                "equals": [
+                  { "ref": "steps.run_go_tests_try_${attempt}.run_go_tests.outputs.parsed.ok" },
+                  { "const": true }
+                ]
+              }
+            },
+            {
+              "id": "fix_go_tests",
+              "when": {
+                "equals": [
+                  { "ref": "steps.run_go_tests_try_${attempt}.run_go_tests.outputs.parsed.ok" },
+                  { "const": false }
+                ]
+              },
+              "node": "codex-local-prompt",
+              "prompt": {
+                "templateRef": "run-go-tests-loop-fix",
+                "vars": {
+                  "tests_result_json_file": {
+                    "artifact": {
+                      "kind": "run-go-tests-result-json-file",
+                      "taskKey": { "ref": "params.taskKey" },
+                      "iteration": { "ref": "repeat.attempt" }
+                    }
+                  }
+                },
+                "extraPrompt": {
+                  "appendPrompt": {
+                    "base": { "ref": "params.extraPrompt" },
+                    "suffix": {
+                      "template": "Последний результат run_go_tests.py сохранён в {result_file}. exitCode={exit_code}, summary={summary}.\nПолный raw-вывод последнего запуска:\n{raw_output}\nИсправь только то, что мешает успешному прохождению проверки.",
+                      "vars": {
+                        "result_file": {
+                          "artifact": {
+                            "kind": "run-go-tests-result-json-file",
+                            "taskKey": { "ref": "params.taskKey" },
+                            "iteration": { "ref": "repeat.attempt" }
+                          }
+                        },
+                        "exit_code": { "ref": "steps.run_go_tests_try_${attempt}.run_go_tests.outputs.parsed.exitCode" },
+                        "summary": { "ref": "steps.run_go_tests_try_${attempt}.run_go_tests.outputs.parsed.summary" },
+                        "raw_output": { "ref": "steps.run_go_tests_try_${attempt}.run_go_tests.outputs.parsed.details.raw" }
+                      }
+                    }
+                  }
+                },
+                "format": "task-prompt"
+              },
+              "params": {
+                "labelText": {
+                  "template": "Running Codex Go tests loop fix (attempt ${attempt})"
+                },
+                "model": { "const": "gpt-5.4" }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "run_go_tests_failed",
+      "steps": [
+        {
+          "id": "assert_run_go_tests_success",
+          "node": "file-check",
+          "params": {
+            "path": { "ref": "params.runGoTestsScript" }
+          },
+          "expect": [
+            {
+              "kind": "step-output",
+              "value": { "ref": "steps.run_go_tests_try_5.run_go_tests.outputs.parsed.ok" },
+              "equals": { "const": true },
+              "message": "run-go-tests-loop exhausted all attempts without a successful run_go_tests.py execution."
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

package/dist/pipeline/flow-specs/task-describe.json

@@ -5,11 +5,36 @@
     {
       "id": "task_describe",
       "steps": [
+        {
+          "id": "fetch_jira",
+          "node": "jira-fetch",
+          "params": {
+            "jiraApiUrl": { "ref": "params.jiraApiUrl" },
+            "outputFile": {
+              "artifact": {
+                "kind": "jira-task-file",
+                "taskKey": { "ref": "params.taskKey" }
+              }
+            }
+          },
+          "expect": [
+            {
+              "kind": "require-file",
+              "path": {
+                "artifact": {
+                  "kind": "jira-task-file",
+                  "taskKey": { "ref": "params.taskKey" }
+                }
+              },
+              "message": "Jira fetch node did not produce the Jira task file."
+            }
+          ]
+        },
         {
           "id": "run_codex_task_describe",
           "node": "codex-local-prompt",
           "prompt": {
-            "inlineTemplate": "Посмотри задачу в {jira_task_file}. Проанализируй код и оформи краткое описание для Jira, без лишних подробностей. Сначала запиши source-of-truth JSON в {jira_description_json_file} в виде объекта { summary: string }, затем markdown-версию в {jira_description_file}.",
+            "templateRef": "task-describe",
             "vars": {
               "jira_task_file": {
                 "artifact": {

package/dist/pipeline/node-registry.js

@@ -8,6 +8,7 @@ import { fileCheckNode } from "./nodes/file-check-node.js";
 import { flowRunNode } from "./nodes/flow-run-node.js";
 import { gitlabReviewArtifactsNode } from "./nodes/gitlab-review-artifacts-node.js";
 import { jiraFetchNode } from "./nodes/jira-fetch-node.js";
+import { jiraIssueCheckNode } from "./nodes/jira-issue-check-node.js";
 import { localScriptCheckNode } from "./nodes/local-script-check-node.js";
 import { planCodexNode } from "./nodes/plan-codex-node.js";
 import { reviewClaudeNode } from "./nodes/review-claude-node.js";
@@ -27,6 +28,7 @@ const builtInNodes = {
     "flow-run": flowRunNode,
     "gitlab-review-artifacts": gitlabReviewArtifactsNode,
     "jira-fetch": jiraFetchNode,
+    "jira-issue-check": jiraIssueCheckNode,
     "local-script-check": localScriptCheckNode,
     "plan-codex": planCodexNode,
     "review-claude": reviewClaudeNode,
@@ -62,6 +64,12 @@ const builtInNodeMetadata = {
         requiredParams: ["gitlabReviewJsonFile", "reviewFile", "reviewJsonFile"],
     },
     "jira-fetch": { kind: "jira-fetch", version: 1, prompt: "forbidden", requiredParams: ["jiraApiUrl", "outputFile"] },
+    "jira-issue-check": {
+        kind: "jira-issue-check",
+        version: 1,
+        prompt: "forbidden",
+        requiredParams: ["jiraTaskFile", "allowedIssueTypes"],
+    },
     "local-script-check": { kind: "local-script-check", version: 1, prompt: "forbidden", requiredParams: ["argv", "labelText"] },
     "plan-codex": { kind: "plan-codex", version: 1, prompt: "forbidden", requiredParams: ["prompt", "requiredArtifacts"] },
     "review-claude": {

package/dist/pipeline/nodes/jira-issue-check-node.js

@@ -0,0 +1,53 @@
+import { readFileSync } from "node:fs";
+import { TaskRunnerError } from "../../errors.js";
+import { printInfo } from "../../tui.js";
+function extractIssueTypeName(path) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        throw new TaskRunnerError(`Failed to parse Jira issue JSON ${path}: ${error.message}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new TaskRunnerError(`Jira issue payload in ${path} must be a JSON object.`);
+    }
+    const fields = parsed.fields;
+    if (!fields || typeof fields !== "object" || Array.isArray(fields)) {
+        throw new TaskRunnerError(`Jira issue payload in ${path} does not contain 'fields'.`);
+    }
+    const issueType = fields.issuetype;
+    if (!issueType || typeof issueType !== "object" || Array.isArray(issueType)) {
+        throw new TaskRunnerError(`Jira issue payload in ${path} does not contain 'fields.issuetype'.`);
+    }
+    const issueTypeName = issueType.name;
+    if (typeof issueTypeName !== "string" || issueTypeName.trim().length === 0) {
+        throw new TaskRunnerError(`Jira issue payload in ${path} does not contain 'fields.issuetype.name'.`);
+    }
+    return issueTypeName.trim();
+}
+export const jiraIssueCheckNode = {
+    kind: "jira-issue-check",
+    version: 1,
+    async run(_context, params) {
+        if (params.labelText) {
+            printInfo(params.labelText);
+        }
+        const issueType = extractIssueTypeName(params.jiraTaskFile);
+        const normalizedIssueType = issueType.toLowerCase();
+        const allowedIssueTypes = params.allowedIssueTypes
+            .map((candidate) => candidate.trim())
+            .filter((candidate) => candidate.length > 0);
+        if (allowedIssueTypes.length === 0) {
+            throw new TaskRunnerError("jira-issue-check requires at least one allowed issue type.");
+        }
+        const isAllowed = allowedIssueTypes.some((candidate) => candidate.toLowerCase() === normalizedIssueType);
+        if (!isAllowed) {
+            throw new TaskRunnerError(`Flow 'bug-analyze' supports only Jira issue types: ${allowedIssueTypes.join(", ")}. ` +
+                `Fetched issue type: ${issueType}.`);
+        }
+        return {
+            value: { issueType },
+        };
+    },
+};

package/dist/pipeline/nodes/local-script-check-node.js

@@ -1,3 +1,5 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
 import { TaskRunnerError } from "../../errors.js";
 import { printInfo } from "../../tui.js";
 function parseStructuredResult(output, commandLabel) {
@@ -59,22 +61,62 @@ function parseStructuredResult(output, commandLabel) {
     }
     throw new TaskRunnerError(`Structured result is missing or invalid in output of '${commandLabel}'.`);
 }
+function fallbackStructuredResult(output, commandLabel, exitCode) {
+    return {
+        ok: false,
+        kind: "check",
+        stage: commandLabel,
+        exitCode,
+        summary: `${commandLabel} failed`,
+        command: commandLabel,
+        details: output.trim().length > 0 ? { raw: output } : {},
+    };
+}
+function persistStructuredResult(filePath, parsed) {
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(parsed, null, 2)}\n`, "utf8");
+}
 export const localScriptCheckNode = {
     kind: "local-script-check",
     version: 1,
     async run(context, params) {
         printInfo(params.labelText);
-        const output = await context.runtime.runCommand(params.argv, {
-            dryRun: context.dryRun,
-            verbose: context.verbose,
-            label: params.argv.join(" "),
-            printFailureOutput: true,
-            env: { ...context.env },
-        });
+        const commandLabel = params.argv.join(" ");
+        let output = "";
+        let parsed;
+        try {
+            output = await context.runtime.runCommand(params.argv, {
+                dryRun: context.dryRun,
+                verbose: context.verbose,
+                label: commandLabel,
+                printFailureOutput: true,
+                env: { ...context.env },
+            });
+            parsed = parseStructuredResult(output, commandLabel);
+        }
+        catch (error) {
+            output = String(error.output ?? "");
+            const exitCode = Number(error.returnCode ?? 1);
+            try {
+                parsed = parseStructuredResult(output, commandLabel);
+            }
+            catch {
+                parsed = fallbackStructuredResult(output, commandLabel, exitCode);
+            }
+        }
+        if (typeof parsed.details.raw !== "string") {
+            parsed.details = {
+                ...parsed.details,
+                raw: output,
+            };
+        }
+        if (params.outputFile) {
+            persistStructuredResult(params.outputFile, parsed);
+        }
         return {
             value: {
                 output,
-                parsed: parseStructuredResult(output, params.argv.join(" ")),
+                parsed,
             },
         };
     },