agentweaver 0.1.18 → 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));
@@ -31,5 +55,15 @@ 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.",
+        },
+        gitWorkspace: createUnavailableGitWorkspace(),
     };
 }

package/dist/interactive/web/index.js

@@ -1,8 +1,11 @@
 import process from "node:process";
 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";
+import { startWebServer, } from "./server.js";
 function actionId(action) {
     return "actionId" in action ? action.actionId : undefined;
 }
@@ -12,8 +15,20 @@ export function createWebInteractiveSession(options, webOptions = {}) {
     let unsubscribe = null;
     let mounted = false;
     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;
+        const scopeKey = requestedScopeKey && requestedScopeKey === explorerScopeKey ? requestedScopeKey : activeScopeKey;
+        return listArtifactCatalog({
+            scopeKey,
+            artifactRegistry: createArtifactRegistry(),
+        });
+    });
     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 } : {}) };
@@ -24,7 +39,119 @@ export function createWebInteractiveSession(options, webOptions = {}) {
             server?.broadcast(event);
         }
     }
+    function uniqueStrings(values) {
+        return values.filter((value, index, allValues) => (typeof value === "string" && value.length > 0 && allValues.indexOf(value) === index));
+    }
+    function collectPublishedArtifactRunIds(executionState) {
+        const runIds = [];
+        for (const phase of executionState?.phases ?? []) {
+            for (const step of phase.steps) {
+                for (const artifact of step.publishedArtifacts ?? []) {
+                    const runId = artifact.manifest?.run_id;
+                    if (runId) {
+                        runIds.push(runId);
+                    }
+                }
+            }
+        }
+        return uniqueStrings(runIds);
+    }
+    function candidateRunIds() {
+        const executionState = controller.getCurrentFlowExecutionState();
+        return uniqueStrings([
+            executionState?.runId ?? null,
+            executionState?.publicationRunId ?? null,
+            ...collectPublishedArtifactRunIds(executionState),
+        ]);
+    }
+    async function resolveArtifactExplorerRunMetadata(scopeKey) {
+        const candidates = candidateRunIds();
+        const preferredRunId = candidates[0] ?? null;
+        try {
+            const catalog = await artifactCatalogProvider({
+                scopeKey,
+            });
+            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: markdownArtifactCount,
+                };
+            }
+            const matchingRunIds = candidates.filter((candidate) => (catalog.items.some((item) => item.scopeKey === scopeKey && item.runId === candidate && item.kind === "markdown")));
+            if (matchingRunIds.length > 0) {
+                return {
+                    runId: matchingRunIds[0] ?? preferredRunId,
+                    ...(matchingRunIds.length > 1 ? { runIds: matchingRunIds } : {}),
+                    artifactCount: markdownArtifactCount,
+                };
+            }
+            if (markdownArtifactCount > 0) {
+                return {
+                    runId: null,
+                    artifactCount: markdownArtifactCount,
+                };
+            }
+            return {
+                runId: preferredRunId,
+                artifactCount: markdownArtifactCount,
+            };
+        }
+        catch {
+            return { runId: preferredRunId };
+        }
+    }
+    async function markArtifactExplorerForCompletedRun(status) {
+        artifactRestoreGeneration += 1;
+        const scopeKey = activeScopeKey;
+        const { runId, runIds, artifactCount } = await resolveArtifactExplorerRunMetadata(scopeKey);
+        controller.setArtifactExplorerAvailability({
+            scopeKey,
+            runId,
+            ...(runIds ? { runIds } : {}),
+            status,
+            ...(artifactCount !== undefined ? { artifactCount } : {}),
+            open: !controller.hasActiveInput(),
+        });
+        await controller.refreshGitWorkspace();
+    }
+    async function restoreArtifactExplorerFromScope(scopeKey) {
+        const generation = ++artifactRestoreGeneration;
+        try {
+            const catalog = await artifactCatalogProvider({ scopeKey });
+            if (generation !== artifactRestoreGeneration || shuttingDown || activeScopeKey !== scopeKey) {
+                return;
+            }
+            if (!catalog || catalog.scopeKey !== scopeKey) {
+                controller.setArtifactExplorerUnavailable();
+                return;
+            }
+            const artifactCount = catalog.items.filter((item) => item.scopeKey === scopeKey && item.kind === "markdown").length;
+            if (artifactCount === 0) {
+                controller.setArtifactExplorerUnavailable("No markdown artifacts were found for the current scope.");
+                return;
+            }
+            controller.setArtifactExplorerAvailability({
+                scopeKey,
+                runId: null,
+                status: "completed",
+                artifactCount,
+                open: false,
+                label: "Artifacts available",
+                message: "Markdown artifacts from this scope are available for review.",
+            });
+        }
+        catch {
+            if (generation === artifactRestoreGeneration && !shuttingDown && activeScopeKey === scopeKey) {
+                controller.setArtifactExplorerUnavailable("Artifact Explorer could not inspect the current scope.");
+            }
+        }
+    }
     async function dispatch(action, client) {
+        let acceptedRunConfirmation = false;
         try {
             if (action.type === "flow.select") {
                 if (action.key) {
@@ -48,10 +175,16 @@ export function createWebInteractiveSession(options, webOptions = {}) {
                 return;
             }
             if (action.type === "confirm.accept") {
+                const confirmation = controller.getViewModel().confirmation;
+                const acceptedAction = action.action ?? confirmation?.selectedAction;
+                acceptedRunConfirmation = confirmation?.kind === "run" && acceptedAction !== "cancel";
                 if (action.action) {
                     controller.selectConfirmAction(action.action);
                 }
                 await controller.acceptConfirmation();
+                if (acceptedRunConfirmation) {
+                    await markArtifactExplorerForCompletedRun("completed");
+                }
                 return;
             }
             if (action.type === "confirm.cancel") {
@@ -86,6 +219,91 @@ export function createWebInteractiveSession(options, webOptions = {}) {
                 controller.clearLog();
                 return;
             }
+            if (action.type === "artifactExplorer.open") {
+                controller.openArtifactExplorer();
+                return;
+            }
+            if (action.type === "artifactExplorer.close") {
+                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;
@@ -93,6 +311,9 @@ export function createWebInteractiveSession(options, webOptions = {}) {
             controller.scrollPane(action.pane, { ...(action.delta !== undefined ? { delta: action.delta } : {}), ...(action.offset !== undefined ? { offset: action.offset } : {}) });
         }
         catch (error) {
+            if (acceptedRunConfirmation) {
+                await markArtifactExplorerForCompletedRun("failed");
+            }
             const message = error.message;
             controller.appendLog(`Web action failed: ${message}`);
             sendError(client, message, actionId(action));
@@ -105,6 +326,7 @@ export function createWebInteractiveSession(options, webOptions = {}) {
             }
             mounted = true;
             controller.mount();
+            void restoreArtifactExplorerFromScope(activeScopeKey);
             unsubscribe = controller.subscribe((event) => {
                 if (event.type === "log") {
                     server?.broadcast({ type: "log.append", appendedLines: event.appendedLines });
@@ -112,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 } : {}),
@@ -121,6 +345,9 @@ export function createWebInteractiveSession(options, webOptions = {}) {
                     controller.appendLog(message);
                 },
                 ...(webOptions.openBrowser ? { openBrowser: webOptions.openBrowser } : {}),
+                getArtifactCatalog: (input) => artifactCatalogProvider(input),
+                gitService: controller.getGitService(),
+                getGitWorkspaceSnapshot: () => controller.getGitWorkspaceSnapshot(),
                 onClientAction: (action, client) => {
                     void dispatch(action, client);
                 },
@@ -130,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`);
@@ -166,7 +393,12 @@ export function createWebInteractiveSession(options, webOptions = {}) {
         requestUserInput: (form) => controller.requestUserInput(form),
         setSummary: (markdown) => controller.setSummary(markdown),
         clearSummary: () => controller.clearSummary(),
-        setScope: (scopeKey, jiraIssueKey, gitBranchName) => controller.setScope(scopeKey, jiraIssueKey, gitBranchName),
+        setScope: (scopeKey, jiraIssueKey, gitBranchName) => {
+            activeScopeKey = scopeKey;
+            controller.setScope(scopeKey, jiraIssueKey, gitBranchName);
+            controller.setArtifactExplorerUnavailable();
+            void restoreArtifactExplorerFromScope(scopeKey);
+        },
         appendLog: (text) => controller.appendLog(text),
         setFlowFailed: (flowId) => controller.setFlowFailed(flowId),
         interruptActiveForm: (message = "Flow interrupted by user.") => {