agentweaver 0.1.14 → 0.1.16

package/dist/interactive/create-interactive-session.js

@@ -0,0 +1,5 @@
+import { createInkInteractiveSession, describeInkInteractiveSessionAvailability } from "./ink/index.js";
+export function createInteractiveSession(options) {
+    return createInkInteractiveSession(options);
+}
+export { describeInkInteractiveSessionAvailability };

package/dist/interactive/ink/index.js

@@ -0,0 +1,576 @@
+import { createRequire } from "node:module";
+import process from "node:process";
+import { TaskRunnerError } from "../../errors.js";
+import { InteractiveSessionController } from "../controller.js";
+const require = createRequire(import.meta.url);
+function hasRuntimeModule(moduleName) {
+    try {
+        require.resolve(moduleName);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function clampScrollOffset(value, maxOffset) {
+    return Math.min(Math.max(0, value), maxOffset);
+}
+function buildSolidFill(width, height) {
+    const safeWidth = Math.max(1, width);
+    const safeHeight = Math.max(1, height);
+    const line = " ".repeat(safeWidth);
+    return Array.from({ length: safeHeight }, () => line).join("\n");
+}
+function parseActionSegments(line) {
+    const matches = line.match(/\[[^\]]+\]/g);
+    if (!matches) {
+        return [{ text: line }];
+    }
+    const segments = [];
+    let cursor = 0;
+    for (const match of matches) {
+        const index = line.indexOf(match, cursor);
+        if (index > cursor) {
+            segments.push({ color: "gray", text: line.slice(cursor, index) });
+        }
+        segments.push({
+            backgroundColor: "yellow",
+            bold: true,
+            color: "black",
+            text: match,
+        });
+        cursor = index + match.length;
+    }
+    if (cursor < line.length) {
+        segments.push({ color: "gray", text: line.slice(cursor) });
+    }
+    return segments;
+}
+function stylePanelLine(panelTitle, line) {
+    const trimmed = line.trim();
+    if (panelTitle.includes("Flows")) {
+        const folderMatch = line.match(/^([> ]\s+)(\s*)([▾▸]) (.+)$/);
+        if (folderMatch) {
+            const prefix = folderMatch[1] ?? "";
+            const indent = folderMatch[2] ?? "";
+            const icon = folderMatch[3] ?? "▸";
+            const name = folderMatch[4] ?? "";
+            const selected = prefix.startsWith(">");
+            const lineBackgroundColor = selected ? "cyan" : undefined;
+            return {
+                ...(lineBackgroundColor ? { backgroundColor: lineBackgroundColor } : {}),
+                segments: [
+                    {
+                        ...(lineBackgroundColor ? { backgroundColor: lineBackgroundColor } : {}),
+                        color: selected ? "black" : "gray",
+                        text: `${prefix}${indent}`,
+                    },
+                    {
+                        ...(lineBackgroundColor ? { backgroundColor: lineBackgroundColor } : {}),
+                        bold: true,
+                        color: "magenta",
+                        text: `${icon} ${name}`,
+                    },
+                ],
+                text: line,
+            };
+        }
+    }
+    if (panelTitle.includes("Flows") && line.startsWith("> ")) {
+        return {
+            backgroundColor: "cyan",
+            bold: true,
+            color: "black",
+            text: line,
+        };
+    }
+    if ((panelTitle === "User Input" || panelTitle === "Confirm") && line.startsWith("> ")) {
+        return {
+            backgroundColor: "cyan",
+            bold: true,
+            color: "black",
+            text: line,
+        };
+    }
+    if (panelTitle === "Confirm") {
+        if (/^(Run|Interrupt) flow /.test(line)) {
+            return { bold: true, color: "cyan", text: line };
+        }
+        if (line.includes("[") && line.includes("]")) {
+            return {
+                segments: parseActionSegments(line),
+                text: line,
+            };
+        }
+        if (trimmed.startsWith("Left/Right or Tab:")) {
+            return { color: "gray", text: line };
+        }
+    }
+    if (panelTitle === "User Input") {
+        const checkboxMatch = line.match(/^(\s*[> ]\s*)(\[[x ]\])(.*)$/);
+        if (checkboxMatch) {
+            const prefix = checkboxMatch[1] ?? "";
+            const marker = checkboxMatch[2] ?? "[ ]";
+            const suffix = checkboxMatch[3] ?? "";
+            const selected = prefix.includes(">");
+            const lineBackgroundColor = selected ? "cyan" : undefined;
+            const lineColor = selected ? "black" : "white";
+            return {
+                ...(lineBackgroundColor ? { backgroundColor: lineBackgroundColor } : {}),
+                color: lineColor,
+                segments: [
+                    { ...(lineBackgroundColor ? { backgroundColor: lineBackgroundColor } : {}), color: lineColor, text: prefix },
+                    {
+                        ...(lineBackgroundColor ? { backgroundColor: lineBackgroundColor } : {}),
+                        bold: marker === "[x]",
+                        color: selected ? "black" : marker === "[x]" ? "green" : "gray",
+                        text: marker,
+                    },
+                    { ...(lineBackgroundColor ? { backgroundColor: lineBackgroundColor } : {}), color: lineColor, text: suffix },
+                ],
+                text: line,
+            };
+        }
+        if (/^Field \d+\/\d+/.test(trimmed)) {
+            return { bold: true, color: "cyan", text: line };
+        }
+        if (trimmed === "Preview:" || trimmed === "Options:" || trimmed === "Text input:") {
+            return { bold: true, color: "magenta", text: line };
+        }
+        if (/^[┌└][─]+[┐┘]$/.test(trimmed) || /^│ .* │$/.test(trimmed)) {
+            return { color: "cyan", text: line };
+        }
+        if (/^Preview \d+-\d+ of \d+/.test(trimmed)) {
+            return { color: "gray", text: line };
+        }
+        if (trimmed.startsWith("Hint:")) {
+            return { color: "gray", text: line };
+        }
+    }
+    if (panelTitle === "Help") {
+        if (trimmed === "Keys:" || trimmed === "Available flows:") {
+            return { bold: true, color: "magenta", text: line };
+        }
+        if (/^[A-Z][^:]+$/.test(trimmed) && !trimmed.includes(" ")) {
+            return { bold: true, color: "cyan", text: line };
+        }
+    }
+    return { text: line };
+}
+function renderStyledContent(react, ink, panelTitle, content, backgroundColor) {
+    const { Fragment, createElement } = react;
+    const { Box, Text } = ink;
+    const lines = content.length > 0 ? content.split("\n") : [" "];
+    const wrap = panelTitle.includes("Flows") ? "truncate-end" : undefined;
+    return createElement(Box, {
+        flexDirection: "column",
+        flexGrow: 1,
+        width: "100%",
+        backgroundColor,
+    }, lines.map((line, index) => {
+        const styledLine = stylePanelLine(panelTitle, line);
+        const lineBackgroundColor = styledLine.backgroundColor ?? backgroundColor;
+        const contentNode = styledLine.segments
+            ? createElement(Text, {
+                backgroundColor: lineBackgroundColor,
+                bold: styledLine.bold,
+                color: styledLine.color,
+                ...(wrap ? { wrap } : {}),
+            }, styledLine.segments.map((segment, segmentIndex) => createElement(Text, {
+                key: `segment-${index}-${segmentIndex}`,
+                backgroundColor: segment.backgroundColor ?? lineBackgroundColor,
+                bold: segment.bold,
+                color: segment.color,
+                ...(wrap ? { wrap } : {}),
+            }, segment.text)))
+            : createElement(Text, {
+                backgroundColor: lineBackgroundColor,
+                bold: styledLine.bold,
+                color: styledLine.color,
+                ...(wrap ? { wrap } : {}),
+            }, styledLine.text.length > 0 ? styledLine.text : " ");
+        return createElement(Box, {
+            key: `line-${index}`,
+            width: "100%",
+            backgroundColor: lineBackgroundColor,
+        }, createElement(Fragment, null, contentNode));
+    }));
+}
+export function sliceFromScroll(text, offset, maxLines = 12) {
+    return resolveScrollWindow(text, offset, maxLines).text;
+}
+function resolveScrollWindow(text, offset, maxLines = 12) {
+    const lines = text.split("\n");
+    const viewportLines = Math.max(1, maxLines);
+    const boundedOffset = clampScrollOffset(offset, Math.max(0, lines.length - viewportLines));
+    const start = boundedOffset;
+    const visible = lines.slice(start, start + maxLines);
+    return {
+        text: visible.join("\n"),
+        startLine: start,
+        totalLines: lines.length,
+        viewportLines,
+    };
+}
+function buildScrollbarLines(scrollbar) {
+    const viewport = Math.max(1, scrollbar.viewportLines);
+    const total = Math.max(0, scrollbar.totalLines);
+    if (total <= viewport) {
+        return Array.from({ length: viewport }, () => ({ char: " ", color: "gray" }));
+    }
+    const thumbSize = Math.max(1, Math.round((viewport * viewport) / total));
+    const maxStart = Math.max(1, total - viewport);
+    const maxThumbOffset = Math.max(0, viewport - thumbSize);
+    const thumbStart = maxThumbOffset === 0
+        ? 0
+        : Math.round((scrollbar.startLine / maxStart) * maxThumbOffset);
+    return Array.from({ length: viewport }, (_, index) => {
+        const inThumb = index >= thumbStart && index < thumbStart + thumbSize;
+        return {
+            char: inThumb ? "█" : "│",
+            color: inThumb ? "cyan" : "gray",
+        };
+    });
+}
+export function normalizeInkKeypress(input, key) {
+    let name;
+    if (key.upArrow) {
+        name = "up";
+    }
+    else if (key.downArrow) {
+        name = "down";
+    }
+    else if (key.leftArrow) {
+        name = "left";
+    }
+    else if (key.rightArrow) {
+        name = "right";
+    }
+    else if (key.pageUp) {
+        name = "pageup";
+    }
+    else if (key.pageDown) {
+        name = "pagedown";
+    }
+    else if (key.return) {
+        name = "enter";
+    }
+    else if (key.escape) {
+        name = "escape";
+    }
+    else if (key.tab) {
+        name = "tab";
+    }
+    else if (key.backspace || key.delete || input === "\b" || input === "\x7f") {
+        name = "backspace";
+    }
+    else if (input === " ") {
+        name = "space";
+    }
+    else if (input.length === 1) {
+        name = input.toLowerCase();
+    }
+    return {
+        ...(name ? { name } : {}),
+        ctrl: key.ctrl,
+        shift: key.shift,
+        meta: key.meta,
+    };
+}
+function buildFlowListText(viewModel, maxLines) {
+    const totalItems = viewModel.flowItems.length;
+    const safeMaxLines = Math.max(1, maxLines);
+    const unclampedStart = viewModel.selectedFlowIndex - Math.floor(safeMaxLines / 2);
+    const maxStart = Math.max(0, totalItems - safeMaxLines);
+    const start = clampScrollOffset(unclampedStart, maxStart);
+    const visibleItems = viewModel.flowItems.slice(start, start + safeMaxLines);
+    return visibleItems
+        .map((item, index) => {
+        const absoluteIndex = start + index;
+        return `${absoluteIndex === viewModel.selectedFlowIndex ? ">" : " "} ${item.label}`;
+    })
+        .join("\n");
+}
+function createPanelComponent(react, ink) {
+    const { createElement } = react;
+    const { Box, Text } = ink;
+    return function InkPanel({ backgroundColor, borderColor = "green", content, flexGrow, height, scrollbar, title, width, }) {
+        const scrollbarLines = scrollbar ? buildScrollbarLines(scrollbar) : null;
+        return createElement(Box, {
+            borderStyle: "round",
+            backgroundColor,
+            borderColor,
+            flexDirection: "column",
+            flexGrow,
+            height,
+            width,
+            paddingX: 1,
+            paddingY: 0,
+        }, createElement(Box, {
+            height: 1,
+            width: "100%",
+            backgroundColor,
+        }, createElement(Text, { bold: true, backgroundColor }, title)), createElement(Box, {
+            flexDirection: "row",
+            flexGrow: 1,
+            width: "100%",
+            backgroundColor,
+        }, createElement(Box, {
+            flexGrow: 1,
+            width: scrollbarLines ? undefined : "100%",
+            backgroundColor,
+        }, renderStyledContent(react, ink, title, content, backgroundColor)), scrollbarLines
+            ? createElement(Box, {
+                flexDirection: "column",
+                width: 1,
+                marginLeft: 1,
+                backgroundColor,
+            }, scrollbarLines.map((line, index) => createElement(Text, {
+                key: `scrollbar-${title}-${index}`,
+                backgroundColor,
+                color: line.color,
+            }, line.char)))
+            : null));
+    };
+}
+function createOverlayBox(react, ink, panel, options) {
+    const { createElement } = react;
+    const { Box, Text } = ink;
+    return createElement(Box, {
+        key: options.key,
+        position: "absolute",
+        top: 0,
+        left: 0,
+        width: "100%",
+        height: "100%",
+        alignItems: "center",
+        justifyContent: "center",
+    }, createElement(Box, {
+        position: "relative",
+        width: options.width,
+        height: options.height,
+        backgroundColor: "black",
+    }, createElement(Box, {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        width: options.width,
+        height: options.height,
+        backgroundColor: "black",
+    }, createElement(Text, { backgroundColor: "black" }, buildSolidFill(options.width, options.height))), createElement(panel, {
+        backgroundColor: "black",
+        borderColor: options.borderColor,
+        content: options.content,
+        height: options.height,
+        title: options.title,
+        width: options.width,
+    })));
+}
+function createInkApp(react, ink, controller) {
+    const { Fragment, createElement, useEffect, useState } = react;
+    const { Box, Text, useInput, useStdout } = ink;
+    const Panel = createPanelComponent(react, ink);
+    const App = () => {
+        const [, setVersion] = useState(0);
+        useEffect(() => {
+            const unsubscribe = controller.subscribe(() => {
+                setVersion((previous) => previous + 1);
+            });
+            controller.mount();
+            return () => {
+                unsubscribe();
+                controller.destroy();
+            };
+        }, []);
+        useInput((input, key) => {
+            void controller.handleKeypress(input, normalizeInkKeypress(input, key));
+        });
+        const { stdout } = useStdout();
+        const terminalRows = Math.max(stdout.rows ?? 24, 20);
+        const terminalColumns = Math.max(stdout.columns ?? 80, 80);
+        const bodyHeight = Math.max(terminalRows - 8, 12);
+        const minRightLogHeight = 4;
+        const minRightSummaryHeight = 4;
+        const sideStatusHeight = 6;
+        const sideDescriptionHeight = Math.max(8, Math.floor(bodyHeight * 0.22));
+        const sideFlowListHeight = Math.max(8, bodyHeight - sideDescriptionHeight - sideStatusHeight);
+        const formModalWidth = Math.max(56, Math.floor(terminalColumns * 0.72));
+        const formContentWidth = Math.max(8, formModalWidth - 8);
+        const viewModel = controller.getViewModel({ formContentWidth });
+        const rightProgressHeight = sideFlowListHeight;
+        const rightLowerAreaHeight = Math.max(0, bodyHeight - rightProgressHeight);
+        const desiredRightSummaryHeight = viewModel.summaryVisible ? Math.max(8, Math.floor(bodyHeight * 0.24)) : 0;
+        const maxRightSummaryHeight = Math.max(0, rightLowerAreaHeight - minRightLogHeight);
+        const rightSummaryHeight = viewModel.summaryVisible
+            ? Math.min(desiredRightSummaryHeight, maxRightSummaryHeight)
+            : 0;
+        const summaryPanelVisible = viewModel.summaryVisible && rightSummaryHeight >= minRightSummaryHeight;
+        const rightLogHeight = Math.max(minRightLogHeight, rightLowerAreaHeight - (summaryPanelVisible ? rightSummaryHeight : 0));
+        const progressViewportLines = Math.max(4, rightProgressHeight - 4);
+        const progressWindow = resolveScrollWindow(viewModel.progressText, viewModel.progressScrollOffset, progressViewportLines);
+        const overlayPanels = [];
+        if (viewModel.helpVisible) {
+            const modalHeight = Math.max(10, Math.floor(terminalRows * 0.6));
+            const modalWidth = Math.max(48, Math.floor(terminalColumns * 0.64));
+            overlayPanels.push(createOverlayBox(react, ink, Panel, {
+                key: "help",
+                borderColor: "magenta",
+                height: modalHeight,
+                width: modalWidth,
+                title: "Help",
+                content: sliceFromScroll(viewModel.helpText, viewModel.helpScrollOffset, Math.max(8, modalHeight - 4)),
+            }));
+        }
+        if (viewModel.confirmText) {
+            overlayPanels.push(createOverlayBox(react, ink, Panel, {
+                key: "confirm",
+                borderColor: "yellow",
+                height: 9,
+                width: Math.max(48, Math.floor(terminalColumns * 0.44)),
+                title: "Confirm",
+                content: viewModel.confirmText,
+            }));
+        }
+        if (viewModel.form) {
+            const modalHeight = Math.max(10, Math.floor(terminalRows * 0.68));
+            overlayPanels.push(createOverlayBox(react, ink, Panel, {
+                key: "form",
+                borderColor: "magenta",
+                height: modalHeight,
+                width: formModalWidth,
+                title: viewModel.form.title,
+                content: viewModel.form.content,
+            }));
+        }
+        return createElement(Fragment, null, createElement(Box, { flexDirection: "column", width: terminalColumns, height: terminalRows }, createElement(Panel, {
+            title: viewModel.title,
+            borderColor: "cyan",
+            height: 4,
+            content: viewModel.header,
+        }), createElement(Box, { flexDirection: "row", alignItems: "flex-start", flexGrow: 1 }, createElement(Box, { flexDirection: "column", width: "34%", marginRight: 1, height: bodyHeight }, createElement(Panel, {
+            title: viewModel.flowListTitle,
+            borderColor: "cyan",
+            height: sideFlowListHeight,
+            content: buildFlowListText(viewModel, Math.max(4, sideFlowListHeight - 4)),
+        }), createElement(Panel, {
+            title: "Flow Description",
+            borderColor: "magenta",
+            height: sideDescriptionHeight,
+            content: viewModel.descriptionText,
+        }), createElement(Panel, {
+            title: "Status",
+            borderColor: "green",
+            height: sideStatusHeight,
+            content: viewModel.statusText,
+        })), createElement(Box, { flexDirection: "column", width: "66%", height: bodyHeight }, createElement(Panel, {
+            title: viewModel.progressTitle,
+            borderColor: "green",
+            height: rightProgressHeight,
+            content: progressWindow.text,
+            scrollbar: {
+                startLine: progressWindow.startLine,
+                totalLines: progressWindow.totalLines,
+                viewportLines: progressWindow.viewportLines,
+            },
+        }), summaryPanelVisible
+            ? createElement(Panel, {
+                title: viewModel.summaryTitle,
+                borderColor: "green",
+                height: rightSummaryHeight,
+                content: sliceFromScroll(viewModel.summaryText, viewModel.summaryScrollOffset, Math.max(4, rightSummaryHeight - 4)),
+            })
+            : null, createElement(Panel, {
+            title: viewModel.logTitle,
+            borderColor: "yellow",
+            height: rightLogHeight,
+            content: sliceFromScroll(viewModel.logText, viewModel.logScrollOffset, Math.max(4, rightLogHeight - 4)),
+        }))), createElement(Box, {
+            borderStyle: "round",
+            borderColor: "gray",
+            height: 3,
+            paddingX: 1,
+        }, createElement(Text, null, viewModel.footer)), ...overlayPanels));
+    };
+    return createElement(App);
+}
+export function isInkRuntimeDependencyAvailable() {
+    return hasRuntimeModule("ink") && hasRuntimeModule("react");
+}
+export function describeInkInteractiveSessionAvailability() {
+    if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+        return "Interactive mode requires a real TTY on both stdin and stdout.";
+    }
+    if (!isInkRuntimeDependencyAvailable()) {
+        return "Interactive mode requires installed runtime dependencies: run `npm install` in the AgentWeaver checkout or reinstall the published package.";
+    }
+    return null;
+}
+async function loadInkModules() {
+    const [inkModule, reactModule] = await Promise.all([import("ink"), import("react")]);
+    const react = (reactModule.default ?? reactModule);
+    return {
+        ink: inkModule,
+        react,
+    };
+}
+class InkInteractiveSession {
+    controller;
+    inkInstance = null;
+    mountingPromise = null;
+    destroyed = false;
+    constructor(options) {
+        this.controller = new InteractiveSessionController(options);
+    }
+    mount() {
+        if (this.mountingPromise) {
+            return;
+        }
+        this.mountingPromise = this.mountInk();
+    }
+    destroy() {
+        this.destroyed = true;
+        this.inkInstance?.unmount();
+        this.inkInstance = null;
+    }
+    requestUserInput(form) {
+        return this.controller.requestUserInput(form);
+    }
+    setSummary(markdown) {
+        this.controller.setSummary(markdown);
+    }
+    clearSummary() {
+        this.controller.clearSummary();
+    }
+    setScope(scopeKey, jiraIssueKey) {
+        this.controller.setScope(scopeKey, jiraIssueKey);
+    }
+    appendLog(text) {
+        this.controller.appendLog(text);
+    }
+    setFlowFailed(flowId) {
+        this.controller.setFlowFailed(flowId);
+    }
+    interruptActiveForm(message) {
+        this.controller.interruptActiveForm(message);
+    }
+    async mountInk() {
+        const { ink, react } = await loadInkModules();
+        if (this.destroyed) {
+            return;
+        }
+        this.inkInstance = ink.render(createInkApp(react, ink, this.controller), {
+            exitOnCtrlC: false,
+            patchConsole: false,
+        });
+    }
+}
+export function isInkInteractiveSessionAvailable() {
+    return describeInkInteractiveSessionAvailability() === null;
+}
+export function createInkInteractiveSession(options) {
+    const unavailableReason = describeInkInteractiveSessionAvailability();
+    if (unavailableReason) {
+        throw new TaskRunnerError(unavailableReason);
+    }
+    return new InkInteractiveSession(options);
+}