agentweaver 0.1.15 → 0.1.17

package/dist/interactive/progress.js

@@ -0,0 +1,245 @@
+export function displayPhaseId(phase) {
+    let result = phase.id;
+    const values = Object.entries(phase.repeatVars)
+        .filter(([key]) => !key.endsWith("_minus_one"))
+        .map(([, value]) => value);
+    for (const value of values) {
+        const suffix = `_${String(value)}`;
+        if (result.endsWith(suffix)) {
+            result = result.slice(0, -suffix.length);
+        }
+    }
+    return result;
+}
+function repeatGroupKey(repeatVars) {
+    const entries = Object.entries(repeatVars).sort(([left], [right]) => left.localeCompare(right));
+    return JSON.stringify(entries);
+}
+function repeatSeriesKey(phases) {
+    const repeatVarNames = Object.keys(phases[0]?.repeatVars ?? {}).sort();
+    const phaseNames = phases.map((phase) => displayPhaseId(phase));
+    return JSON.stringify({
+        repeatVarNames,
+        phaseNames,
+    });
+}
+function repeatLabel(repeatVars) {
+    const entries = Object.entries(repeatVars).filter(([key]) => !key.endsWith("_minus_one"));
+    if (entries.length === 0) {
+        return null;
+    }
+    if (entries.length === 1) {
+        const [key, value] = entries[0] ?? ["repeat", ""];
+        return `${key} ${value}`;
+    }
+    return entries.map(([key, value]) => `${key}=${value}`).join(", ");
+}
+export function isAfterTermination(flowState, flow, phase) {
+    const terminationReason = flowState.terminationReason ?? "";
+    const match = /^Stopped by ([^:]+):/.exec(terminationReason);
+    if (!match) {
+        return false;
+    }
+    const stoppedPhaseId = match[1];
+    const stoppedIndex = flow.phases.findIndex((candidate) => candidate.id === stoppedPhaseId);
+    const currentIndex = flow.phases.findIndex((candidate) => candidate.id === phase.id);
+    if (stoppedIndex < 0 || currentIndex < 0) {
+        return false;
+    }
+    return currentIndex > stoppedIndex;
+}
+export function displayStatusForPhase(flowState, flow, phase, actualStatus) {
+    if (actualStatus) {
+        return actualStatus;
+    }
+    if (!flowState?.terminated) {
+        return "pending";
+    }
+    return isAfterTermination(flowState, flow, phase) ? "skipped" : "pending";
+}
+export function displayStatusForStep(flowState, flow, phase, actualStatus) {
+    if (actualStatus) {
+        return actualStatus;
+    }
+    if (!flowState?.terminated) {
+        return "pending";
+    }
+    return isAfterTermination(flowState, flow, phase) ? "skipped" : "pending";
+}
+export function statusForGroup(flow, phases, flowState) {
+    const statuses = phases.map((phase) => displayStatusForPhase(flowState, flow, phase, flowState?.phases.find((candidate) => candidate.id === phase.id)?.status ?? null));
+    if (statuses.some((status) => status === "running")) {
+        return "running";
+    }
+    if (statuses.every((status) => status === "skipped")) {
+        return "skipped";
+    }
+    if (statuses.every((status) => status === "done" || status === "skipped")) {
+        return "done";
+    }
+    return "pending";
+}
+export function groupPhases(flow) {
+    const items = [];
+    let index = 0;
+    while (index < flow.phases.length) {
+        const phase = flow.phases[index];
+        if (!phase) {
+            break;
+        }
+        const label = repeatLabel(phase.repeatVars);
+        if (!label) {
+            items.push({ kind: "phase", phase });
+            index += 1;
+            continue;
+        }
+        const phases = [phase];
+        let nextIndex = index + 1;
+        while (nextIndex < flow.phases.length) {
+            const candidate = flow.phases[nextIndex];
+            if (!candidate || repeatGroupKey(candidate.repeatVars) !== repeatGroupKey(phase.repeatVars)) {
+                break;
+            }
+            phases.push(candidate);
+            nextIndex += 1;
+        }
+        items.push({ kind: "group", label, phases, seriesKey: repeatSeriesKey(phases) });
+        index = nextIndex;
+    }
+    return items;
+}
+export function shouldDisplayPhase(flow, flowState, phase) {
+    const phaseState = flowState?.phases.find((candidate) => candidate.id === phase.id) ?? null;
+    if (!flowState) {
+        return true;
+    }
+    if (phaseState?.status === "skipped" && flowState.terminated && isAfterTermination(flowState, flow, phase)) {
+        return false;
+    }
+    return true;
+}
+export function visiblePhaseItems(flow, flowState) {
+    const pendingSeries = new Set();
+    return groupPhases(flow).filter((item) => {
+        if (item.kind === "phase") {
+            return shouldDisplayPhase(flow, flowState, item.phase);
+        }
+        const visiblePhases = item.phases.filter((phase) => shouldDisplayPhase(flow, flowState, phase));
+        const hasState = visiblePhases.some((phase) => flowState?.phases.some((candidate) => candidate.id === phase.id));
+        if (visiblePhases.length === 0) {
+            return false;
+        }
+        if (hasState) {
+            return true;
+        }
+        if (pendingSeries.has(item.seriesKey)) {
+            return false;
+        }
+        pendingSeries.add(item.seriesKey);
+        return true;
+    });
+}
+export function buildProgressViewModel(flow, flowState) {
+    if (!flow) {
+        return {
+            flow: null,
+            items: [],
+            anchorIndex: null,
+        };
+    }
+    const items = [];
+    let anchorIndex = null;
+    let sawExecutedItem = false;
+    const rememberAnchor = (status) => {
+        if (status === "running") {
+            anchorIndex = items.length;
+            sawExecutedItem = true;
+            return;
+        }
+        if (status === "done" || status === "skipped") {
+            sawExecutedItem = true;
+            return;
+        }
+        if (status === "pending" && sawExecutedItem && anchorIndex === null) {
+            anchorIndex = items.length;
+        }
+    };
+    for (const item of visiblePhaseItems(flow, flowState)) {
+        if (item.kind === "group") {
+            const visiblePhases = item.phases.filter((phase) => shouldDisplayPhase(flow, flowState, phase));
+            if (visiblePhases.length === 0) {
+                continue;
+            }
+            const groupStatus = statusForGroup(flow, visiblePhases, flowState);
+            rememberAnchor(groupStatus);
+            items.push({
+                kind: "group",
+                label: item.label,
+                depth: 0,
+                status: groupStatus,
+            });
+            for (const phase of visiblePhases) {
+                const phaseState = flowState?.phases.find((candidate) => candidate.id === phase.id);
+                const phaseStatus = displayStatusForPhase(flowState, flow, phase, phaseState?.status ?? null);
+                rememberAnchor(phaseStatus);
+                items.push({
+                    kind: "phase",
+                    label: displayPhaseId(phase),
+                    depth: 1,
+                    status: phaseStatus,
+                });
+                for (const step of phase.steps) {
+                    const stepState = phaseState?.steps.find((candidate) => candidate.id === step.id);
+                    const stepStatus = displayStatusForStep(flowState, flow, phase, stepState?.status ?? null);
+                    rememberAnchor(stepStatus);
+                    items.push({
+                        kind: "step",
+                        label: step.id,
+                        depth: 2,
+                        status: stepStatus,
+                    });
+                }
+            }
+            continue;
+        }
+        const phase = item.phase;
+        if (!shouldDisplayPhase(flow, flowState, phase)) {
+            continue;
+        }
+        const phaseState = flowState?.phases.find((candidate) => candidate.id === phase.id);
+        const phaseStatus = displayStatusForPhase(flowState, flow, phase, phaseState?.status ?? null);
+        rememberAnchor(phaseStatus);
+        items.push({
+            kind: "phase",
+            label: displayPhaseId(phase),
+            depth: 0,
+            status: phaseStatus,
+        });
+        for (const step of phase.steps) {
+            const stepState = phaseState?.steps.find((candidate) => candidate.id === step.id);
+            const stepStatus = displayStatusForStep(flowState, flow, phase, stepState?.status ?? null);
+            rememberAnchor(stepStatus);
+            items.push({
+                kind: "step",
+                label: step.id,
+                depth: 1,
+                status: stepStatus,
+            });
+        }
+    }
+    if (flowState?.terminated) {
+        const terminationOutcome = flowState.terminationOutcome ?? "success";
+        items.push({
+            kind: "termination",
+            label: terminationOutcome === "stopped" ? "Flow stopped before completion" : "Flow completed successfully",
+            detail: `Reason: ${flowState.terminationReason ?? "flow terminated"}`,
+            depth: 0,
+            status: terminationOutcome === "stopped" ? "running" : "done",
+        });
+    }
+    return {
+        flow,
+        items,
+        anchorIndex,
+    };
+}

package/dist/interactive/selectors.js

@@ -0,0 +1,14 @@
+import { buildProgressViewModel } from "./progress.js";
+import { computeVisibleFlowItems } from "./tree.js";
+export function selectVisibleFlowItems(flowTree, expandedFlowFolders) {
+    return computeVisibleFlowItems(flowTree, expandedFlowFolders);
+}
+export function selectHeaderLabel(selectedItem, fallbackFlowId) {
+    if (!selectedItem) {
+        return fallbackFlowId;
+    }
+    return selectedItem.kind === "folder" ? selectedItem.pathSegments.join("/") : selectedItem.flow.label;
+}
+export function selectProgressViewModel(flow, flowState) {
+    return buildProgressViewModel(flow, flowState);
+}

package/dist/interactive/session.js

@@ -0,0 +1 @@
+export {};

package/dist/interactive/state.js

@@ -0,0 +1,34 @@
+import { buildFlowTree, collectInitiallyExpandedFolderKeys, computeVisibleFlowItems, makeFlowKey } from "./tree.js";
+export function createInitialInteractiveState(options) {
+    const flowTree = buildFlowTree(options.flows);
+    const expandedFlowFolders = new Set(collectInitiallyExpandedFolderKeys(flowTree));
+    const visibleFlowItems = computeVisibleFlowItems(flowTree, expandedFlowFolders);
+    const initiallySelectedItem = visibleFlowItems.find((item) => item.kind === "flow") ?? visibleFlowItems[0];
+    const selectedFlowId = initiallySelectedItem?.kind === "flow" ? initiallySelectedItem.flow.id : options.flows[0]?.id ?? "auto-golang";
+    return {
+        scopeKey: options.scopeKey,
+        jiraIssueKey: options.jiraIssueKey ?? null,
+        summaryText: options.summaryText.trim(),
+        version: options.version ?? "",
+        flowTreeKeys: flowTree.map((node) => node.key),
+        selectedFlowId,
+        selectedFlowItemKey: initiallySelectedItem?.key ?? makeFlowKey(selectedFlowId),
+        focusedPane: "flows",
+        summaryVisible: options.summaryText.trim().length > 0,
+        busy: false,
+        currentFlowId: null,
+        currentNode: null,
+        currentExecutor: null,
+        failedFlowId: null,
+        flowState: {
+            flowId: null,
+            executionState: null,
+        },
+        runningStartedAt: null,
+        spinnerFrame: 0,
+        progressScrollOffset: 0,
+        summaryScrollOffset: 0,
+        logScrollOffset: 0,
+        helpScrollOffset: 0,
+    };
+}

package/dist/interactive/tree.js

@@ -0,0 +1,155 @@
+function compareTreeNames(left, right) {
+    return left.localeCompare(right, "ru");
+}
+export function makeFolderKey(pathSegments) {
+    return `folder:${pathSegments.join("/")}`;
+}
+export function makeFlowKey(flowId) {
+    return `flow:${flowId}`;
+}
+export function buildFlowTree(flows) {
+    const roots = new Map();
+    const ensureFolder = (pathSegments) => {
+        const firstSegment = pathSegments[0];
+        if (!firstSegment) {
+            throw new Error("Flow tree folder path cannot be empty.");
+        }
+        const rootFolder = roots.get(firstSegment);
+        let currentFolder;
+        if (rootFolder) {
+            currentFolder = rootFolder;
+        }
+        else {
+            currentFolder = {
+                kind: "folder",
+                key: makeFolderKey([firstSegment]),
+                name: firstSegment,
+                pathSegments: [firstSegment],
+                children: [],
+            };
+            roots.set(firstSegment, currentFolder);
+        }
+        for (let index = 1; index < pathSegments.length; index += 1) {
+            const segment = pathSegments[index] ?? "";
+            const folderPath = pathSegments.slice(0, index + 1);
+            let nextFolder = currentFolder.children.find((child) => child.kind === "folder" && child.name === segment);
+            if (!nextFolder) {
+                nextFolder = {
+                    kind: "folder",
+                    key: makeFolderKey(folderPath),
+                    name: segment,
+                    pathSegments: folderPath,
+                    children: [],
+                };
+                currentFolder.children.push(nextFolder);
+            }
+            currentFolder = nextFolder;
+        }
+        return currentFolder;
+    };
+    for (const flow of flows) {
+        if (flow.treePath.length === 0) {
+            continue;
+        }
+        const folderPath = flow.treePath.slice(0, -1);
+        const leafName = flow.treePath[flow.treePath.length - 1] ?? flow.id;
+        const parent = ensureFolder(folderPath);
+        parent.children.push({
+            kind: "flow",
+            key: makeFlowKey(flow.id),
+            name: leafName,
+            pathSegments: [...flow.treePath],
+            flow,
+        });
+    }
+    const sortNodes = (nodes) => [...nodes]
+        .sort((left, right) => {
+        if (left.kind !== right.kind) {
+            return left.kind === "folder" ? -1 : 1;
+        }
+        return compareTreeNames(left.name, right.name);
+    })
+        .map((node) => node.kind === "folder"
+        ? {
+            ...node,
+            children: sortNodes(node.children),
+        }
+        : node);
+    const orderedRootNames = ["global", "custom", "default"];
+    const sortedRoots = [...roots.values()].sort((left, right) => {
+        const leftIndex = orderedRootNames.indexOf(left.name);
+        const rightIndex = orderedRootNames.indexOf(right.name);
+        if (leftIndex !== -1 || rightIndex !== -1) {
+            if (leftIndex === -1) {
+                return 1;
+            }
+            if (rightIndex === -1) {
+                return -1;
+            }
+            return leftIndex - rightIndex;
+        }
+        return compareTreeNames(left.name, right.name);
+    });
+    return sortNodes(sortedRoots);
+}
+export function computeVisibleFlowItems(flowTree, expandedFlowFolders) {
+    const items = [];
+    const walk = (nodes, depth) => {
+        for (const node of nodes) {
+            if (node.kind === "folder") {
+                items.push({
+                    kind: "folder",
+                    key: node.key,
+                    name: node.name,
+                    depth,
+                    pathSegments: [...node.pathSegments],
+                });
+                if (expandedFlowFolders.has(node.key)) {
+                    walk(node.children, depth + 1);
+                }
+                continue;
+            }
+            items.push({
+                kind: "flow",
+                key: node.key,
+                name: node.name,
+                depth,
+                pathSegments: [...node.pathSegments],
+                flow: node.flow,
+            });
+        }
+    };
+    walk(flowTree, 0);
+    return items;
+}
+export function collectFolderKeys(flowTree) {
+    const keys = [];
+    const walk = (nodes) => {
+        for (const node of nodes) {
+            if (node.kind !== "folder") {
+                continue;
+            }
+            keys.push(node.key);
+            walk(node.children);
+        }
+    };
+    walk(flowTree);
+    return keys;
+}
+export function collectInitiallyExpandedFolderKeys(flowTree) {
+    const keys = [];
+    const walk = (nodes) => {
+        for (const node of nodes) {
+            if (node.kind !== "folder") {
+                continue;
+            }
+            const expandedByDefault = node.pathSegments.length === 1 && (node.name === "default" || node.name === "global");
+            if (expandedByDefault) {
+                keys.push(node.key);
+            }
+            walk(node.children);
+        }
+    };
+    walk(flowTree);
+    return keys;
+}

package/dist/interactive/types.js

@@ -0,0 +1 @@
+export {};

package/dist/interactive/view-model.js

@@ -0,0 +1 @@
+export {};