agentweaver 0.1.17 → 0.1.19

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,283 @@ 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));
+    }
+    getCurrentFlowExecutionState() {
+        return this.state.flowState.executionState;
+    }
+    hasActiveInput() {
+        return this.confirmSession !== null || this.activeFormSession !== null;
+    }
+    setArtifactExplorerAvailability(input) {
+        const count = input.artifactCount;
+        const hasCount = typeof count === "number";
+        const failed = input.status === "failed";
+        const label = input.label
+            ?? (failed
+                ? hasCount && count > 0 ? "Run failed; artifacts available" : "Run failed"
+                : hasCount && count === 0 ? "Run completed; no artifacts found" : "Artifacts ready");
+        const message = input.message
+            ?? (failed
+                ? hasCount && count > 0
+                    ? "The workflow failed, but artifacts are available for review."
+                    : "The workflow failed. The explorer can check for any artifacts written before failure."
+                : hasCount && count === 0
+                    ? "The workflow completed, but no artifacts were found for this run yet."
+                    : "The workflow completed and artifacts are available for review.");
+        this.state.artifactExplorer = {
+            available: true,
+            open: Boolean(input.open) && !this.hasActiveInput(),
+            scopeKey: input.scopeKey,
+            runId: input.runId ?? null,
+            ...(input.runIds && input.runIds.length > 1 ? { runIds: input.runIds } : {}),
+            status: input.status,
+            label,
+            ...(hasCount ? { artifactCount: count } : {}),
+            message,
+        };
+        this.emitChange();
+    }
+    setArtifactExplorerUnavailable(message = "Artifacts are available after a Web UI workflow run completes.") {
+        if (!this.state.artifactExplorer.available && !this.state.artifactExplorer.open) {
+            return;
+        }
+        this.state.artifactExplorer = {
+            available: false,
+            open: false,
+            scopeKey: null,
+            runId: null,
+            status: "unavailable",
+            label: "Artifact Explorer",
+            message,
+        };
+        this.emitChange();
+    }
+    closeArtifactExplorer() {
+        if (!this.state.artifactExplorer.open) {
+            return;
+        }
+        this.state.artifactExplorer = {
+            ...this.state.artifactExplorer,
+            open: false,
+        };
+        this.emitChange();
+    }
+    openArtifactExplorer() {
+        if (!this.state.artifactExplorer.available || this.hasActiveInput()) {
+            return;
+        }
+        if (this.state.artifactExplorer.open) {
+            return;
+        }
+        this.state.artifactExplorer = {
+            ...this.state.artifactExplorer,
+            open: true,
+        };
+        this.emitChange();
+    }
     getViewModel(layout) {
         const selectedItem = this.selectedFlowTreeItem();
         const activeFlowId = this.activeFlowId();
@@ -337,6 +618,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,7 +637,9 @@ export class InteractiveSessionController {
             logText: this.logText,
             logScrollOffset: this.state.logScrollOffset,
             confirmText: this.renderConfirmText(),
+            confirmation: this.renderConfirmationView(),
             form: this.renderFormView(layout),
+            artifactExplorer: { ...this.state.artifactExplorer },
         };
     }
     emitChange(event = { type: "render" }) {
@@ -395,7 +682,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 +799,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 +874,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 +916,7 @@ export class InteractiveSessionController {
             return;
         }
         if (key.name === "enter") {
-            await this.acceptConfirm();
+            await this.acceptActiveConfirm();
         }
     }
     async handleFlowKey(key) {
@@ -661,27 +968,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 +1160,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 +1285,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 +1407,7 @@ export class InteractiveSessionController {
         }
         this.syncActiveSelectFieldValue();
         try {
+            session.validationError = null;
             validateUserInputValues(session.form, session.values);
             const result = {
                 formId: session.form.formId,
@@ -1112,7 +1420,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),
@@ -30,5 +31,14 @@ export function createInitialInteractiveState(options) {
         summaryScrollOffset: 0,
         logScrollOffset: 0,
         helpScrollOffset: 0,
+        artifactExplorer: {
+            available: false,
+            open: false,
+            scopeKey: null,
+            runId: null,
+            status: "unavailable",
+            label: "Artifact Explorer",
+            message: "Artifacts are available after a Web UI workflow run completes.",
+        },
     };
 }