agentweaver 0.1.10 → 0.1.12

package/dist/jira.js

@@ -5,6 +5,57 @@ 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"]);
+const JIRA_AUTH_MODES = new Set(["auto", "basic", "bearer"]);
+function parseJiraAuthMode(rawMode) {
+    const mode = rawMode?.trim().toLowerCase() || "auto";
+    if (!JIRA_AUTH_MODES.has(mode)) {
+        throw new TaskRunnerError("JIRA_AUTH_MODE must be one of: auto, basic, bearer.");
+    }
+    return mode;
+}
+export function detectJiraDeployment(url) {
+    try {
+        return new URL(url).hostname.toLowerCase().includes("atlassian") ? "cloud" : "server";
+    }
+    catch {
+        return url.toLowerCase().includes("atlassian") ? "cloud" : "server";
+    }
+}
+export function resolveJiraAuthMode(url) {
+    const authMode = parseJiraAuthMode(process.env.JIRA_AUTH_MODE);
+    if (authMode !== "auto") {
+        return authMode;
+    }
+    return detectJiraDeployment(url) === "cloud" ? "basic" : "bearer";
+}
+export function buildJiraAuthHeaders(url) {
+    const jiraApiKey = process.env.JIRA_API_KEY?.trim();
+    if (!jiraApiKey) {
+        throw new TaskRunnerError("JIRA_API_KEY is required for Jira authentication.");
+    }
+    const authMode = resolveJiraAuthMode(url);
+    if (authMode === "bearer") {
+        return {
+            Authorization: `Bearer ${jiraApiKey}`,
+        };
+    }
+    const jiraUsername = process.env.JIRA_USERNAME?.trim();
+    if (!jiraUsername) {
+        const host = (() => {
+            try {
+                return new URL(url).host;
+            }
+            catch {
+                return "unknown";
+            }
+        })();
+        throw new TaskRunnerError(`JIRA_USERNAME is required for Jira Cloud Basic auth (detected from URL host: ${host}).`);
+    }
+    const encodedCredentials = Buffer.from(`${jiraUsername}:${jiraApiKey}`).toString("base64");
+    return {
+        Authorization: `Basic ${encodedCredentials}`,
+    };
+}
 function sanitizeAttachmentFileName(fileName) {
     const parsed = path.parse(fileName);
     const baseName = parsed.name
@@ -29,13 +80,9 @@ function parseJiraAttachments(issueBody) {
     }
 }
 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}`,
+            ...buildJiraAuthHeaders(url),
             Accept: accept,
         },
     });
@@ -44,6 +91,26 @@ async function fetchAuthorizedBuffer(url, accept) {
     }
     return Buffer.from(await response.arrayBuffer());
 }
+function isSubtask(issue) {
+    return issue.fields?.issuetype?.subtask === true;
+}
+function getParentKey(issue) {
+    if (!issue.fields?.parent?.key) {
+        return null;
+    }
+    return issue.fields.parent.key;
+}
+function normalizeIssue(jiraRaw) {
+    const issue = jiraRaw;
+    const key = issue.key ?? null;
+    const summary = typeof issue.fields?.summary === "string" ? issue.fields.summary : "";
+    const description = typeof issue.fields?.description === "string" ? issue.fields.description : "";
+    const type = typeof issue.fields?.issuetype?.name === "string" ? issue.fields.issuetype.name : "";
+    if (!key) {
+        return null;
+    }
+    return { key, type, summary, description };
+}
 function toTextAttachmentContent(fileName, body) {
     return [
         `=== Attachment: ${fileName} ===`,
@@ -85,6 +152,42 @@ export async function fetchJiraIssue(jiraApiUrl, jiraTaskFile, attachmentsManife
     const body = await fetchAuthorizedBuffer(jiraApiUrl, "application/json");
     mkdirSync(path.dirname(jiraTaskFile), { recursive: true });
     await writeFile(jiraTaskFile, body);
+    let enrichedFile;
+    try {
+        const rawIssue = JSON.parse(body.toString("utf8"));
+        const normalizedChild = normalizeIssue(rawIssue);
+        if (normalizedChild && isSubtask(rawIssue)) {
+            const parentKey = getParentKey(rawIssue);
+            let parentNormalized = null;
+            if (parentKey) {
+                try {
+                    const parentUrl = buildJiraApiUrl(parentKey);
+                    const parentBody = await fetchAuthorizedBuffer(parentUrl, "application/json");
+                    const parentRaw = JSON.parse(parentBody.toString("utf8"));
+                    parentNormalized = normalizeIssue(parentRaw);
+                }
+                catch {
+                    parentNormalized = null;
+                }
+            }
+            if (normalizedChild) {
+                const enrichedArtifact = {
+                    issue: normalizedChild,
+                    parent: parentNormalized,
+                    context: {
+                        scopeSource: normalizedChild.key,
+                        businessContextSource: parentNormalized?.key ?? normalizedChild.key,
+                    },
+                };
+                const parsedPath = path.parse(jiraTaskFile);
+                enrichedFile = path.join(parsedPath.dir, `${parsedPath.name}-enriched${parsedPath.ext}`);
+                await writeFile(enrichedFile, `${JSON.stringify(enrichedArtifact, null, 2)}\n`, "utf8");
+            }
+        }
+    }
+    catch {
+        // Non-JSON response or parse error - skip enrichment
+    }
     const attachments = parseJiraAttachments(body);
     const manifestItems = [];
     const planningContextChunks = [];
@@ -151,6 +254,7 @@ export async function fetchJiraIssue(jiraApiUrl, jiraTaskFile, attachmentsManife
         planningContextAttachments: manifest.summary.planningContextCount,
         ...(attachmentsManifestFile ? { attachmentsManifestFile } : {}),
         ...(attachmentsContextFile ? { attachmentsContextFile } : {}),
+        ...(enrichedFile ? { enrichedFile } : {}),
     };
 }
 export function requireJiraTaskFile(jiraTaskFile) {

package/dist/pipeline/auto-flow.js

@@ -1,9 +1,9 @@
 import { loadDeclarativeFlow } from "./declarative-flows.js";
-let cachedAutoFlow = null;
-export function loadAutoFlow() {
-    if (cachedAutoFlow) {
-        return cachedAutoFlow;
+let cachedAutoGolangFlow = null;
+export function loadAutoGolangFlow() {
+    if (cachedAutoGolangFlow) {
+        return cachedAutoGolangFlow;
     }
-    cachedAutoFlow = loadDeclarativeFlow({ source: "built-in", fileName: "auto.json" });
-    return cachedAutoFlow;
+    cachedAutoGolangFlow = loadDeclarativeFlow({ source: "built-in", fileName: "auto-golang.json" });
+    return cachedAutoGolangFlow;
 }

package/dist/pipeline/context.js

@@ -11,6 +11,7 @@ export function createPipelineContext(input) {
         ui: getOutputAdapter(),
         dryRun: input.dryRun,
         verbose: input.verbose,
+        mdLang: input.mdLang ?? null,
         runtime: input.runtime,
         executors: createExecutorRegistry(),
         nodes: createNodeRegistry(),

package/dist/pipeline/flow-catalog.js

@@ -1,12 +1,14 @@
 import path from "node:path";
 import { TaskRunnerError } from "../errors.js";
-import { loadAutoFlow } from "./auto-flow.js";
+import { loadAutoGolangFlow } from "./auto-flow.js";
 import { loadDeclarativeFlow } from "./declarative-flows.js";
 import { listBuiltInFlowSpecFiles, listProjectFlowSpecFiles, projectFlowSpecsDir } from "./spec-loader.js";
 export const BUILT_IN_COMMAND_FLOW_IDS = [
-    "auto",
+    "auto-golang",
+    "auto-common",
     "bug-analyze",
     "bug-fix",
+    "git-commit",
     "gitlab-diff-review",
     "gitlab-review",
     "mr-description",
@@ -15,13 +17,41 @@ export const BUILT_IN_COMMAND_FLOW_IDS = [
     "implement",
     "review",
     "review-fix",
+    "review-loop",
     "run-go-tests-loop",
     "run-go-linter-loop",
 ];
+const BUILT_IN_COMMAND_FLOW_FILES = {
+    "auto-golang": "auto-golang.json",
+    "auto-common": "auto-common.json",
+    "bug-analyze": "bugz/bug-analyze.json",
+    "bug-fix": "bugz/bug-fix.json",
+    "git-commit": "git-commit.json",
+    "gitlab-diff-review": "gitlab/gitlab-diff-review.json",
+    "gitlab-review": "gitlab/gitlab-review.json",
+    "mr-description": "gitlab/mr-description.json",
+    plan: "plan.json",
+    "task-describe": "task-describe.json",
+    implement: "implement.json",
+    review: "review/review.json",
+    "review-fix": "review/review-fix.json",
+    "review-loop": "review/review-loop.json",
+    "run-go-tests-loop": "go/run-go-tests-loop.json",
+    "run-go-linter-loop": "go/run-go-linter-loop.json",
+};
+function builtInCommandIdForFile(fileName) {
+    for (const [flowId, candidate] of Object.entries(BUILT_IN_COMMAND_FLOW_FILES)) {
+        if (candidate === fileName) {
+            return flowId;
+        }
+    }
+    return null;
+}
 function loadBuiltInCatalogEntry(fileName) {
+    const commandId = builtInCommandIdForFile(fileName);
     const relativePath = fileName.replace(/\.json$/i, "").split(/[\\/]+/).filter((segment) => segment.length > 0);
-    const id = relativePath.join("/");
-    const flow = id === "auto" ? loadAutoFlow() : loadDeclarativeFlow({ source: "built-in", fileName });
+    const id = commandId ?? relativePath.join("/");
+    const flow = id === "auto-golang" ? loadAutoGolangFlow() : loadDeclarativeFlow({ source: "built-in", fileName });
     return {
         id,
         source: "built-in",

package/dist/pipeline/flow-model-settings.js

@@ -0,0 +1,77 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { DEFAULT_MODEL_BY_EXECUTOR, defaultModelForExecutor } from "./launch-profile-config.js";
+import { scopeArtifactsDir } from "../artifacts.js";
+const FLOW_MODEL_SETTINGS_FILE = "agentweaver-flow-model-settings.json";
+function flowModelSettingsPath(scopeKey) {
+    return path.join(scopeArtifactsDir(scopeKey), FLOW_MODEL_SETTINGS_FILE);
+}
+function ensureArtifactsDir(scopeKey) {
+    const artifactsDir = scopeArtifactsDir(scopeKey);
+    if (!existsSync(artifactsDir)) {
+        mkdirSync(artifactsDir, { recursive: true });
+    }
+}
+export function loadFlowModelSettings(scopeKey) {
+    const filePath = flowModelSettingsPath(scopeKey);
+    if (!existsSync(filePath)) {
+        return {};
+    }
+    try {
+        const content = readFileSync(filePath, "utf8");
+        const parsed = JSON.parse(content);
+        if (typeof parsed !== "object" || parsed === null) {
+            return {};
+        }
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+export function saveFlowModelSettings(scopeKey, store) {
+    ensureArtifactsDir(scopeKey);
+    const filePath = flowModelSettingsPath(scopeKey);
+    const tempPath = `${filePath}.tmp`;
+    const content = JSON.stringify(store, null, 2);
+    writeFileSync(tempPath, content, "utf8");
+    renameSync(tempPath, filePath);
+}
+export function getEffectiveModelForFlow(flowId, scopeKey, executor) {
+    const store = loadFlowModelSettings(scopeKey);
+    const flowSettings = store[flowId];
+    if (!flowSettings) {
+        return defaultModelForExecutor(executor);
+    }
+    if (flowSettings.lastSelectedModel && flowSettings.lastSelectedModel !== "default") {
+        return flowSettings.lastSelectedModel;
+    }
+    if (flowSettings.defaultModel && flowSettings.defaultModel !== "default") {
+        return flowSettings.defaultModel;
+    }
+    return defaultModelForExecutor(executor);
+}
+export function updateLastSelectedModel(flowId, scopeKey, executor, model) {
+    const store = loadFlowModelSettings(scopeKey);
+    const existingSettings = store[flowId];
+    if (existingSettings) {
+        store[flowId] = {
+            ...existingSettings,
+            executor,
+            defaultModel: model,
+            lastSelectedModel: model,
+        };
+    }
+    else {
+        store[flowId] = {
+            executor,
+            defaultModel: DEFAULT_MODEL_BY_EXECUTOR[executor],
+            lastSelectedModel: model,
+        };
+    }
+    saveFlowModelSettings(scopeKey, store);
+}
+export function getFlowModelSettings(flowId, scopeKey) {
+    const store = loadFlowModelSettings(scopeKey);
+    return store[flowId] ?? null;
+}