agentweaver 0.1.10 → 0.1.11

package/dist/interactive-ui.js

@@ -142,6 +142,7 @@ export class InteractiveUi {
     scopeKey;
     jiraIssueKey;
     summaryVisible;
+    version;
     constructor(options) {
         this.options = options;
         if (options.flows.length === 0) {
@@ -149,12 +150,13 @@ export class InteractiveUi {
         }
         this.flowMap = new Map(options.flows.map((flow) => [flow.id, flow]));
         this.flowTree = buildFlowTree(options.flows);
-        this.selectedFlowId = options.flows[0]?.id ?? "auto";
+        this.selectedFlowId = options.flows[0]?.id ?? "auto-golang";
         this.visibleFlowItems = this.computeVisibleFlowItems();
         this.selectedFlowItemKey = this.visibleFlowItems[0]?.key ?? makeFlowKey(this.selectedFlowId);
         this.scopeKey = options.scopeKey;
         this.jiraIssueKey = options.jiraIssueKey ?? null;
         this.summaryVisible = options.summaryText.trim().length > 0;
+        this.version = options.version ?? "";
         this.screen = blessed.screen({
             smartCSR: true,
             fullUnicode: true,
@@ -721,10 +723,12 @@ export class InteractiveUi {
         const branchLabel = this.options.gitBranchName ? this.options.gitBranchName : "detached-head";
         const flowLabel = `${current}${this.busy ? " {yellow-fg}[running]{/yellow-fg}" : ""}`;
         const divider = " {gray-fg}│{/gray-fg} ";
+        const versionLabel = this.version ? `${divider}{bold}Version{/bold} {white-fg}${this.version}{/white-fg}` : "";
         this.header.setContent([
             "{bold}AgentWeaver{/bold}",
             divider,
             `{bold}Scope{/bold} {green-fg}${this.scopeKey}{/green-fg}`,
+            versionLabel,
             this.jiraIssueKey ? `${divider}{bold}Jira{/bold} {yellow-fg}${this.jiraIssueKey}{/yellow-fg}` : "",
             divider,
             `{bold}Flow{/bold} ${flowLabel}`,
@@ -745,19 +749,117 @@ export class InteractiveUi {
         }
         return this.activeFormSession.form.fields[this.activeFormSession.currentFieldIndex] ?? null;
     }
-    renderTextInputValue(value, placeholder) {
-        const rawText = value || placeholder || "Введите текст";
-        const frameWidth = Math.max(36, rawText.length + 6);
+    renderTextInputValue(value, placeholder, rows = 1) {
+        const rawLines = (value || placeholder || "Введите текст").split("\n");
+        const visibleLines = rawLines.slice(0, Math.max(1, rows));
+        const contentWidth = visibleLines.reduce((max, line) => Math.max(max, line.length), 0);
+        const frameWidth = Math.max(36, contentWidth + 6);
         const innerWidth = Math.max(32, frameWidth - 4);
-        const visibleText = rawText.length > innerWidth - 2 ? `${rawText.slice(0, innerWidth - 5)}...` : rawText;
-        const padded = value
-            ? `{white-fg}${visibleText.padEnd(innerWidth - 2, " ")}{/white-fg}`
-            : `{gray-fg}${visibleText.padEnd(innerWidth - 2, " ")}{/gray-fg}`;
-        return [
-            `{cyan-fg}┌${"─".repeat(frameWidth - 2)}┐{/cyan-fg}`,
-            `{cyan-fg}│{/cyan-fg}{black-bg} {green-fg}>{/green-fg} ${padded} {/black-bg}{cyan-fg}│{/cyan-fg}`,
-            `{cyan-fg}└${"─".repeat(frameWidth - 2)}┘{/cyan-fg}`,
-        ];
+        const renderedRows = Array.from({ length: Math.max(1, rows) }, (_, index) => {
+            const rawLine = visibleLines[index] ?? "";
+            const visibleText = rawLine.length > innerWidth - 2 ? `${rawLine.slice(0, innerWidth - 5)}...` : rawLine;
+            const color = value ? "white-fg" : "gray-fg";
+            return `{cyan-fg}│{/cyan-fg}{black-bg} ${index === 0 ? "{green-fg}>{/green-fg}" : " "} {${color}}${visibleText.padEnd(innerWidth - 2, " ")}{/${color}} {/black-bg}{cyan-fg}│{/cyan-fg}`;
+        });
+        return [`{cyan-fg}┌${"─".repeat(frameWidth - 2)}┐{/cyan-fg}`, ...renderedRows, `{cyan-fg}└${"─".repeat(frameWidth - 2)}┘{/cyan-fg}`];
+    }
+    formModalInnerHeight() {
+        const rawHeight = typeof this.formModal.height === "number" ? this.formModal.height : this.formModal?.lpos?.yi
+            ? this.formModal.lpos.yl - this.formModal.lpos.yi + 1
+            : 0;
+        const paddingTop = Number(this.formModal.padding?.top ?? 0);
+        const paddingBottom = Number(this.formModal.padding?.bottom ?? 0);
+        return Math.max(6, rawHeight - 2 - paddingTop - paddingBottom);
+    }
+    formModalInnerWidth() {
+        const rawWidth = typeof this.formModal.width === "number" ? this.formModal.width : this.formModal?.lpos?.xi
+            ? this.formModal.lpos.xl - this.formModal.lpos.xi + 1
+            : 0;
+        const paddingLeft = Number(this.formModal.padding?.left ?? 0);
+        const paddingRight = Number(this.formModal.padding?.right ?? 0);
+        return Math.max(24, rawWidth - 2 - paddingLeft - paddingRight);
+    }
+    wrapFormText(text, width) {
+        const normalized = text.trim();
+        if (!normalized) {
+            return [""];
+        }
+        const wrapped = [];
+        for (const paragraph of normalized.split("\n")) {
+            if (!paragraph.trim()) {
+                wrapped.push("");
+                continue;
+            }
+            let remaining = paragraph.trim();
+            while (remaining.length > width) {
+                let splitAt = remaining.lastIndexOf(" ", width);
+                if (splitAt <= 0) {
+                    splitAt = width;
+                }
+                wrapped.push(remaining.slice(0, splitAt).trimEnd());
+                remaining = remaining.slice(splitAt).trimStart();
+            }
+            wrapped.push(remaining);
+        }
+        return wrapped.length > 0 ? wrapped : [""];
+    }
+    renderSelectableFieldWindow(field, value, currentOptionIndex, availableLines) {
+        const contentWidth = this.formModalInnerWidth();
+        const firstLineWidth = Math.max(12, contentWidth - 6);
+        const continuationWidth = Math.max(8, contentWidth - 6);
+        const descriptionWidth = Math.max(8, contentWidth - 4);
+        const renderedOptions = field.options.map((option, index) => {
+            const isCursor = index === currentOptionIndex;
+            const isSelected = field.type === "single-select"
+                ? value === option.value
+                : Array.isArray(value) && value.includes(option.value);
+            const cursor = isCursor ? "{cyan-fg}>{/cyan-fg}" : " ";
+            const marker = isSelected ? "[x]" : "[ ]";
+            const labelLines = this.wrapFormText(option.label, firstLineWidth);
+            const itemLines = [`${cursor} ${marker} ${labelLines[0] ?? ""}`];
+            for (const continuation of labelLines.slice(1)) {
+                itemLines.push(`      ${continuation.slice(0, continuationWidth)}`);
+            }
+            if (option.description?.trim()) {
+                for (const descriptionLine of this.wrapFormText(option.description, descriptionWidth)) {
+                    itemLines.push(`    {gray-fg}${descriptionLine}{/gray-fg}`);
+                }
+            }
+            return itemLines;
+        });
+        if (renderedOptions.length === 0) {
+            return ["{gray-fg}Нет доступных вариантов.{/gray-fg}"];
+        }
+        let startIndex = 0;
+        let selectedStartLine = 0;
+        for (let index = 0; index < currentOptionIndex; index += 1) {
+            selectedStartLine += renderedOptions[index]?.length ?? 0;
+        }
+        let visibleLines = 0;
+        for (let index = 0; index < renderedOptions.length; index += 1) {
+            const itemHeight = renderedOptions[index]?.length ?? 0;
+            if (index < currentOptionIndex && selectedStartLine + itemHeight > availableLines) {
+                startIndex = index + 1;
+                selectedStartLine -= itemHeight;
+            }
+        }
+        const output = [];
+        for (let index = startIndex; index < renderedOptions.length; index += 1) {
+            const itemLines = renderedOptions[index] ?? [];
+            if (output.length > 0 && output.length + itemLines.length > availableLines) {
+                break;
+            }
+            if (output.length === 0 && itemLines.length > availableLines) {
+                output.push(...itemLines.slice(0, availableLines));
+                break;
+            }
+            output.push(...itemLines);
+            visibleLines += itemLines.length;
+            if (visibleLines >= availableLines) {
+                break;
+            }
+        }
+        return output;
     }
     renderActiveForm() {
         if (!this.activeFormSession) {
@@ -771,18 +873,20 @@ export class InteractiveUi {
         if (!field) {
             return;
         }
-        const lines = [`{bold}${session.form.title}{/bold}`];
+        const headerLines = [`{bold}${session.form.title}{/bold}`];
         if (session.form.description?.trim()) {
-            lines.push("");
-            lines.push(session.form.description.trim());
+            headerLines.push("");
+            headerLines.push(session.form.description.trim());
         }
-        lines.push("");
-        lines.push(`Field ${session.currentFieldIndex + 1}/${session.form.fields.length}`);
-        lines.push(`{yellow-fg}${field.label}{/yellow-fg}`);
+        headerLines.push("");
+        headerLines.push(`Field ${session.currentFieldIndex + 1}/${session.form.fields.length}`);
+        headerLines.push(`{yellow-fg}${field.label}{/yellow-fg}`);
         if (field.help?.trim()) {
-            lines.push(field.help.trim());
+            headerLines.push(field.help.trim());
         }
-        lines.push("");
+        headerLines.push("");
+        const footerLines = ["", "{green-fg}Ctrl+S{/green-fg}: submit", "{magenta-fg}Shift+Tab{/magenta-fg}: previous field", "{red-fg}Esc{/red-fg}: cancel"];
+        const lines = [...headerLines];
         if (field.type === "boolean") {
             const current = session.values[field.id] === true;
             lines.push(`${current ? "[x]" : "[ ]"} ${field.label}`);
@@ -792,37 +896,24 @@ export class InteractiveUi {
         }
         else if (field.type === "text") {
             const current = String(session.values[field.id] ?? "");
-            lines.push(...this.renderTextInputValue(current, field.placeholder));
+            lines.push(...this.renderTextInputValue(current, field.placeholder, field.multiline ? Math.max(1, field.rows ?? 3) : 1));
             lines.push("");
-            lines.push("Type text, Backspace: delete");
-            lines.push("Enter/Tab: next field");
+            lines.push(field.multiline ? "Type text, Enter: new line, Backspace: delete" : "Type text, Backspace: delete");
+            lines.push("Tab: next field");
         }
         else {
             const currentOptionIndex = Math.min(session.currentOptionIndex, Math.max(0, field.options.length - 1));
             session.currentOptionIndex = currentOptionIndex;
-            field.options.forEach((option, index) => {
-                const isCursor = index === currentOptionIndex;
-                const value = session.values[field.id];
-                const isSelected = field.type === "single-select"
-                    ? value === option.value
-                    : Array.isArray(value) && value.includes(option.value);
-                const cursor = isCursor ? "{cyan-fg}>{/cyan-fg}" : " ";
-                const marker = isSelected ? "[x]" : "[ ]";
-                lines.push(`${cursor} ${marker} ${option.label}`);
-                if (option.description?.trim()) {
-                    lines.push(`    {gray-fg}${option.description.trim()}{/gray-fg}`);
-                }
-            });
+            const availableLines = Math.max(3, this.formModalInnerHeight() - headerLines.length - footerLines.length - 3);
+            lines.push(...this.renderSelectableFieldWindow(field, session.values[field.id], currentOptionIndex, availableLines));
             lines.push("");
             lines.push("Up/Down: move");
             lines.push("Space: select/toggle");
             lines.push("Enter/Tab: next field");
         }
-        lines.push("");
-        lines.push("{green-fg}Ctrl+S{/green-fg}: submit");
-        lines.push("{magenta-fg}Shift+Tab{/magenta-fg}: previous field");
-        lines.push("{red-fg}Esc{/red-fg}: cancel");
+        lines.push(...footerLines);
         this.formModal.setContent(lines.join("\n"));
+        this.formModal.setScroll(0);
         this.formModal.show();
         this.formModal.setFront();
         this.formModal.focus();
@@ -880,7 +971,7 @@ export class InteractiveUi {
             this.renderActiveForm();
         }
     }
-    appendActiveFormText(ch, key) {
+    appendActiveFormText(ch, key, appendNewline = false) {
         const session = this.activeFormSession;
         const field = this.currentFormField();
         if (!session || !field || field.type !== "text") {
@@ -892,6 +983,11 @@ export class InteractiveUi {
             this.renderActiveForm();
             return;
         }
+        if (appendNewline) {
+            session.values[field.id] = `${current}\n`;
+            this.renderActiveForm();
+            return;
+        }
         if (key.ctrl || key.meta || !ch || ch === "\r" || ch === "\n" || ch === "\t") {
             return;
         }
@@ -966,7 +1062,12 @@ export class InteractiveUi {
         }
         if (field.type === "text") {
             if (key.name === "enter") {
-                this.moveActiveFormField(1);
+                if (field.multiline) {
+                    this.appendActiveFormText(ch, key, true);
+                }
+                else {
+                    this.moveActiveFormField(1);
+                }
                 return;
             }
             this.appendActiveFormText(ch, key);

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/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;
+}