agentweaver 0.1.8 → 0.1.9

package/dist/jira.js

@@ -3,6 +3,54 @@ import { writeFile } from "node:fs/promises";
 import path from "node:path";
 import { TaskRunnerError } from "./errors.js";
 const ISSUE_KEY_RE = /^[A-Z][A-Z0-9_]*-[0-9]+$/;
+const TEXT_ATTACHMENT_EXTENSIONS = new Set([".md", ".json", ".txt"]);
+const DOWNLOAD_ONLY_ATTACHMENT_EXTENSIONS = new Set([".doc"]);
+function sanitizeAttachmentFileName(fileName) {
+    const parsed = path.parse(fileName);
+    const baseName = parsed.name
+        .trim()
+        .replaceAll(/[^a-zA-Z0-9._-]+/g, "-")
+        .replaceAll(/-+/g, "-")
+        .replaceAll(/^-|-$/g, "");
+    const safeBaseName = baseName.length > 0 ? baseName : "attachment";
+    const extension = parsed.ext.replaceAll(/[^a-zA-Z0-9.]+/g, "").toLowerCase();
+    return `${safeBaseName}${extension}`;
+}
+function attachmentExtension(fileName) {
+    return path.extname(fileName).toLowerCase();
+}
+function parseJiraAttachments(issueBody) {
+    try {
+        const parsed = JSON.parse(issueBody.toString("utf8"));
+        return Array.isArray(parsed.fields?.attachment) ? parsed.fields.attachment : [];
+    }
+    catch {
+        return [];
+    }
+}
+async function fetchAuthorizedBuffer(url, accept) {
+    const jiraApiKey = process.env.JIRA_API_KEY;
+    if (!jiraApiKey) {
+        throw new TaskRunnerError("JIRA_API_KEY is required for Jira fetch.");
+    }
+    const response = await fetch(url, {
+        headers: {
+            Authorization: `Bearer ${jiraApiKey}`,
+            Accept: accept,
+        },
+    });
+    if (!response.ok) {
+        throw new TaskRunnerError(`Failed to fetch Jira resource: HTTP ${response.status}`);
+    }
+    return Buffer.from(await response.arrayBuffer());
+}
+function toTextAttachmentContent(fileName, body) {
+    return [
+        `=== Attachment: ${fileName} ===`,
+        body.toString("utf8").trimEnd(),
+        "",
+    ].join("\n");
+}
 export function extractIssueKey(jiraRef) {
     const normalizedRef = jiraRef.replace(/\/+$/, "");
     if (normalizedRef.includes("://")) {
@@ -33,23 +81,77 @@ export function buildJiraApiUrl(jiraRef) {
     const baseUrl = browseUrl.split("/browse/")[0];
     return `${baseUrl}/rest/api/2/issue/${issueKey}`;
 }
-export async function fetchJiraIssue(jiraApiUrl, jiraTaskFile) {
-    const jiraApiKey = process.env.JIRA_API_KEY;
-    if (!jiraApiKey) {
-        throw new TaskRunnerError("JIRA_API_KEY is required for plan mode.");
+export async function fetchJiraIssue(jiraApiUrl, jiraTaskFile, attachmentsManifestFile, attachmentsContextFile) {
+    const body = await fetchAuthorizedBuffer(jiraApiUrl, "application/json");
+    mkdirSync(path.dirname(jiraTaskFile), { recursive: true });
+    await writeFile(jiraTaskFile, body);
+    const attachments = parseJiraAttachments(body);
+    const manifestItems = [];
+    const planningContextChunks = [];
+    const attachmentsDir = attachmentsManifestFile ? path.join(path.dirname(attachmentsManifestFile), "jira-attachments") : null;
+    if (attachmentsManifestFile) {
+        mkdirSync(path.dirname(attachmentsManifestFile), { recursive: true });
     }
-    const response = await fetch(jiraApiUrl, {
-        headers: {
-            Authorization: `Bearer ${jiraApiKey}`,
-            Accept: "application/json",
+    if (attachmentsContextFile) {
+        mkdirSync(path.dirname(attachmentsContextFile), { recursive: true });
+    }
+    if (attachmentsDir) {
+        mkdirSync(attachmentsDir, { recursive: true });
+    }
+    for (const [index, attachment] of attachments.entries()) {
+        const fileName = typeof attachment.filename === "string" ? attachment.filename.trim() : "";
+        const downloadUrl = typeof attachment.content === "string" ? attachment.content.trim() : "";
+        if (!fileName || !downloadUrl) {
+            continue;
+        }
+        const extension = attachmentExtension(fileName);
+        const shouldDownload = TEXT_ATTACHMENT_EXTENSIONS.has(extension) || DOWNLOAD_ONLY_ATTACHMENT_EXTENSIONS.has(extension);
+        if (!shouldDownload || !attachmentsDir) {
+            continue;
+        }
+        const safeFileName = `${String(index + 1).padStart(3, "0")}-${sanitizeAttachmentFileName(fileName)}`;
+        const savedPath = path.join(attachmentsDir, safeFileName);
+        const attachmentBody = await fetchAuthorizedBuffer(downloadUrl, "*/*");
+        await writeFile(savedPath, attachmentBody);
+        const includedInPlanningContext = TEXT_ATTACHMENT_EXTENSIONS.has(extension);
+        if (includedInPlanningContext) {
+            planningContextChunks.push(toTextAttachmentContent(fileName, attachmentBody));
+        }
+        manifestItems.push({
+            id: typeof attachment.id === "string" ? attachment.id : String(attachment.id ?? ""),
+            fileName,
+            extension,
+            mimeType: typeof attachment.mimeType === "string" ? attachment.mimeType : null,
+            sizeBytes: typeof attachment.size === "number" ? attachment.size : null,
+            createdAt: typeof attachment.created === "string" ? attachment.created : null,
+            downloadUrl,
+            savedPath,
+            includedInPlanningContext,
+        });
+    }
+    const manifest = {
+        summary: {
+            downloadedCount: manifestItems.length,
+            planningContextCount: manifestItems.filter((item) => item.includedInPlanningContext).length,
         },
-    });
-    if (!response.ok) {
-        throw new TaskRunnerError(`Failed to fetch Jira issue: HTTP ${response.status}`);
+        attachments: manifestItems,
+    };
+    if (attachmentsManifestFile) {
+        await writeFile(attachmentsManifestFile, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
     }
-    const body = Buffer.from(await response.arrayBuffer());
-    mkdirSync(path.dirname(jiraTaskFile), { recursive: true });
-    await writeFile(jiraTaskFile, body);
+    if (attachmentsContextFile) {
+        const contextBody = planningContextChunks.length > 0
+            ? planningContextChunks.join("\n")
+            : "No supported text attachments were downloaded from Jira.\n";
+        await writeFile(attachmentsContextFile, contextBody, "utf8");
+    }
+    return {
+        issueFile: jiraTaskFile,
+        downloadedAttachments: manifest.summary.downloadedCount,
+        planningContextAttachments: manifest.summary.planningContextCount,
+        ...(attachmentsManifestFile ? { attachmentsManifestFile } : {}),
+        ...(attachmentsContextFile ? { attachmentsContextFile } : {}),
+    };
 }
 export function requireJiraTaskFile(jiraTaskFile) {
     if (!existsSync(jiraTaskFile)) {

package/dist/pipeline/auto-flow.js

@@ -4,6 +4,6 @@ export function loadAutoFlow() {
     if (cachedAutoFlow) {
         return cachedAutoFlow;
     }
-    cachedAutoFlow = loadDeclarativeFlow("auto.json");
+    cachedAutoFlow = loadDeclarativeFlow({ source: "built-in", fileName: "auto.json" });
     return cachedAutoFlow;
 }

package/dist/pipeline/declarative-flows.js

@@ -1,16 +1,28 @@
+import path from "node:path";
 import { createNodeRegistry } from "./node-registry.js";
+import { createExecutorRegistry } from "./registry.js";
 import { compileFlowSpec } from "./spec-compiler.js";
-import { loadFlowSpecSync } from "./spec-loader.js";
+import { listBuiltInFlowSpecFiles, listProjectFlowSpecFiles, loadFlowSpecSync, projectFlowSpecsDir, resolveBuiltInFlowSpecPath } from "./spec-loader.js";
 import { validateExpandedPhases, validateFlowSpec } from "./spec-validator.js";
 const cache = new Map();
-export function loadDeclarativeFlow(fileName) {
-    const cached = cache.get(fileName);
+function toFlowSpecSource(ref) {
+    return ref.source === "built-in" ? { source: "built-in", fileName: ref.fileName } : { source: "project-local", filePath: ref.filePath };
+}
+function cacheKey(ref) {
+    return ref.source === "built-in" ? `built-in:${ref.fileName}` : `project-local:${path.resolve(ref.filePath)}`;
+}
+export function loadDeclarativeFlow(flow) {
+    const ref = typeof flow === "string" ? { source: "built-in", fileName: flow } : flow;
+    const cached = cache.get(cacheKey(ref));
     if (cached) {
         return cached;
     }
-    const spec = loadFlowSpecSync(fileName);
+    const spec = loadFlowSpecSync(toFlowSpecSource(ref));
     const nodeRegistry = createNodeRegistry();
-    validateFlowSpec(spec, nodeRegistry);
+    const executorRegistry = createExecutorRegistry();
+    validateFlowSpec(spec, nodeRegistry, executorRegistry, {
+        resolveFlowByName: (fileName) => resolveNamedDeclarativeFlowRef(fileName, process.cwd()),
+    });
     const phases = compileFlowSpec(spec);
     validateExpandedPhases(phases);
     const loaded = {
@@ -18,7 +30,30 @@ export function loadDeclarativeFlow(fileName) {
         version: spec.version,
         constants: spec.constants ?? {},
         phases,
+        source: ref.source,
+        fileName: ref.source === "built-in" ? ref.fileName : path.basename(ref.filePath),
+        absolutePath: ref.source === "built-in" ? resolveBuiltInFlowSpecPath(ref.fileName) : path.resolve(ref.filePath),
     };
-    cache.set(fileName, loaded);
+    cache.set(cacheKey(ref), loaded);
     return loaded;
 }
+export function resolveNamedDeclarativeFlowRef(fileName, cwd) {
+    const projectMatches = listProjectFlowSpecFiles(cwd).filter((candidate) => path.basename(candidate) === fileName);
+    const builtInExists = listBuiltInFlowSpecFiles().includes(fileName);
+    if (projectMatches.length > 0 && builtInExists) {
+        throw new Error(`Ambiguous nested flow '${fileName}': both built-in and project-local specs exist in ${projectFlowSpecsDir(cwd)}.`);
+    }
+    if (projectMatches.length > 1) {
+        throw new Error(`Ambiguous project-local flow '${fileName}' in ${projectFlowSpecsDir(cwd)}.`);
+    }
+    if (projectMatches[0]) {
+        return { source: "project-local", filePath: projectMatches[0] };
+    }
+    if (builtInExists) {
+        return { source: "built-in", fileName };
+    }
+    throw new Error(`Nested flow '${fileName}' was not found.`);
+}
+export function loadNamedDeclarativeFlow(fileName, cwd) {
+    return loadDeclarativeFlow(resolveNamedDeclarativeFlowRef(fileName, cwd));
+}

package/dist/pipeline/flow-catalog.js

@@ -0,0 +1,66 @@
+import path from "node:path";
+import { TaskRunnerError } from "../errors.js";
+import { loadAutoFlow } from "./auto-flow.js";
+import { loadDeclarativeFlow } from "./declarative-flows.js";
+import { listProjectFlowSpecFiles } from "./spec-loader.js";
+export const INTERACTIVE_BUILT_IN_FLOWS = [
+    { id: "auto", fileName: "auto.json" },
+    { id: "bug-analyze", fileName: "bug-analyze.json" },
+    { id: "bug-fix", fileName: "bug-fix.json" },
+    { id: "gitlab-diff-review", fileName: "gitlab-diff-review.json" },
+    { id: "gitlab-review", fileName: "gitlab-review.json" },
+    { id: "mr-description", fileName: "mr-description.json" },
+    { id: "plan", fileName: "plan.json" },
+    { id: "task-describe", fileName: "task-describe.json" },
+    { id: "implement", fileName: "implement.json" },
+    { id: "review", fileName: "review.json" },
+    { id: "review-fix", fileName: "review-fix.json" },
+    { id: "run-go-tests-loop", fileName: "run-go-tests-loop.json" },
+    { id: "run-go-linter-loop", fileName: "run-go-linter-loop.json" },
+];
+function loadBuiltInCatalogEntry(id, fileName) {
+    const flow = id === "auto" ? loadAutoFlow() : loadDeclarativeFlow({ source: "built-in", fileName });
+    return {
+        id,
+        source: "built-in",
+        fileName,
+        absolutePath: flow.absolutePath,
+        flow,
+    };
+}
+function loadProjectCatalogEntry(filePath) {
+    const flow = loadDeclarativeFlow({ source: "project-local", filePath });
+    return {
+        id: path.basename(filePath, path.extname(filePath)),
+        source: "project-local",
+        fileName: path.basename(filePath),
+        absolutePath: path.resolve(filePath),
+        flow,
+    };
+}
+export function loadInteractiveFlowCatalog(cwd) {
+    const entries = INTERACTIVE_BUILT_IN_FLOWS.map((entry) => loadBuiltInCatalogEntry(entry.id, entry.fileName));
+    for (const filePath of listProjectFlowSpecFiles(cwd)) {
+        entries.push(loadProjectCatalogEntry(filePath));
+    }
+    const byId = new Map();
+    for (const entry of entries) {
+        const duplicate = byId.get(entry.id);
+        if (duplicate) {
+            throw new TaskRunnerError(`Flow id '${entry.id}' conflicts between ${duplicate.absolutePath} and ${entry.absolutePath}. Rename one of the flow files.`);
+        }
+        byId.set(entry.id, entry);
+    }
+    return entries;
+}
+export function findCatalogEntry(flowId, entries) {
+    return entries.find((entry) => entry.id === flowId);
+}
+export function isBuiltInCommandFlowId(flowId) {
+    return INTERACTIVE_BUILT_IN_FLOWS.some((entry) => entry.id === flowId);
+}
+export function toDeclarativeFlowRef(entry) {
+    return entry.source === "built-in"
+        ? { source: "built-in", fileName: entry.fileName }
+        : { source: "project-local", filePath: entry.absolutePath };
+}

package/dist/pipeline/flow-specs/auto.json

@@ -18,6 +18,18 @@
                 "kind": "jira-task-file",
                 "taskKey": { "ref": "params.taskKey" }
               }
+            },
+            "attachmentsManifestFile": {
+              "artifact": {
+                "kind": "jira-attachments-manifest-file",
+                "taskKey": { "ref": "params.taskKey" }
+              }
+            },
+            "attachmentsContextFile": {
+              "artifact": {
+                "kind": "jira-attachments-context-file",
+                "taskKey": { "ref": "params.taskKey" }
+              }
             }
           },
           "expect": [
@@ -30,6 +42,26 @@
                 }
               },
               "message": "Jira fetch node did not produce the Jira task file."
+            },
+            {
+              "kind": "require-file",
+              "path": {
+                "artifact": {
+                  "kind": "jira-attachments-manifest-file",
+                  "taskKey": { "ref": "params.taskKey" }
+                }
+              },
+              "message": "Jira fetch node did not produce the Jira attachments manifest file."
+            },
+            {
+              "kind": "require-file",
+              "path": {
+                "artifact": {
+                  "kind": "jira-attachments-context-file",
+                  "taskKey": { "ref": "params.taskKey" }
+                }
+              },
+              "message": "Jira fetch node did not produce the Jira attachments context file."
             }
           ]
         },
@@ -166,6 +198,139 @@
             }
           ]
         },
+        {
+          "id": "generate_planning_questions",
+          "node": "codex-local-prompt",
+          "prompt": {
+            "templateRef": "plan-questions",
+            "vars": {
+              "jira_task_file": {
+                "artifact": {
+                  "kind": "jira-task-file",
+                  "taskKey": { "ref": "params.taskKey" }
+                }
+              },
+              "jira_attachments_manifest_file": {
+                "artifact": {
+                  "kind": "jira-attachments-manifest-file",
+                  "taskKey": { "ref": "params.taskKey" }
+                }
+              },
+              "jira_attachments_context_file": {
+                "artifact": {
+                  "kind": "jira-attachments-context-file",
+                  "taskKey": { "ref": "params.taskKey" }
+                }
+              },
+              "planning_questions_json_file": {
+                "artifact": {
+                  "kind": "planning-questions-json-file",
+                  "taskKey": { "ref": "params.taskKey" }
+                }
+              }
+            },
+            "extraPrompt": { "ref": "params.extraPrompt" },
+            "format": "task-prompt"
+          },
+          "params": {
+            "labelText": { "const": "Generating planning questions" },
+            "model": { "const": "gpt-5.4" },
+            "requiredArtifacts": {
+              "list": [
+                {
+                  "artifact": {
+                    "kind": "planning-questions-json-file",
+                    "taskKey": { "ref": "params.taskKey" }
+                  }
+                }
+              ]
+            }
+          },
+          "expect": [
+            {
+              "kind": "require-artifacts",
+              "when": { "not": { "ref": "context.dryRun" } },
+              "paths": {
+                "list": [
+                  {
+                    "artifact": {
+                      "kind": "planning-questions-json-file",
+                      "taskKey": { "ref": "params.taskKey" }
+                    }
+                  }
+                ]
+              },
+              "message": "Planning questions step did not produce the questions artifact."
+            },
+            {
+              "kind": "require-structured-artifacts",
+              "when": { "not": { "ref": "context.dryRun" } },
+              "items": [
+                {
+                  "path": {
+                    "artifact": {
+                      "kind": "planning-questions-json-file",
+                      "taskKey": { "ref": "params.taskKey" }
+                    }
+                  },
+                  "schemaId": "planning-questions/v1"
+                }
+              ],
+              "message": "Planning questions step produced invalid structured artifacts."
+            }
+          ]
+        },
+        {
+          "id": "build_planning_questions_form",
+          "node": "planning-questions-form",
+          "params": {
+            "planningQuestionsJsonFile": {
+              "artifact": {
+                "kind": "planning-questions-json-file",
+                "taskKey": { "ref": "params.taskKey" }
+              }
+            },
+            "formId": { "const": "planning-questions" },
+            "title": { "const": "Planning Questions" },
+            "description": {
+              "const": "Ответьте на вопросы модели, если они нужны для точного design/plan. Если вопросов нет, шаг завершится автоматически."
+            }
+          }
+        },
+        {
+          "id": "collect_planning_answers",
+          "node": "user-input",
+          "params": {
+            "formId": { "ref": "steps.plan.build_planning_questions_form.value.formId" },
+            "title": { "ref": "steps.plan.build_planning_questions_form.value.title" },
+            "description": { "ref": "steps.plan.build_planning_questions_form.value.description" },
+            "submitLabel": { "const": "Continue planning" },
+            "fields": { "ref": "steps.plan.build_planning_questions_form.value.fields" },
+            "outputFile": {
+              "artifact": {
+                "kind": "planning-answers-json-file",
+                "taskKey": { "ref": "params.taskKey" }
+              }
+            }
+          },
+          "expect": [
+            {
+              "kind": "require-structured-artifacts",
+              "items": [
+                {
+                  "path": {
+                    "artifact": {
+                      "kind": "planning-answers-json-file",
+                      "taskKey": { "ref": "params.taskKey" }
+                    }
+                  },
+                  "schemaId": "user-input/v1"
+                }
+              ],
+              "message": "Planning answers input is missing or invalid."
+            }
+          ]
+        },
         {
           "id": "run_codex_plan",
           "node": "codex-local-prompt",
@@ -178,6 +343,18 @@
                   "taskKey": { "ref": "params.taskKey" }
                 }
               },
+              "jira_attachments_manifest_file": {
+                "artifact": {
+                  "kind": "jira-attachments-manifest-file",
+                  "taskKey": { "ref": "params.taskKey" }
+                }
+              },
+              "jira_attachments_context_file": {
+                "artifact": {
+                  "kind": "jira-attachments-context-file",
+                  "taskKey": { "ref": "params.taskKey" }
+                }
+              },
               "design_file": {
                 "artifact": {
                   "kind": "design-file",
@@ -215,7 +392,12 @@
                 }
               }
             },
-            "extraPrompt": { "ref": "params.extraPrompt" },
+            "extraPrompt": {
+              "appendPrompt": {
+                "base": { "ref": "params.extraPrompt" },
+                "suffix": { "ref": "steps.plan.collect_planning_answers.value.promptSuffix" }
+              }
+            },
             "format": "task-prompt"
           },
           "params": {