agentweaver 0.1.18 → 0.1.19

package/README.md

@@ -146,6 +146,14 @@ The Web UI serves the operator console from the same local process, including `/
 
 Web UI state is process-local: it exists only while the AgentWeaver process is running and is not shared with other AgentWeaver processes. The Web UI is intended to match the interactive operator workflow for flow selection, launch confirmation, routing and user-input forms, progress and logs, and interrupt handling.
 
+### Artifact Explorer
+
+After a Web UI workflow completes, and also after a failed run when artifacts were written before failure, the Web UI offers the Artifact Explorer. It reads artifacts from the active AgentWeaver scope only, optionally filtered to the run id published by the completed workflow. The browser requests artifact content through safe artifact identifiers resolved by the active catalog and registry; it does not accept arbitrary filesystem paths.
+
+The MVP explorer previews Markdown, JSON, plain text, and diff artifacts. Diffs are rendered as text. Binary and unknown artifacts are listed with metadata and safe raw/download actions, but their inline preview is a placeholder. Large previews are bounded and marked as truncated with loaded byte and total size metadata; raw and download links can still serve the full artifact bytes with no-store cache headers and safe content types.
+
+When Web UI credentials are configured, the same HTTP Basic auth protection applies to `/`, `/static/*`, `/__agentweaver/ws`, `/__agentweaver/exit`, and the artifact list, preview, raw, and download API routes. The MVP explorer does not support artifact editing, comments, run comparison, image previews, specialized viewers, live updates, or full-text search.
+
 ## Installation
 
 Local development:

package/dist/index.js

@@ -38,6 +38,7 @@ import { requestUserInputInTerminal } from "./user-input.js";
 import { runDoctorCommand } from "./doctor/index.js";
 import { requestJiraContext, resolveProjectScope, } from "./scope.js";
 const COMMANDS = [
+    "auto",
     "auto-golang",
     "auto-common-guided",
     "auto-common",
@@ -174,6 +175,8 @@ function usage() {
   agentweaver review-loop [--dry] [--verbose] [--prompt <text>] [--scope <name>] [--blocking-severities <list>] [<jira-browse-url|jira-issue-key>]
   agentweaver run-go-tests-loop [--dry] [--verbose] [--prompt <text>] [--scope <name>] [<jira-browse-url|jira-issue-key>]
   agentweaver run-go-linter-loop [--dry] [--verbose] [--prompt <text>] [--scope <name>] [<jira-browse-url|jira-issue-key>]
+  agentweaver auto [--dry] [--verbose] [--prompt <text>] [--md-lang <en|ru>] <jira-browse-url|jira-issue-key>
+  agentweaver auto --help-phases
   agentweaver auto-golang [--dry] [--verbose] [--prompt <text>] [<jira-browse-url|jira-issue-key>]
   agentweaver auto-golang [--dry] [--verbose] [--prompt <text>] --from <phase> [<jira-browse-url|jira-issue-key>]
   agentweaver auto-golang --help-phases
@@ -1481,11 +1484,12 @@ async function parseCliArgs(argv) {
         writeStderrSync(`${usage()}\n`);
         process.exit(1);
     }
-    const command = argv[0];
-    if (!COMMANDS.includes(command)) {
+    const rawCommand = argv[0];
+    if (!COMMANDS.includes(rawCommand)) {
         writeStderrSync(`${usage()}\n`);
         process.exit(1);
     }
+    const command = rawCommand === "auto" ? "auto-common" : rawCommand;
     let dry = false;
     let verbose = false;
     let prompt;

package/dist/interactive/controller.js

@@ -522,6 +522,79 @@ export class InteractiveSessionController {
     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();
@@ -566,6 +639,7 @@ export class InteractiveSessionController {
             confirmText: this.renderConfirmText(),
             confirmation: this.renderConfirmationView(),
             form: this.renderFormView(layout),
+            artifactExplorer: { ...this.state.artifactExplorer },
         };
     }
     emitChange(event = { type: "render" }) {

package/dist/interactive/state.js

@@ -31,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.",
+        },
     };
 }

package/dist/interactive/web/index.js

@@ -1,8 +1,10 @@
 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 { 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,6 +14,17 @@ export function createWebInteractiveSession(options, webOptions = {}) {
     let unsubscribe = null;
     let mounted = false;
     let shuttingDown = false;
+    let activeScopeKey = options.scopeKey;
+    let artifactRestoreGeneration = 0;
+    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() };
     }
@@ -24,7 +37,117 @@ 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,
+                ...(candidates.length === 1 && preferredRunId ? { runId: preferredRunId, runIds: candidates } : {}),
+                ...(candidates.length > 1 ? { runIds: candidates } : {}),
+            });
+            if (!catalog || catalog.scopeKey !== scopeKey) {
+                return { runId: preferredRunId };
+            }
+            if (candidates.length === 0) {
+                return {
+                    runId: null,
+                    artifactCount: catalog.items.filter((item) => item.scopeKey === scopeKey && item.kind === "markdown").length,
+                };
+            }
+            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,
+                };
+            }
+            return {
+                runId: preferredRunId,
+                artifactCount: catalog.items.filter((item) => item.scopeKey === scopeKey && item.kind === "markdown" && item.runId === preferredRunId).length,
+            };
+        }
+        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(),
+        });
+    }
+    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 +171,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 +215,14 @@ 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 === "help.toggle") {
                 controller.showHelp(action.visible ?? !controller.getViewModel().helpVisible);
                 return;
@@ -93,6 +230,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 +245,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 });
@@ -121,6 +262,7 @@ export function createWebInteractiveSession(options, webOptions = {}) {
                     controller.appendLog(message);
                 },
                 ...(webOptions.openBrowser ? { openBrowser: webOptions.openBrowser } : {}),
+                getArtifactCatalog: (input) => artifactCatalogProvider(input),
                 onClientAction: (action, client) => {
                     void dispatch(action, client);
                 },
@@ -166,7 +308,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.") => {

package/dist/interactive/web/protocol.js

@@ -12,6 +12,8 @@ const ACTION_TYPES = new Set([
     "interrupt.openConfirm",
     "flow.interrupt",
     "log.clear",
+    "artifactExplorer.open",
+    "artifactExplorer.close",
     "help.toggle",
     "scroll",
 ]);
@@ -96,7 +98,11 @@ export function parseClientAction(raw) {
         const action = optionalNonEmptyString(parsed, "action");
         return { type: "confirm.accept", ...(action ? { action } : {}), ...(actionId ? { actionId } : {}) };
     }
-    if (parsed.type === "confirm.cancel" || parsed.type === "form.cancel" || parsed.type === "log.clear") {
+    if (parsed.type === "confirm.cancel"
+        || parsed.type === "form.cancel"
+        || parsed.type === "log.clear"
+        || parsed.type === "artifactExplorer.open"
+        || parsed.type === "artifactExplorer.close") {
         return { type: parsed.type, ...(actionId ? { actionId } : {}) };
     }
     if (parsed.type === "form.update") {