agentweaver 0.1.9 → 0.1.11

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,
         },
     });

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/declarative-flows.js

@@ -39,18 +39,21 @@ export function loadDeclarativeFlow(flow) {
 }
 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) {
+    const builtInMatches = listBuiltInFlowSpecFiles().filter((candidate) => path.basename(candidate) === fileName);
+    if (projectMatches.length > 0 && builtInMatches.length > 0) {
         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 (builtInMatches.length > 1) {
+        throw new Error(`Ambiguous built-in flow '${fileName}'. Use unique nested flow file names.`);
+    }
     if (projectMatches[0]) {
         return { source: "project-local", filePath: projectMatches[0] };
     }
-    if (builtInExists) {
-        return { source: "built-in", fileName };
+    if (builtInMatches[0]) {
+        return { source: "built-in", fileName: builtInMatches[0] };
     }
     throw new Error(`Nested flow '${fileName}' was not found.`);
 }

package/dist/pipeline/flow-catalog.js

@@ -1,47 +1,84 @@
 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 { 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" },
+import { listBuiltInFlowSpecFiles, listProjectFlowSpecFiles, projectFlowSpecsDir } from "./spec-loader.js";
+export const BUILT_IN_COMMAND_FLOW_IDS = [
+    "auto-golang",
+    "auto-common",
+    "bug-analyze",
+    "bug-fix",
+    "git-commit",
+    "gitlab-diff-review",
+    "gitlab-review",
+    "mr-description",
+    "plan",
+    "task-describe",
+    "implement",
+    "review",
+    "review-fix",
+    "review-loop",
+    "run-go-tests-loop",
+    "run-go-linter-loop",
 ];
-function loadBuiltInCatalogEntry(id, fileName) {
-    const flow = id === "auto" ? loadAutoFlow() : loadDeclarativeFlow({ source: "built-in", fileName });
+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 = commandId ?? relativePath.join("/");
+    const flow = id === "auto-golang" ? loadAutoGolangFlow() : loadDeclarativeFlow({ source: "built-in", fileName });
     return {
         id,
         source: "built-in",
         fileName,
         absolutePath: flow.absolutePath,
+        treePath: ["default", ...relativePath],
         flow,
     };
 }
-function loadProjectCatalogEntry(filePath) {
+function loadProjectCatalogEntry(cwd, filePath) {
     const flow = loadDeclarativeFlow({ source: "project-local", filePath });
+    const relativeFilePath = path.relative(projectFlowSpecsDir(cwd), path.resolve(filePath));
+    const relativePathWithoutExt = relativeFilePath.replace(/\.json$/i, "");
+    const relativeSegments = relativePathWithoutExt.split(path.sep).filter((segment) => segment.length > 0);
     return {
-        id: path.basename(filePath, path.extname(filePath)),
+        id: relativeSegments.join("/"),
         source: "project-local",
         fileName: path.basename(filePath),
         absolutePath: path.resolve(filePath),
+        treePath: ["custom", ...relativeSegments],
         flow,
     };
 }
 export function loadInteractiveFlowCatalog(cwd) {
-    const entries = INTERACTIVE_BUILT_IN_FLOWS.map((entry) => loadBuiltInCatalogEntry(entry.id, entry.fileName));
+    const entries = listBuiltInFlowSpecFiles().map((fileName) => loadBuiltInCatalogEntry(fileName));
     for (const filePath of listProjectFlowSpecFiles(cwd)) {
-        entries.push(loadProjectCatalogEntry(filePath));
+        entries.push(loadProjectCatalogEntry(cwd, filePath));
     }
     const byId = new Map();
     for (const entry of entries) {
@@ -57,7 +94,7 @@ 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);
+    return BUILT_IN_COMMAND_FLOW_IDS.includes(flowId);
 }
 export function toDeclarativeFlowRef(entry) {
     return entry.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;
+}