agentweaver 0.1.0

package/dist/interactive-ui.js

@@ -0,0 +1,427 @@
+import blessed from "neo-blessed";
+import { renderMarkdownToTerminal } from "./markdown.js";
+import { setOutputAdapter, stripAnsi } from "./tui.js";
+export class InteractiveUi {
+    options;
+    screen;
+    header;
+    summary;
+    sidebar;
+    log;
+    input;
+    footer;
+    help;
+    history;
+    historyIndex;
+    busy = false;
+    currentCommand = "idle";
+    focusedPane = "input";
+    constructor(options, history) {
+        this.options = options;
+        this.history = history;
+        this.historyIndex = history.length;
+        this.screen = blessed.screen({
+            smartCSR: true,
+            fullUnicode: true,
+            title: `AgentWeaver ${options.issueKey}`,
+            dockBorders: true,
+            autoPadding: false,
+        });
+        this.header = blessed.box({
+            parent: this.screen,
+            top: 0,
+            left: 0,
+            width: "100%",
+            height: 3,
+            tags: true,
+            padding: {
+                left: 1,
+                right: 1,
+            },
+            border: "line",
+            style: {
+                border: { fg: "green" },
+                fg: "white",
+            },
+        });
+        this.sidebar = blessed.box({
+            parent: this.screen,
+            top: 3,
+            left: 0,
+            width: "28%",
+            height: "100%-7",
+            tags: true,
+            label: " Commands ",
+            padding: {
+                left: 1,
+                right: 1,
+            },
+            border: "line",
+            scrollable: true,
+            alwaysScroll: true,
+            keys: true,
+            vi: true,
+            style: {
+                border: { fg: "cyan" },
+                fg: "white",
+            },
+        });
+        this.summary = blessed.box({
+            parent: this.screen,
+            top: 3,
+            left: "28%",
+            width: "72%",
+            height: 9,
+            tags: true,
+            label: " Task Summary ",
+            padding: {
+                left: 1,
+                right: 1,
+            },
+            border: "line",
+            scrollable: true,
+            alwaysScroll: true,
+            keys: true,
+            vi: true,
+            style: {
+                border: { fg: "green" },
+                fg: "white",
+            },
+        });
+        this.log = blessed.log({
+            parent: this.screen,
+            top: 12,
+            left: "28%",
+            width: "72%",
+            height: "100%-16",
+            tags: false,
+            label: " Activity ",
+            padding: {
+                left: 1,
+                right: 1,
+            },
+            border: "line",
+            scrollable: true,
+            alwaysScroll: true,
+            keys: true,
+            vi: true,
+            mouse: true,
+            scrollbar: {
+                ch: " ",
+                inverse: true,
+            },
+            style: {
+                border: { fg: "yellow" },
+                fg: "white",
+            },
+        });
+        this.input = blessed.textbox({
+            parent: this.screen,
+            bottom: 1,
+            left: 0,
+            width: "100%",
+            height: 3,
+            keys: true,
+            inputOnFocus: true,
+            mouse: true,
+            label: " command ",
+            padding: {
+                left: 1,
+            },
+            border: "line",
+            style: {
+                border: { fg: "magenta" },
+                fg: "white",
+                focus: {
+                    border: { fg: "magenta" },
+                },
+            },
+        });
+        this.footer = blessed.box({
+            parent: this.screen,
+            bottom: 0,
+            left: 0,
+            width: "100%",
+            height: 1,
+            tags: true,
+            style: { fg: "gray" },
+        });
+        this.help = blessed.box({
+            parent: this.screen,
+            top: "center",
+            left: "center",
+            width: "70%",
+            height: "65%",
+            hidden: true,
+            tags: true,
+            label: " Help ",
+            padding: {
+                left: 1,
+                right: 1,
+            },
+            border: "line",
+            scrollable: true,
+            keys: true,
+            vi: true,
+            mouse: true,
+            style: {
+                border: { fg: "magenta" },
+                bg: "black",
+                fg: "white",
+            },
+        });
+        this.bindKeys();
+        this.renderStaticContent();
+    }
+    bindKeys() {
+        this.screen.key(["C-c", "q"], () => {
+            this.options.onExit();
+        });
+        this.screen.key(["f1", "?"], () => {
+            this.help.hidden = !this.help.hidden;
+            if (!this.help.hidden) {
+                this.help.focus();
+            }
+            else {
+                this.input.focus();
+            }
+            this.screen.render();
+        });
+        this.screen.key(["escape"], () => {
+            this.help.hide();
+            this.focusPane("input");
+            this.screen.render();
+        });
+        this.screen.key(["C-l"], () => {
+            this.log.setContent("");
+            this.appendLog("Log cleared.");
+        });
+        this.screen.key(["S-tab"], () => {
+            this.cycleFocus(-1);
+        });
+        this.screen.key(["tab"], () => {
+            if (this.focusedPane !== "input") {
+                this.cycleFocus(1);
+            }
+        });
+        this.screen.key(["C-j"], () => {
+            this.focusPane("log");
+        });
+        this.screen.key(["C-k"], () => {
+            this.focusPane("input");
+        });
+        this.log.key(["up"], () => {
+            this.log.scroll(-1);
+            this.screen.render();
+        });
+        this.log.key(["down"], () => {
+            this.log.scroll(1);
+            this.screen.render();
+        });
+        this.log.key(["pageup"], () => {
+            this.log.scroll(-(this.log.height - 2));
+            this.screen.render();
+        });
+        this.log.key(["pagedown"], () => {
+            this.log.scroll(this.log.height - 2);
+            this.screen.render();
+        });
+        this.log.key(["home"], () => {
+            this.log.setScroll(0);
+            this.screen.render();
+        });
+        this.log.key(["end"], () => {
+            this.log.setScrollPerc(100);
+            this.screen.render();
+        });
+        this.summary.key(["pageup"], () => {
+            this.summary.scroll(-(this.summary.height - 2));
+            this.screen.render();
+        });
+        this.summary.key(["pagedown"], () => {
+            this.summary.scroll(this.summary.height - 2);
+            this.screen.render();
+        });
+        this.sidebar.key(["pageup"], () => {
+            this.sidebar.scroll(-(this.sidebar.height - 2));
+            this.screen.render();
+        });
+        this.sidebar.key(["pagedown"], () => {
+            this.sidebar.scroll(this.sidebar.height - 2);
+            this.screen.render();
+        });
+        this.input.key(["up"], () => {
+            if (this.history.length === 0) {
+                return;
+            }
+            this.historyIndex = Math.max(0, this.historyIndex - 1);
+            this.input.setValue(this.history[this.historyIndex] ?? "");
+            this.screen.render();
+        });
+        this.input.key(["down"], () => {
+            if (this.history.length === 0) {
+                return;
+            }
+            this.historyIndex = Math.min(this.history.length, this.historyIndex + 1);
+            this.input.setValue(this.history[this.historyIndex] ?? "");
+            this.screen.render();
+        });
+        this.input.key(["tab"], () => {
+            const current = String(this.input.getValue() ?? "");
+            const hit = this.options.commands.find((item) => item.startsWith(current.trim()));
+            if (hit) {
+                this.input.setValue(hit);
+                this.screen.render();
+            }
+        });
+        this.input.key(["C-j"], () => {
+            this.focusPane("log");
+        });
+        this.input.key(["C-u"], () => {
+            this.focusPane("summary");
+        });
+        this.input.key(["C-h"], () => {
+            this.focusPane("sidebar");
+        });
+        this.input.key(["S-tab"], () => {
+            this.cycleFocus(-1);
+        });
+        this.log.key(["tab"], () => {
+            this.cycleFocus(1);
+        });
+        this.log.key(["S-tab"], () => {
+            this.cycleFocus(-1);
+        });
+        this.summary.key(["tab"], () => {
+            this.cycleFocus(1);
+        });
+        this.summary.key(["S-tab"], () => {
+            this.cycleFocus(-1);
+        });
+        this.sidebar.key(["tab"], () => {
+            this.cycleFocus(1);
+        });
+        this.sidebar.key(["S-tab"], () => {
+            this.cycleFocus(-1);
+        });
+        this.input.on("submit", async (value) => {
+            const line = value.trim();
+            this.input.clearValue();
+            this.screen.render();
+            if (!line || this.busy) {
+                return;
+            }
+            this.history.push(line);
+            this.historyIndex = this.history.length;
+            this.appendLog(`> ${line}`);
+            await this.options.onSubmit(line);
+            this.focusPane("input");
+        });
+    }
+    cycleFocus(direction) {
+        const panes = ["input", "log", "summary", "sidebar"];
+        const currentIndex = panes.indexOf(this.focusedPane);
+        const nextIndex = (currentIndex + direction + panes.length) % panes.length;
+        this.focusPane(panes[nextIndex] ?? "input");
+    }
+    focusPane(pane) {
+        this.focusedPane = pane;
+        this.header.style.border.fg = "green";
+        this.log.style.border.fg = pane === "log" ? "brightYellow" : "yellow";
+        this.summary.style.border.fg = pane === "summary" ? "brightGreen" : "green";
+        this.sidebar.style.border.fg = pane === "sidebar" ? "brightCyan" : "cyan";
+        this.input.style.border.fg = pane === "input" ? "brightMagenta" : "magenta";
+        if (pane === "input") {
+            this.input.focus();
+        }
+        else if (pane === "log") {
+            this.log.focus();
+        }
+        else if (pane === "summary") {
+            this.summary.focus();
+        }
+        else {
+            this.sidebar.focus();
+        }
+        this.footer.setContent(` Focus: ${pane} | Enter: run command | Tab/Shift+Tab: switch pane | Ctrl+J: log | Ctrl+K: input | PgUp/PgDn: scroll | ?: help | q: exit `);
+        this.screen.render();
+    }
+    renderStaticContent() {
+        this.header.setContent(`{bold}AgentWeaver{/bold}  {green-fg}${this.options.issueKey}{/green-fg}\n` +
+            `cwd: ${this.options.cwd}   current: ${this.currentCommand}`);
+        const summaryBody = this.options.summaryText.trim()
+            ? this.options.summaryText.trim()
+            : "Using existing Jira task file.\n\nUse /help to see commands.";
+        this.summary.setContent(renderMarkdownToTerminal(stripAnsi(summaryBody)));
+        this.sidebar.setContent([
+            this.options.commands.join("\n"),
+            "",
+            "Keys:",
+            "? / F1      help",
+            "Ctrl+L      clear log",
+            "Tab         complete",
+            "q / Ctrl+C  exit",
+        ].join("\n"));
+        this.help.setContent(renderMarkdownToTerminal([
+            "AgentWeaver interactive mode",
+            "",
+            "Use slash commands in the input box:",
+            this.options.commands.join("\n"),
+            "",
+            "Keys:",
+            "Tab           autocomplete command",
+            "Up/Down       history",
+            "Ctrl+L        clear log",
+            "? or F1       toggle help",
+            "Esc           close help",
+            "q / Ctrl+C    exit",
+        ].join("\n")));
+        this.footer.setContent(" Enter: run command | Tab: complete | Up/Down: history | ?: help | Ctrl+L: clear log | q: exit ");
+    }
+    createAdapter() {
+        return {
+            writeStdout: (text) => {
+                this.appendLog(stripAnsi(text).replace(/\r/g, ""));
+            },
+            writeStderr: (text) => {
+                this.appendLog(stripAnsi(text).replace(/\r/g, ""));
+            },
+            supportsTransientStatus: false,
+            supportsPassthrough: false,
+        };
+    }
+    mount() {
+        setOutputAdapter(this.createAdapter());
+        this.focusPane("input");
+    }
+    destroy() {
+        setOutputAdapter(null);
+        this.screen.destroy();
+    }
+    setBusy(busy, command) {
+        this.busy = busy;
+        this.currentCommand = command ?? (busy ? this.currentCommand : "idle");
+        this.header.setContent(`{bold}AgentWeaver{/bold}  {green-fg}${this.options.issueKey}{/green-fg}\n` +
+            `cwd: ${this.options.cwd}\n` +
+            `current: ${this.currentCommand}${busy ? " {yellow-fg}[running]{/yellow-fg}" : ""}`);
+        this.input.setLabel(busy ? " command [busy] " : " command ");
+        this.screen.render();
+    }
+    appendLog(text) {
+        const normalized = text
+            .split("\n")
+            .map((line) => line.replace(/\t/g, "  "))
+            .join("\n")
+            .trimEnd();
+        if (!normalized) {
+            this.log.add("");
+        }
+        else {
+            for (const line of normalized.split("\n")) {
+                this.log.add(line);
+            }
+        }
+        this.log.setScrollPerc(100);
+        this.screen.render();
+    }
+}

package/dist/jira.js

@@ -0,0 +1,56 @@
+import { existsSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { TaskRunnerError } from "./errors.js";
+const ISSUE_KEY_RE = /^[A-Z][A-Z0-9_]*-[0-9]+$/;
+export function extractIssueKey(jiraRef) {
+    const normalizedRef = jiraRef.replace(/\/+$/, "");
+    if (normalizedRef.includes("://")) {
+        const issueKey = normalizedRef.split("/").pop() ?? "";
+        if (!normalizedRef.includes("/browse/") || !issueKey) {
+            throw new TaskRunnerError("Expected Jira browse URL like https://jira.example.ru/browse/DEMO-3288");
+        }
+        return issueKey;
+    }
+    if (!ISSUE_KEY_RE.test(normalizedRef)) {
+        throw new TaskRunnerError("Expected Jira issue key like DEMO-3288 or browse URL like https://jira.example.ru/browse/DEMO-3288");
+    }
+    return normalizedRef;
+}
+export function buildJiraBrowseUrl(jiraRef) {
+    if (jiraRef.includes("://")) {
+        return jiraRef.replace(/\/+$/, "");
+    }
+    const baseUrl = process.env.JIRA_BASE_URL?.replace(/\/+$/, "") ?? "";
+    if (!baseUrl) {
+        throw new TaskRunnerError("JIRA_BASE_URL is required when passing only a Jira issue key.");
+    }
+    return `${baseUrl}/browse/${extractIssueKey(jiraRef)}`;
+}
+export function buildJiraApiUrl(jiraRef) {
+    const browseUrl = buildJiraBrowseUrl(jiraRef);
+    const issueKey = extractIssueKey(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.");
+    }
+    const response = await fetch(jiraApiUrl, {
+        headers: {
+            Authorization: `Bearer ${jiraApiKey}`,
+            Accept: "application/json",
+        },
+    });
+    if (!response.ok) {
+        throw new TaskRunnerError(`Failed to fetch Jira issue: HTTP ${response.status}`);
+    }
+    const body = Buffer.from(await response.arrayBuffer());
+    await writeFile(jiraTaskFile, body);
+}
+export function requireJiraTaskFile(jiraTaskFile) {
+    if (!existsSync(jiraTaskFile)) {
+        throw new TaskRunnerError(`Jira issue JSON not found: ${jiraTaskFile}\nRun plan mode first to download the Jira task.`);
+    }
+}

package/dist/markdown.js

@@ -0,0 +1,183 @@
+import MarkdownIt from "markdown-it";
+const md = new MarkdownIt({
+    html: false,
+    linkify: true,
+    typographer: false,
+});
+function wrapText(text, width = 88, indent = "") {
+    const words = text.trim().split(/\s+/).filter(Boolean);
+    if (words.length === 0) {
+        return [indent];
+    }
+    const lines = [];
+    let current = indent;
+    for (const word of words) {
+        const candidate = current.trim() ? `${current} ${word}` : `${indent}${word}`;
+        if (candidate.length > width && current.trim()) {
+            lines.push(current);
+            current = `${indent}${word}`;
+        }
+        else {
+            current = candidate;
+        }
+    }
+    if (current) {
+        lines.push(current);
+    }
+    return lines;
+}
+function renderInline(tokens) {
+    if (!tokens) {
+        return "";
+    }
+    let result = "";
+    let linkHref = "";
+    for (const token of tokens) {
+        switch (token.type) {
+            case "text":
+                result += token.content;
+                break;
+            case "code_inline":
+                result += `\`${token.content}\``;
+                break;
+            case "softbreak":
+            case "hardbreak":
+                result += "\n";
+                break;
+            case "strong_open":
+            case "strong_close":
+                result += "*";
+                break;
+            case "em_open":
+            case "em_close":
+                result += "_";
+                break;
+            case "link_open":
+                linkHref = token.attrGet("href") ?? "";
+                break;
+            case "link_close":
+                if (linkHref) {
+                    result += ` (${linkHref})`;
+                    linkHref = "";
+                }
+                break;
+            case "image":
+                result += `[image: ${token.content || token.attrGet("src") || ""}]`;
+                break;
+            default:
+                if (token.content) {
+                    result += token.content;
+                }
+                break;
+        }
+    }
+    return result;
+}
+export function renderMarkdownToTerminal(markdown, width = 88) {
+    const tokens = md.parse(markdown, {});
+    const lines = [];
+    let bulletDepth = 0;
+    let orderedDepth = 0;
+    let orderedIndex = 1;
+    let inBlockQuote = false;
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        const previousType = tokens[index - 1]?.type ?? "";
+        const previousPreviousType = tokens[index - 2]?.type ?? "";
+        switch (token.type) {
+            case "heading_open": {
+                const inlineToken = tokens[index + 1];
+                const level = Number.parseInt(token.tag.replace("h", ""), 10);
+                const text = renderInline(inlineToken?.children).trim();
+                if (lines.length > 0) {
+                    lines.push("");
+                }
+                const prefix = "#".repeat(Number.isNaN(level) ? 1 : level);
+                lines.push(`${prefix} ${text}`);
+                lines.push("");
+                break;
+            }
+            case "paragraph_open":
+                break;
+            case "inline": {
+                const isListItemInline = previousType === "list_item_open" ||
+                    (previousType === "paragraph_open" && previousPreviousType === "list_item_open");
+                if (isListItemInline) {
+                    const baseIndent = "  ".repeat(Math.max(bulletDepth, orderedDepth) - 1);
+                    const prefix = bulletDepth > 0 ? "• " : `${orderedIndex}. `;
+                    const contentLines = wrapText(renderInline(token.children).trim(), width, `${baseIndent}${prefix}`);
+                    lines.push(...contentLines);
+                    if (orderedDepth > 0) {
+                        orderedIndex += 1;
+                    }
+                    break;
+                }
+                const next = tokens[index + 1]?.type ?? "";
+                if (previousType === "heading_open" || previousType === "bullet_list_open" || previousType === "ordered_list_open") {
+                    break;
+                }
+                const text = renderInline(token.children).trim();
+                if (!text) {
+                    break;
+                }
+                const indent = inBlockQuote ? "> " : "";
+                lines.push(...wrapText(text, width, indent));
+                if (next === "paragraph_close") {
+                    lines.push("");
+                }
+                break;
+            }
+            case "bullet_list_open":
+                bulletDepth += 1;
+                break;
+            case "bullet_list_close":
+                bulletDepth = Math.max(0, bulletDepth - 1);
+                lines.push("");
+                break;
+            case "ordered_list_open":
+                orderedDepth += 1;
+                orderedIndex = Number.parseInt(token.attrGet("start") ?? "1", 10) || 1;
+                break;
+            case "ordered_list_close":
+                orderedDepth = Math.max(0, orderedDepth - 1);
+                orderedIndex = 1;
+                lines.push("");
+                break;
+            case "list_item_open":
+                break;
+            case "list_item_close":
+                break;
+            case "blockquote_open":
+                inBlockQuote = true;
+                break;
+            case "blockquote_close":
+                inBlockQuote = false;
+                lines.push("");
+                break;
+            case "fence":
+            case "code_block": {
+                if (lines.length > 0 && lines[lines.length - 1] !== "") {
+                    lines.push("");
+                }
+                const language = token.info?.trim();
+                lines.push(language ? `\`\`\` ${language}` : "```");
+                lines.push(...token.content.replace(/\n$/, "").split("\n"));
+                lines.push("```");
+                lines.push("");
+                break;
+            }
+            case "hr":
+                lines.push("─".repeat(Math.min(width, 40)));
+                lines.push("");
+                break;
+            case "paragraph_close":
+                break;
+            default:
+                break;
+        }
+    }
+    while (lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    return lines.join("\n").replace(/\n{3,}/g, "\n\n");
+}