agentweaver 0.1.16 → 0.1.18

package/dist/interactive/controller.js

@@ -23,6 +23,8 @@ const HELP_TEXT = renderMarkdownToTerminal([
     "q / Ctrl+C   exit",
 ].join("\n"));
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SPINNER_INTERVAL_MS = 200;
+const LOG_FLUSH_INTERVAL_MS = 120;
 function clamp(value, min, max) {
     return Math.min(max, Math.max(min, value));
 }
@@ -180,6 +182,7 @@ export class InteractiveSessionController {
                 currentOptionIndex: initialOptionIndex,
                 currentTextCursorIndex: initialCursorIndex,
                 previewScrollOffset: 0,
+                validationError: null,
                 resolve,
                 reject,
             };
@@ -204,9 +207,12 @@ export class InteractiveSessionController {
         }
         this.emitChange();
     }
-    setScope(scopeKey, jiraIssueKey) {
+    setScope(scopeKey, jiraIssueKey, gitBranchName) {
         this.state.scopeKey = scopeKey;
         this.state.jiraIssueKey = jiraIssueKey ?? null;
+        if (gitBranchName !== undefined) {
+            this.state.gitBranchName = gitBranchName;
+        }
         this.emitChange();
     }
     appendLog(text) {
@@ -304,7 +310,18 @@ export class InteractiveSessionController {
     selectFlowIndex(index) {
         const selectedItem = this.visibleFlowItems[index];
         if (!selectedItem) {
-            return;
+            throw new Error(`Invalid flow index: ${index}`);
+        }
+        this.state.selectedFlowItemKey = selectedItem.key;
+        if (selectedItem.kind === "flow") {
+            this.state.selectedFlowId = selectedItem.flow.id;
+        }
+        this.emitChange();
+    }
+    selectFlowKey(key) {
+        const selectedItem = this.visibleFlowItems.find((item) => item.key === key);
+        if (!selectedItem) {
+            throw new Error(`Unknown visible flow item key: ${key}`);
         }
         this.state.selectedFlowItemKey = selectedItem.key;
         if (selectedItem.kind === "flow") {
@@ -312,6 +329,199 @@ export class InteractiveSessionController {
         }
         this.emitChange();
     }
+    selectFlowId(flowId) {
+        const selectedItem = this.visibleFlowItems.find((item) => item.kind === "flow" && item.flow.id === flowId);
+        if (!selectedItem) {
+            throw new Error(`Unknown visible flow: ${flowId}`);
+        }
+        this.state.selectedFlowItemKey = selectedItem.key;
+        this.state.selectedFlowId = selectedItem.flow.id;
+        this.emitChange();
+    }
+    toggleFolderKey(key) {
+        const item = this.visibleFlowItems.find((candidate) => candidate.key === key);
+        if (!item || item.kind !== "folder") {
+            throw new Error(`Unknown visible folder key: ${key}`);
+        }
+        this.toggleFlowFolder(key);
+    }
+    toggleFolder(key) {
+        this.toggleFolderKey(key);
+    }
+    async openRunConfirm(flowId, key) {
+        if (flowId) {
+            if (!this.visibleFlowItems.some((item) => item.kind === "flow" && item.flow.id === flowId)) {
+                throw new Error(`Unknown visible flow: ${flowId}`);
+            }
+            this.selectFlowId(flowId);
+        }
+        else if (key) {
+            const keyedItem = this.visibleFlowItems.find((item) => item.key === key);
+            if (!keyedItem || keyedItem.kind !== "flow") {
+                throw new Error(`Unknown visible flow item key: ${key}`);
+            }
+            this.selectFlowKey(key);
+        }
+        const selectedItem = this.selectedFlowTreeItem();
+        if (!selectedItem || selectedItem.kind !== "flow") {
+            throw new Error("A flow must be selected before opening run confirmation.");
+        }
+        await this.openConfirm();
+    }
+    selectConfirmAction(action) {
+        if (!this.confirmSession) {
+            throw new Error("No confirmation is active.");
+        }
+        const actions = this.confirmActions();
+        if (!actions.includes(action)) {
+            throw new Error(`Invalid confirmation action: ${action}`);
+        }
+        this.confirmSession.selectedAction = action;
+        this.emitChange();
+    }
+    async acceptConfirmation() {
+        await this.acceptConfirm();
+    }
+    async acceptConfirm() {
+        if (!this.confirmSession) {
+            throw new Error("No confirmation is active.");
+        }
+        await this.acceptActiveConfirm();
+    }
+    cancelConfirmation() {
+        this.cancelConfirm();
+    }
+    cancelConfirm() {
+        if (!this.confirmSession) {
+            throw new Error("No confirmation is active.");
+        }
+        this.confirmSession = null;
+        this.emitChange();
+    }
+    updateActiveFormValues(values) {
+        const session = this.activeFormSession;
+        if (!session) {
+            throw new Error("No form is active.");
+        }
+        const fieldIds = new Set(session.form.fields.map((field) => field.id));
+        const nextValues = { ...session.values };
+        let changed = false;
+        for (const [fieldId, value] of Object.entries(values)) {
+            if (!fieldIds.has(fieldId)) {
+                continue;
+            }
+            nextValues[fieldId] = value;
+            changed = true;
+        }
+        if (!changed) {
+            return;
+        }
+        session.values = nextValues;
+        for (const field of session.form.fields) {
+            normalizeUserInputFieldValue(field, session.values);
+        }
+        session.validationError = null;
+        const field = this.currentFormField();
+        if (field?.type === "text") {
+            session.currentTextCursorIndex = String(session.values[field.id] ?? "").length;
+        }
+        else if (field?.type === "single-select" || field?.type === "multi-select") {
+            session.currentOptionIndex = this.selectedOptionIndexForField(field);
+        }
+        this.emitChange();
+    }
+    updateFormField(fieldId, value) {
+        const session = this.activeFormSession;
+        if (!session) {
+            throw new Error("No form is active.");
+        }
+        const fieldIndex = session.form.fields.findIndex((candidate) => candidate.id === fieldId);
+        const baseField = session.form.fields[fieldIndex];
+        if (!baseField) {
+            throw new Error(`Unknown form field: ${fieldId}`);
+        }
+        const field = resolveFieldDefinition(baseField, session.values);
+        if (field.type === "boolean" && typeof value !== "boolean") {
+            throw new Error(`Field '${field.label}' must be a boolean.`);
+        }
+        if (field.type === "text" && typeof value !== "string") {
+            throw new Error(`Field '${field.label}' must be a string.`);
+        }
+        if (field.type === "single-select" && typeof value !== "string") {
+            throw new Error(`Field '${field.label}' must be a string.`);
+        }
+        if (field.type === "multi-select"
+            && (!Array.isArray(value) || value.some((item) => typeof item !== "string"))) {
+            throw new Error(`Field '${field.label}' must be a string array.`);
+        }
+        session.currentFieldIndex = fieldIndex;
+        this.updateActiveFormValues({ [fieldId]: value });
+    }
+    submitActiveFormValues(values) {
+        if (!this.activeFormSession) {
+            throw new Error("No form is active.");
+        }
+        if (values) {
+            this.updateActiveFormValues(values);
+        }
+        this.submitActiveForm();
+        if (this.activeFormSession) {
+            throw new Error("Form validation failed. See session log for details.");
+        }
+    }
+    submitForm(values) {
+        this.submitActiveFormValues(values);
+    }
+    cancelForm() {
+        if (!this.activeFormSession) {
+            throw new Error("No form is active.");
+        }
+        this.cancelActiveForm();
+    }
+    async interruptFlow(flowId) {
+        const hadActiveForm = this.activeFormSession !== null;
+        if (this.activeFormSession) {
+            this.interruptActiveForm();
+        }
+        const targetFlowId = flowId ?? this.state.currentFlowId;
+        if (!targetFlowId && hadActiveForm) {
+            return;
+        }
+        if (!targetFlowId) {
+            throw new Error("No running flow is available to interrupt.");
+        }
+        await this.options.onInterrupt(targetFlowId);
+    }
+    async interruptCurrentFlow(flowId) {
+        await this.interruptFlow(flowId);
+    }
+    toggleHelp(visible) {
+        this.helpVisible = visible ?? !this.helpVisible;
+        this.emitChange();
+    }
+    showHelp(visible) {
+        this.toggleHelp(visible);
+    }
+    scrollPane(panel, options) {
+        if (panel === "flows") {
+            if (options.delta !== undefined) {
+                this.moveSelectedFlow(options.delta);
+                return;
+            }
+            if (options.offset !== undefined) {
+                this.selectFlowIndex(options.offset);
+                return;
+            }
+            throw new Error("Flow scroll requires delta or offset.");
+        }
+        const scrollPanel = panel;
+        const maxOffset = this.panelMaxScroll(scrollPanel);
+        const current = this.scrollOffsetFor(scrollPanel);
+        this.applyScrollOffset(scrollPanel, options.offset ?? current + (options.delta ?? 0), maxOffset);
+    }
+    setScrollOffset(panel, offset) {
+        this.applyScrollOffset(panel, offset, this.panelMaxScroll(panel));
+    }
     getViewModel(layout) {
         const selectedItem = this.selectedFlowTreeItem();
         const activeFlowId = this.activeFlowId();
@@ -335,6 +545,10 @@ export class InteractiveSessionController {
             flowItems: this.visibleFlowItems.map((item) => ({
                 key: item.key,
                 label: this.renderFlowTreeLabel(item),
+                kind: item.kind,
+                name: item.name,
+                depth: item.depth,
+                ...(item.kind === "folder" ? { expanded: this.expandedFlowFolders.has(item.key) } : {}),
             })),
             selectedFlowIndex: Math.max(0, this.visibleFlowItems.findIndex((item) => item.key === this.state.selectedFlowItemKey)),
             progressTitle: this.panelTitle("Current Flow", "progress"),
@@ -350,6 +564,7 @@ export class InteractiveSessionController {
             logText: this.logText,
             logScrollOffset: this.state.logScrollOffset,
             confirmText: this.renderConfirmText(),
+            confirmation: this.renderConfirmationView(),
             form: this.renderFormView(layout),
         };
     }
@@ -393,7 +608,7 @@ export class InteractiveSessionController {
         const current = this.state.currentFlowId ?? selectHeaderLabel(this.selectedFlowTreeItem(), this.state.selectedFlowId);
         const pathParts = this.options.cwd.split(path.sep).filter(Boolean);
         const folderName = pathParts.slice(-3).join("/") || this.options.cwd;
-        const branchLabel = this.options.gitBranchName ? this.options.gitBranchName : "detached-head";
+        const branchLabel = this.state.gitBranchName ? this.state.gitBranchName : "detached-head";
         const runningSuffix = this.state.busy ? " [running]" : "";
         const versionLabel = this.state.version ? ` | Version ${this.state.version}` : "";
         const jiraLabel = this.state.jiraIssueKey ? ` | Jira ${this.state.jiraIssueKey}` : "";
@@ -428,7 +643,8 @@ export class InteractiveSessionController {
             return "Flow structure is not available.";
         }
         if (selectedItem.kind === "folder") {
-            const kindLabel = selectedItem.pathSegments[0] === "custom" ? "project-local" : "built-in";
+            const rootName = selectedItem.pathSegments[0];
+            const kindLabel = rootName === "custom" ? "project-local" : rootName === "global" ? "global" : "built-in";
             return [
                 `Flow folder '${selectedItem.pathSegments.join("/")}'.`,
                 "",
@@ -440,8 +656,8 @@ export class InteractiveSessionController {
         const description = flow.description?.trim() || "No description available for this flow.";
         const details = [
             `Path: ${flow.treePath.join("/")}`,
-            `Source: ${flow.source === "project-local" ? "project-local" : "built-in"}`,
-            flow.source === "project-local" && flow.sourcePath ? `File: ${flow.sourcePath}` : "",
+            `Source: ${flow.source === "project-local" ? "project-local" : flow.source === "global" ? "global" : "built-in"}`,
+            flow.source !== "built-in" && flow.sourcePath ? `File: ${flow.sourcePath}` : "",
         ]
             .filter((line) => line.length > 0)
             .join("\n");
@@ -488,11 +704,13 @@ export class InteractiveSessionController {
                 ? "Stop"
                 : action === "resume"
                     ? "Resume"
-                    : action === "restart"
-                        ? "Restart"
-                        : action === "ok"
-                            ? "OK"
-                            : "Cancel";
+                    : action === "continue"
+                        ? "Continue"
+                        : action === "restart"
+                            ? "Restart"
+                            : action === "ok"
+                                ? "OK"
+                                : "Cancel";
             return session.selectedAction === action ? `[ ${label} ]` : `  ${label}  `;
         })
             .join("   ");
@@ -507,6 +725,20 @@ export class InteractiveSessionController {
         lines.push("", actionLabels, "", "Left/Right or Tab: choose    Enter: confirm    Esc: cancel");
         return lines.join("\n");
     }
+    renderConfirmationView() {
+        const session = this.confirmSession;
+        const text = this.renderConfirmText();
+        if (!session || !text) {
+            return null;
+        }
+        return {
+            kind: session.kind,
+            flowId: session.flowId,
+            text,
+            actions: this.confirmActions(),
+            selectedAction: session.selectedAction,
+        };
+    }
     renderFormView(layout) {
         const session = this.activeFormSession;
         const field = this.currentFormField();
@@ -568,6 +800,12 @@ export class InteractiveSessionController {
             title: "User Input",
             content: lines.join("\n"),
             footer,
+            formId: session.form.formId,
+            definition: session.form,
+            values: { ...session.values },
+            fields: session.form.fields.map((candidate) => resolveFieldDefinition(candidate, session.values)),
+            currentFieldId: field.id,
+            error: session.validationError,
         };
     }
     currentFormField() {
@@ -604,7 +842,7 @@ export class InteractiveSessionController {
             return;
         }
         if (key.name === "enter") {
-            await this.acceptConfirm();
+            await this.acceptActiveConfirm();
         }
     }
     async handleFlowKey(key) {
@@ -656,27 +894,27 @@ export class InteractiveSessionController {
         const maxOffset = this.panelMaxScroll(panel);
         const current = this.scrollOffsetFor(panel);
         if (key.name === "up") {
-            this.setScrollOffset(panel, current - 1, maxOffset);
+            this.applyScrollOffset(panel, current - 1, maxOffset);
             return;
         }
         if (key.name === "down") {
-            this.setScrollOffset(panel, current + 1, maxOffset);
+            this.applyScrollOffset(panel, current + 1, maxOffset);
             return;
         }
         if (key.name === "pageup") {
-            this.setScrollOffset(panel, current - 10, maxOffset);
+            this.applyScrollOffset(panel, current - 10, maxOffset);
             return;
         }
         if (key.name === "pagedown") {
-            this.setScrollOffset(panel, current + 10, maxOffset);
+            this.applyScrollOffset(panel, current + 10, maxOffset);
             return;
         }
         if (key.name === "home") {
-            this.setScrollOffset(panel, 0, maxOffset);
+            this.applyScrollOffset(panel, 0, maxOffset);
             return;
         }
         if (key.name === "end") {
-            this.setScrollOffset(panel, maxOffset, maxOffset);
+            this.applyScrollOffset(panel, maxOffset, maxOffset);
         }
     }
     moveSelectedFlow(delta) {
@@ -759,10 +997,20 @@ export class InteractiveSessionController {
         this.confirmSession = {
             kind: "run",
             flowId: selectedItem.flow.id,
-            resumeAvailable: confirmation.resumeAvailable,
-            hasExistingState: confirmation.hasExistingState,
+            availability: {
+                hasExistingState: confirmation.hasExistingState,
+                resume: confirmation.resume.available,
+                continue: confirmation.continue.available,
+                restart: confirmation.restart.available,
+            },
             details: confirmation.details ?? null,
-            selectedAction: confirmation.resumeAvailable ? "resume" : confirmation.hasExistingState ? "restart" : "ok",
+            selectedAction: confirmation.resume.available
+                ? "resume"
+                : confirmation.continue.available
+                    ? "continue"
+                    : confirmation.restart.available
+                        ? "restart"
+                        : "ok",
         };
         this.emitChange();
     }
@@ -774,8 +1022,12 @@ export class InteractiveSessionController {
         this.confirmSession = {
             kind: "interrupt",
             flowId,
-            resumeAvailable: true,
-            hasExistingState: true,
+            availability: {
+                hasExistingState: true,
+                resume: true,
+                continue: false,
+                restart: false,
+            },
             details: "The current flow will be stopped. State will be saved and can be continued via Resume.",
             selectedAction: "stop",
         };
@@ -791,8 +1043,12 @@ export class InteractiveSessionController {
         this.confirmSession = {
             kind: "exit",
             flowId: null,
-            resumeAvailable: false,
-            hasExistingState: false,
+            availability: {
+                hasExistingState: false,
+                resume: false,
+                continue: false,
+                restart: false,
+            },
             details,
             selectedAction: "ok",
         };
@@ -808,11 +1064,17 @@ export class InteractiveSessionController {
         if (this.confirmSession.kind === "exit") {
             return ["ok", "cancel"];
         }
-        return this.confirmSession.resumeAvailable
-            ? ["resume", "restart", "cancel"]
-            : this.confirmSession.hasExistingState
-                ? ["restart", "cancel"]
-                : ["ok", "cancel"];
+        const actions = [];
+        if (this.confirmSession.availability.resume) {
+            actions.push("resume");
+        }
+        if (this.confirmSession.availability.continue) {
+            actions.push("continue");
+        }
+        if (this.confirmSession.availability.restart) {
+            actions.push("restart");
+        }
+        return actions.length > 0 ? [...actions, "cancel"] : ["ok", "cancel"];
     }
     moveConfirmSelection(delta) {
         if (!this.confirmSession) {
@@ -824,7 +1086,7 @@ export class InteractiveSessionController {
         this.confirmSession.selectedAction = (actions[nextIndex] ?? "cancel");
         this.emitChange();
     }
-    async acceptConfirm() {
+    async acceptActiveConfirm() {
         const session = this.confirmSession;
         if (!session) {
             return;
@@ -850,7 +1112,11 @@ export class InteractiveSessionController {
             return;
         }
         const flowId = session.flowId ?? this.state.selectedFlowId;
-        const launchMode = session.selectedAction === "resume" ? "resume" : "restart";
+        const launchMode = session.selectedAction === "resume"
+            ? "resume"
+            : session.selectedAction === "continue"
+                ? "continue"
+                : "restart";
         this.confirmSession = null;
         this.setBusy(true, flowId);
         this.clearFlowFailure(flowId);
@@ -895,7 +1161,7 @@ export class InteractiveSessionController {
             this.spinnerTimer = setInterval(() => {
                 this.state.spinnerFrame = (this.state.spinnerFrame + 1) % SPINNER_FRAMES.length;
                 this.emitChange();
-            }, 120);
+            }, SPINNER_INTERVAL_MS);
             return;
         }
         if (!running && this.spinnerTimer) {
@@ -945,7 +1211,7 @@ export class InteractiveSessionController {
         }
         return this.state.logScrollOffset;
     }
-    setScrollOffset(panel, value, maxOffset) {
+    applyScrollOffset(panel, value, maxOffset) {
         const next = clamp(value, 0, maxOffset);
         if (panel === "progress") {
             this.state.progressScrollOffset = next;
@@ -1067,6 +1333,7 @@ export class InteractiveSessionController {
         }
         this.syncActiveSelectFieldValue();
         try {
+            session.validationError = null;
             validateUserInputValues(session.form, session.values);
             const result = {
                 formId: session.form.formId,
@@ -1079,7 +1346,9 @@ export class InteractiveSessionController {
             this.emitChange();
         }
         catch (error) {
-            this.appendLog(error.message);
+            session.validationError = error.message;
+            this.appendLog(session.validationError);
+            this.emitChange();
         }
     }
     cancelActiveForm() {
@@ -1278,7 +1547,7 @@ export class InteractiveSessionController {
         this.logFlushTimer = setTimeout(() => {
             this.logFlushTimer = null;
             this.flushPendingLogLines();
-        }, 50);
+        }, LOG_FLUSH_INTERVAL_MS);
     }
     flushPendingLogLines() {
         if (this.pendingLogLines.length === 0) {

package/dist/interactive/ink/index.js

@@ -370,14 +370,35 @@ function createInkApp(react, ink, controller) {
     const { Fragment, createElement, useEffect, useState } = react;
     const { Box, Text, useInput, useStdout } = ink;
     const Panel = createPanelComponent(react, ink);
+    const LOG_REPAINT_DEBOUNCE_MS = 100;
     const App = () => {
         const [, setVersion] = useState(0);
         useEffect(() => {
-            const unsubscribe = controller.subscribe(() => {
+            let logRepaintTimer = null;
+            const flushRepaint = () => {
+                if (logRepaintTimer) {
+                    clearTimeout(logRepaintTimer);
+                    logRepaintTimer = null;
+                }
                 setVersion((previous) => previous + 1);
+            };
+            const unsubscribe = controller.subscribe((event) => {
+                if (event.type === "log") {
+                    if (logRepaintTimer) {
+                        return;
+                    }
+                    logRepaintTimer = setTimeout(() => {
+                        flushRepaint();
+                    }, LOG_REPAINT_DEBOUNCE_MS);
+                    return;
+                }
+                flushRepaint();
             });
             controller.mount();
             return () => {
+                if (logRepaintTimer) {
+                    clearTimeout(logRepaintTimer);
+                }
                 unsubscribe();
                 controller.destroy();
             };
@@ -541,8 +562,8 @@ class InkInteractiveSession {
     clearSummary() {
         this.controller.clearSummary();
     }
-    setScope(scopeKey, jiraIssueKey) {
-        this.controller.setScope(scopeKey, jiraIssueKey);
+    setScope(scopeKey, jiraIssueKey, gitBranchName) {
+        this.controller.setScope(scopeKey, jiraIssueKey, gitBranchName);
     }
     appendLog(text) {
         this.controller.appendLog(text);

package/dist/interactive/state.js

@@ -8,6 +8,7 @@ export function createInitialInteractiveState(options) {
     return {
         scopeKey: options.scopeKey,
         jiraIssueKey: options.jiraIssueKey ?? null,
+        gitBranchName: options.gitBranchName,
         summaryText: options.summaryText.trim(),
         version: options.version ?? "",
         flowTreeKeys: flowTree.map((node) => node.key),

package/dist/interactive/tree.js

@@ -75,7 +75,7 @@ export function buildFlowTree(flows) {
             children: sortNodes(node.children),
         }
         : node);
-    const orderedRootNames = ["custom", "default"];
+    const orderedRootNames = ["global", "custom", "default"];
     const sortedRoots = [...roots.values()].sort((left, right) => {
         const leftIndex = orderedRootNames.indexOf(left.name);
         const rightIndex = orderedRootNames.indexOf(right.name);
@@ -143,7 +143,7 @@ export function collectInitiallyExpandedFolderKeys(flowTree) {
             if (node.kind !== "folder") {
                 continue;
             }
-            const expandedByDefault = node.pathSegments.length === 1 && node.name === "default";
+            const expandedByDefault = node.pathSegments.length === 1 && (node.name === "default" || node.name === "global");
             if (expandedByDefault) {
                 keys.push(node.key);
             }