agentweaver 0.1.17 → 0.1.18

package/dist/interactive/controller.js

@@ -182,6 +182,7 @@ export class InteractiveSessionController {
                 currentOptionIndex: initialOptionIndex,
                 currentTextCursorIndex: initialCursorIndex,
                 previewScrollOffset: 0,
+                validationError: null,
                 resolve,
                 reject,
             };
@@ -206,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) {
@@ -306,7 +310,7 @@ 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") {
@@ -314,6 +318,210 @@ export class InteractiveSessionController {
         }
         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") {
+            this.state.selectedFlowId = selectedItem.flow.id;
+        }
+        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();
@@ -337,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"),
@@ -352,6 +564,7 @@ export class InteractiveSessionController {
             logText: this.logText,
             logScrollOffset: this.state.logScrollOffset,
             confirmText: this.renderConfirmText(),
+            confirmation: this.renderConfirmationView(),
             form: this.renderFormView(layout),
         };
     }
@@ -395,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}` : "";
@@ -512,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();
@@ -573,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() {
@@ -609,7 +842,7 @@ export class InteractiveSessionController {
             return;
         }
         if (key.name === "enter") {
-            await this.acceptConfirm();
+            await this.acceptActiveConfirm();
         }
     }
     async handleFlowKey(key) {
@@ -661,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) {
@@ -853,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;
@@ -978,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;
@@ -1100,6 +1333,7 @@ export class InteractiveSessionController {
         }
         this.syncActiveSelectFieldValue();
         try {
+            session.validationError = null;
             validateUserInputValues(session.form, session.values);
             const result = {
                 formId: session.form.formId,
@@ -1112,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() {

package/dist/interactive/ink/index.js

@@ -562,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/web/index.js

@@ -0,0 +1,179 @@
+import process from "node:process";
+import { writeSync } from "node:fs";
+import { FlowInterruptedError } from "../../errors.js";
+import { InteractiveSessionController } from "../controller.js";
+import { startWebServer } from "./server.js";
+function actionId(action) {
+    return "actionId" in action ? action.actionId : undefined;
+}
+export function createWebInteractiveSession(options, webOptions = {}) {
+    const controller = new InteractiveSessionController(options);
+    let server = null;
+    let unsubscribe = null;
+    let mounted = false;
+    let shuttingDown = false;
+    function snapshot() {
+        return { type: "snapshot", viewModel: controller.getViewModel() };
+    }
+    function sendError(client, message, id) {
+        const event = { type: "error", message, ...(id ? { actionId: id } : {}) };
+        if (client) {
+            client.send(event);
+        }
+        else {
+            server?.broadcast(event);
+        }
+    }
+    async function dispatch(action, client) {
+        try {
+            if (action.type === "flow.select") {
+                if (action.key) {
+                    controller.selectFlowKey(action.key);
+                }
+                else {
+                    controller.selectFlowIndex(action.index ?? 0);
+                }
+                return;
+            }
+            if (action.type === "folder.toggle") {
+                controller.toggleFolderKey(action.key);
+                return;
+            }
+            if (action.type === "run.openConfirm") {
+                await controller.openRunConfirm(action.flowId, action.key);
+                return;
+            }
+            if (action.type === "confirm.select") {
+                controller.selectConfirmAction(action.action);
+                return;
+            }
+            if (action.type === "confirm.accept") {
+                if (action.action) {
+                    controller.selectConfirmAction(action.action);
+                }
+                await controller.acceptConfirmation();
+                return;
+            }
+            if (action.type === "confirm.cancel") {
+                controller.cancelConfirmation();
+                return;
+            }
+            if (action.type === "form.update") {
+                controller.updateActiveFormValues(action.values);
+                return;
+            }
+            if (action.type === "form.fieldUpdate") {
+                controller.updateFormField(action.fieldId, action.value);
+                return;
+            }
+            if (action.type === "form.submit") {
+                controller.submitForm(action.values);
+                return;
+            }
+            if (action.type === "form.cancel") {
+                controller.cancelForm();
+                return;
+            }
+            if (action.type === "flow.interrupt") {
+                await controller.interruptCurrentFlow(action.flowId);
+                return;
+            }
+            if (action.type === "interrupt.openConfirm") {
+                controller.openInterruptConfirm();
+                return;
+            }
+            if (action.type === "log.clear") {
+                controller.clearLog();
+                return;
+            }
+            if (action.type === "help.toggle") {
+                controller.showHelp(action.visible ?? !controller.getViewModel().helpVisible);
+                return;
+            }
+            controller.scrollPane(action.pane, { ...(action.delta !== undefined ? { delta: action.delta } : {}), ...(action.offset !== undefined ? { offset: action.offset } : {}) });
+        }
+        catch (error) {
+            const message = error.message;
+            controller.appendLog(`Web action failed: ${message}`);
+            sendError(client, message, actionId(action));
+        }
+    }
+    return {
+        mount() {
+            if (mounted) {
+                return;
+            }
+            mounted = true;
+            controller.mount();
+            unsubscribe = controller.subscribe((event) => {
+                if (event.type === "log") {
+                    server?.broadcast({ type: "log.append", appendedLines: event.appendedLines });
+                    return;
+                }
+                server?.broadcast(snapshot());
+            });
+            void startWebServer({
+                ...(webOptions.noOpen !== undefined ? { noOpen: webOptions.noOpen } : {}),
+                ...(webOptions.host !== undefined ? { host: webOptions.host } : {}),
+                ...(webOptions.auth !== undefined ? { auth: webOptions.auth } : {}),
+                printInfo: (message) => {
+                    webOptions.printInfo?.(message);
+                    controller.appendLog(message);
+                },
+                ...(webOptions.openBrowser ? { openBrowser: webOptions.openBrowser } : {}),
+                onClientAction: (action, client) => {
+                    void dispatch(action, client);
+                },
+                onClientConnected: (client) => {
+                    client.send(snapshot());
+                },
+                onExitRequested: () => {
+                    options.onExit();
+                },
+            }).then((started) => {
+                if (shuttingDown) {
+                    void started.close().catch((error) => {
+                        process.stderr.write(`Failed to close Web UI server: ${error.message}\n`);
+                    });
+                    return;
+                }
+                server = started;
+                webOptions.onServerReady?.(started);
+            }).catch((error) => {
+                const message = `Web UI startup failed: ${error.message}`;
+                controller.appendLog(message);
+                writeSync(process.stderr.fd, `${message}\n`);
+                options.onExit();
+            });
+        },
+        destroy() {
+            if (shuttingDown) {
+                return;
+            }
+            shuttingDown = true;
+            controller.interruptActiveForm("Web UI session closed.");
+            unsubscribe?.();
+            unsubscribe = null;
+            const closePromise = server?.close();
+            server = null;
+            if (closePromise) {
+                void closePromise.catch((error) => {
+                    process.stderr.write(`Failed to close Web UI server: ${error.message}\n`);
+                });
+            }
+            controller.destroy();
+        },
+        requestUserInput: (form) => controller.requestUserInput(form),
+        setSummary: (markdown) => controller.setSummary(markdown),
+        clearSummary: () => controller.clearSummary(),
+        setScope: (scopeKey, jiraIssueKey, gitBranchName) => controller.setScope(scopeKey, jiraIssueKey, gitBranchName),
+        appendLog: (text) => controller.appendLog(text),
+        setFlowFailed: (flowId) => controller.setFlowFailed(flowId),
+        interruptActiveForm: (message = "Flow interrupted by user.") => {
+            controller.interruptActiveForm(message);
+            if (message) {
+                controller.appendLog(new FlowInterruptedError(message).message);
+            }
+        },
+    };
+}