agentweaver 0.1.19 → 0.1.20

package/dist/interactive/progress.js

@@ -1,3 +1,4 @@
+import { buildAutoFlowEditorViewModel } from "./auto-flow.js";
 export function displayPhaseId(phase) {
     let result = phase.id;
     const values = Object.entries(phase.repeatVars)
@@ -139,7 +140,7 @@ export function visiblePhaseItems(flow, flowState) {
         return true;
     });
 }
-export function buildProgressViewModel(flow, flowState) {
+export function buildProgressViewModel(flow, flowState, options = {}) {
     if (!flow) {
         return {
             flow: null,
@@ -147,6 +148,9 @@ export function buildProgressViewModel(flow, flowState) {
             anchorIndex: null,
         };
     }
+    if (flow.autoFlow) {
+        return buildAutoFlowProgressViewModel(flow, flowState, options);
+    }
     const items = [];
     let anchorIndex = null;
     let sawExecutedItem = false;
@@ -243,3 +247,192 @@ export function buildProgressViewModel(flow, flowState) {
         anchorIndex,
     };
 }
+function phaseOrder(flow) {
+    return new Map(flow.phases.map((phase, index) => [phase.id, index]));
+}
+function stoppedPhaseId(flowState) {
+    const terminationReason = flowState?.terminationReason ?? "";
+    const match = /^Stopped by ([^:]+):/.exec(terminationReason);
+    return match?.[1] ?? null;
+}
+function mapRuntimeStatus(status) {
+    if (status === "done") {
+        return "success";
+    }
+    return status;
+}
+function lastRuntimeBlockId(slots, flow, flowState) {
+    const order = phaseOrder(flow);
+    let result = null;
+    for (const slot of slots) {
+        for (const block of slot.blocks) {
+            if (!block.phaseId) {
+                continue;
+            }
+            const phaseState = flowState?.phases.find((phase) => phase.id === block.phaseId);
+            if (!phaseState || phaseState.status === "pending" || phaseState.status === "skipped") {
+                continue;
+            }
+            const phaseIndex = order.get(block.phaseId) ?? -1;
+            if (!result || phaseIndex >= result.phaseIndex) {
+                result = { blockId: block.blockId, phaseIndex };
+            }
+        }
+    }
+    return result?.blockId ?? null;
+}
+function runtimeStatusForBlock(block, input) {
+    if (block.status === "invalid" || block.status === "disabled" || block.status === "blocked" || block.status === "empty") {
+        return block.status;
+    }
+    if (!block.phaseId) {
+        return block.status;
+    }
+    const phaseState = input.flowState?.phases.find((phase) => phase.id === block.phaseId) ?? null;
+    const failed = input.failedFlowId === input.flow.id;
+    if (failed && (phaseState?.status === "running" || input.fallbackFailedBlockId === block.blockId)) {
+        return "failed";
+    }
+    if (input.waitingForUserInput && phaseState?.status === "running") {
+        return "waiting-user";
+    }
+    const stoppedId = input.flowState?.terminationOutcome === "stopped" ? stoppedPhaseId(input.flowState) : null;
+    if (stoppedId && stoppedId === block.phaseId) {
+        return "stopped";
+    }
+    if (phaseState) {
+        return mapRuntimeStatus(phaseState.status);
+    }
+    if (input.flowState?.terminated && stoppedId) {
+        const order = phaseOrder(input.flow);
+        const stoppedIndex = order.get(stoppedId) ?? -1;
+        const currentIndex = order.get(block.phaseId) ?? -1;
+        if (stoppedIndex >= 0 && currentIndex > stoppedIndex) {
+            return "skipped";
+        }
+    }
+    return block.status;
+}
+function aggregateSlotStatus(slot, blockStatuses) {
+    if (slot.status === "invalid" || blockStatuses.some((status) => status === "invalid")) {
+        return "invalid";
+    }
+    if (slot.blocks.length === 0) {
+        return "empty";
+    }
+    for (const status of ["failed", "stopped", "waiting-user", "running"]) {
+        if (blockStatuses.includes(status)) {
+            return status;
+        }
+    }
+    if (blockStatuses.every((status) => status === "disabled")) {
+        return "disabled";
+    }
+    const executableStatuses = blockStatuses.filter((status) => status !== "disabled");
+    if (executableStatuses.length > 0 && executableStatuses.every((status) => status === "success" || status === "skipped")) {
+        return executableStatuses.every((status) => status === "skipped") ? "skipped" : "success";
+    }
+    if (blockStatuses.some((status) => status === "blocked")) {
+        return "blocked";
+    }
+    return "pending";
+}
+function rememberProgressAnchor(items, status, state) {
+    if (status === "running" || status === "waiting-user" || status === "failed" || status === "stopped" || status === "invalid") {
+        state.anchorIndex = items.length;
+        state.sawExecutedItem = true;
+        return;
+    }
+    if (status === "done" || status === "success" || status === "skipped" || status === "disabled") {
+        state.sawExecutedItem = true;
+        return;
+    }
+    if (status === "pending" && state.sawExecutedItem && state.anchorIndex === null) {
+        state.anchorIndex = items.length;
+    }
+}
+function buildAutoFlowProgressViewModel(flow, flowState, options) {
+    if (!flow.autoFlow) {
+        return {
+            flow,
+            items: [],
+            anchorIndex: null,
+        };
+    }
+    const editor = buildAutoFlowEditorViewModel(flow.autoFlow, {
+        ...(flow.autoFlow.diagnostics && flow.autoFlow.diagnostics.length > 0 ? { diagnostics: flow.autoFlow.diagnostics } : {}),
+        ...(flow.autoFlow.lastMessage ? { lastMessage: flow.autoFlow.lastMessage } : {}),
+    });
+    const items = [];
+    const anchorState = { anchorIndex: null, sawExecutedItem: false };
+    const fallbackFailedBlockId = options.failedFlowId === flow.id
+        ? lastRuntimeBlockId(editor.slots, flow, flowState)
+        : null;
+    for (const slot of editor.slots) {
+        const blockRows = slot.blocks.map((block) => ({
+            block,
+            status: runtimeStatusForBlock(block, {
+                flow,
+                flowState,
+                ...(options.failedFlowId !== undefined ? { failedFlowId: options.failedFlowId } : {}),
+                ...(options.waitingForUserInput !== undefined ? { waitingForUserInput: options.waitingForUserInput } : {}),
+                fallbackFailedBlockId,
+            }),
+        }));
+        const status = aggregateSlotStatus(slot, blockRows.map((row) => row.status));
+        rememberProgressAnchor(items, status, anchorState);
+        items.push({
+            kind: "slot",
+            label: slot.title,
+            depth: 0,
+            status,
+            detail: slot.reason,
+            slotId: slot.slotId,
+        });
+        for (const { block, status: blockRuntimeStatus } of blockRows) {
+            rememberProgressAnchor(items, blockRuntimeStatus, anchorState);
+            items.push({
+                kind: "block",
+                label: block.title,
+                depth: 1,
+                status: blockRuntimeStatus,
+                detail: block.reason,
+                slotId: block.slotId,
+                blockId: block.blockId,
+                locked: block.locked,
+                enabled: block.enabled,
+            });
+            for (const diagnostic of block.diagnostics) {
+                rememberProgressAnchor(items, "invalid", anchorState);
+                const detail = diagnostic.paramName ? `${diagnostic.blockId ?? "flow"}.${diagnostic.paramName}` : diagnostic.blockId;
+                items.push({
+                    kind: "block",
+                    label: diagnostic.message,
+                    depth: 2,
+                    status: "invalid",
+                    ...(detail ? { detail } : {}),
+                    slotId: block.slotId,
+                    blockId: block.blockId,
+                    locked: block.locked,
+                    enabled: block.enabled,
+                });
+            }
+        }
+    }
+    if (flowState?.terminated) {
+        const terminationOutcome = flowState.terminationOutcome ?? "success";
+        const status = terminationOutcome === "stopped" ? "stopped" : "success";
+        items.push({
+            kind: "termination",
+            label: terminationOutcome === "stopped" ? "Flow stopped before completion" : "Flow completed successfully",
+            detail: `Reason: ${flowState.terminationReason ?? "flow terminated"}`,
+            depth: 0,
+            status,
+        });
+    }
+    return {
+        flow,
+        items,
+        anchorIndex: anchorState.anchorIndex,
+    };
+}

package/dist/interactive/state.js

@@ -1,4 +1,28 @@
 import { buildFlowTree, collectInitiallyExpandedFolderKeys, computeVisibleFlowItems, makeFlowKey } from "./tree.js";
+export function createUnavailableGitWorkspace(message = "Git workspace has not been refreshed yet.") {
+    return {
+        available: false,
+        repositoryRoot: null,
+        branch: null,
+        detachedHead: false,
+        clean: true,
+        upstream: null,
+        ahead: 0,
+        behind: 0,
+        lastCommit: null,
+        changedFiles: [],
+        branches: [],
+        remotes: [],
+        canPush: false,
+        pushDisabledReason: "Git repository is not available.",
+        warnings: [],
+        error: message,
+        refreshedAt: null,
+        selectedPaths: [],
+        commitMessage: "",
+        operation: { status: "idle" },
+    };
+}
 export function createInitialInteractiveState(options) {
     const flowTree = buildFlowTree(options.flows);
     const expandedFlowFolders = new Set(collectInitiallyExpandedFolderKeys(flowTree));
@@ -40,5 +64,6 @@ export function createInitialInteractiveState(options) {
             label: "Artifact Explorer",
             message: "Artifacts are available after a Web UI workflow run completes.",
         },
+        gitWorkspace: createUnavailableGitWorkspace(),
     };
 }

package/dist/interactive/web/index.js

@@ -3,6 +3,7 @@ import { writeSync } from "node:fs";
 import { FlowInterruptedError } from "../../errors.js";
 import { listArtifactCatalog } from "../../runtime/artifact-catalog.js";
 import { createArtifactRegistry } from "../../runtime/artifact-registry.js";
+import { loadAgentWeaverSettings, updateWebUiSettings } from "../../runtime/settings.js";
 import { InteractiveSessionController } from "../controller.js";
 import { startWebServer, } from "./server.js";
 function actionId(action) {
@@ -16,6 +17,7 @@ export function createWebInteractiveSession(options, webOptions = {}) {
     let shuttingDown = false;
     let activeScopeKey = options.scopeKey;
     let artifactRestoreGeneration = 0;
+    let webUiSettings = loadAgentWeaverSettings().webUi;
     const artifactCatalogProvider = webOptions.getArtifactCatalog ?? ((input) => {
         const explorerScopeKey = controller.getViewModel().artifactExplorer.scopeKey;
         const requestedScopeKey = input?.scopeKey;
@@ -26,7 +28,7 @@ export function createWebInteractiveSession(options, webOptions = {}) {
         });
     });
     function snapshot() {
-        return { type: "snapshot", viewModel: controller.getViewModel() };
+        return { type: "snapshot", viewModel: controller.getViewModel(), settings: webUiSettings };
     }
     function sendError(client, message, id) {
         const event = { type: "error", message, ...(id ? { actionId: id } : {}) };
@@ -68,33 +70,34 @@ export function createWebInteractiveSession(options, webOptions = {}) {
         try {
             const catalog = await artifactCatalogProvider({
                 scopeKey,
-                ...(candidates.length === 1 && preferredRunId ? { runId: preferredRunId, runIds: candidates } : {}),
-                ...(candidates.length > 1 ? { runIds: candidates } : {}),
             });
             if (!catalog || catalog.scopeKey !== scopeKey) {
                 return { runId: preferredRunId };
             }
+            const markdownArtifactCount = catalog.items.filter((item) => item.scopeKey === scopeKey && item.kind === "markdown").length;
             if (candidates.length === 0) {
                 return {
                     runId: null,
-                    artifactCount: catalog.items.filter((item) => item.scopeKey === scopeKey && item.kind === "markdown").length,
+                    artifactCount: markdownArtifactCount,
                 };
             }
             const matchingRunIds = candidates.filter((candidate) => (catalog.items.some((item) => item.scopeKey === scopeKey && item.runId === candidate && item.kind === "markdown")));
             if (matchingRunIds.length > 0) {
-                const matchingRunIdSet = new Set(matchingRunIds);
                 return {
                     runId: matchingRunIds[0] ?? preferredRunId,
                     ...(matchingRunIds.length > 1 ? { runIds: matchingRunIds } : {}),
-                    artifactCount: catalog.items.filter((item) => (item.scopeKey === scopeKey
-                        && item.kind === "markdown"
-                        && item.runId !== null
-                        && matchingRunIdSet.has(item.runId))).length,
+                    artifactCount: markdownArtifactCount,
+                };
+            }
+            if (markdownArtifactCount > 0) {
+                return {
+                    runId: null,
+                    artifactCount: markdownArtifactCount,
                 };
             }
             return {
                 runId: preferredRunId,
-                artifactCount: catalog.items.filter((item) => item.scopeKey === scopeKey && item.kind === "markdown" && item.runId === preferredRunId).length,
+                artifactCount: markdownArtifactCount,
             };
         }
         catch {
@@ -113,6 +116,7 @@ export function createWebInteractiveSession(options, webOptions = {}) {
             ...(artifactCount !== undefined ? { artifactCount } : {}),
             open: !controller.hasActiveInput(),
         });
+        await controller.refreshGitWorkspace();
     }
     async function restoreArtifactExplorerFromScope(scopeKey) {
         const generation = ++artifactRestoreGeneration;
@@ -223,6 +227,83 @@ export function createWebInteractiveSession(options, webOptions = {}) {
                 controller.closeArtifactExplorer();
                 return;
             }
+            if (action.type === "autoFlow.selectPreset") {
+                controller.selectAutoFlowPreset(action.preset);
+                return;
+            }
+            if (action.type === "autoFlow.loadConfig") {
+                controller.loadAutoFlowConfig(action.name, action.flowId);
+                return;
+            }
+            if (action.type === "autoFlow.save") {
+                controller.saveAutoFlowConfig(action.flowId, action.name, action.location);
+                return;
+            }
+            if (action.type === "autoFlow.reset") {
+                controller.resetAutoFlowConfig(action.flowId);
+                return;
+            }
+            if (action.type === "autoFlow.toggleBlock") {
+                controller.toggleAutoFlowBlock(action.flowId, action.blockId, action.enabled, action.slotId);
+                return;
+            }
+            if (action.type === "autoFlow.updateParam") {
+                controller.updateAutoFlowParameter(action.flowId, action.blockId, action.paramName, action.value, action.slotId);
+                return;
+            }
+            if (action.type === "autoFlow.insertBlock") {
+                controller.insertAutoFlowBlock(action.flowId, action.slotId, action.blockId);
+                return;
+            }
+            if (action.type === "autoFlow.removeBlock") {
+                controller.removeAutoFlowBlock(action.flowId, action.slotId, action.blockId);
+                return;
+            }
+            if (action.type === "git.refresh") {
+                await controller.refreshGitWorkspace();
+                return;
+            }
+            if (action.type === "git.createBranch") {
+                await controller.createGitBranch(action.branchName);
+                return;
+            }
+            if (action.type === "git.checkout") {
+                await controller.checkoutGitBranch(action.branchName);
+                return;
+            }
+            if (action.type === "git.fetch") {
+                await controller.fetchGitWorkspace();
+                return;
+            }
+            if (action.type === "git.pullFfOnly") {
+                await controller.pullGitWorkspaceFfOnly();
+                return;
+            }
+            if (action.type === "git.stage") {
+                await controller.stageGitPaths(action.paths);
+                return;
+            }
+            if (action.type === "git.unstage") {
+                await controller.unstageGitPaths(action.paths);
+                return;
+            }
+            if (action.type === "git.updateCommitMessage") {
+                controller.updateGitCommitMessage(action.message);
+                return;
+            }
+            if (action.type === "git.commit") {
+                await controller.commitGitChanges(action.paths, action.message);
+                return;
+            }
+            if (action.type === "git.push") {
+                await controller.pushGitWorkspace();
+                return;
+            }
+            if (action.type === "settings.update") {
+                webUiSettings = updateWebUiSettings(action.settings);
+                server?.broadcast(snapshot());
+                return;
+            }
             if (action.type === "help.toggle") {
                 controller.showHelp(action.visible ?? !controller.getViewModel().helpVisible);
                 return;
@@ -253,7 +334,9 @@ export function createWebInteractiveSession(options, webOptions = {}) {
                 }
                 server?.broadcast(snapshot());
             });
-            void startWebServer({
+            void controller.refreshGitWorkspace().catch((error) => {
+                controller.appendLog(`Git workspace refresh failed: ${error.message}`);
+            }).then(() => startWebServer({
                 ...(webOptions.noOpen !== undefined ? { noOpen: webOptions.noOpen } : {}),
                 ...(webOptions.host !== undefined ? { host: webOptions.host } : {}),
                 ...(webOptions.auth !== undefined ? { auth: webOptions.auth } : {}),
@@ -263,6 +346,8 @@ export function createWebInteractiveSession(options, webOptions = {}) {
                 },
                 ...(webOptions.openBrowser ? { openBrowser: webOptions.openBrowser } : {}),
                 getArtifactCatalog: (input) => artifactCatalogProvider(input),
+                gitService: controller.getGitService(),
+                getGitWorkspaceSnapshot: () => controller.getGitWorkspaceSnapshot(),
                 onClientAction: (action, client) => {
                     void dispatch(action, client);
                 },
@@ -272,7 +357,7 @@ export function createWebInteractiveSession(options, webOptions = {}) {
                 onExitRequested: () => {
                     options.onExit();
                 },
-            }).then((started) => {
+            })).then((started) => {
                 if (shuttingDown) {
                     void started.close().catch((error) => {
                         process.stderr.write(`Failed to close Web UI server: ${error.message}\n`);