@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/tui/workflow-labels.js

@@ -1,223 +0,0 @@
-import { nonemptyText } from "./text-values.js";
-import { isDoneResult, parallelStatuses, groupStatus, outcomeLabel, spanCompleted, } from "./workflow-outcomes.js";
-export { isDoneResult } from "./workflow-outcomes.js";
-function parallelLabelCount(label) {
-    if (!label.startsWith("[") || !label.endsWith("]")) {
-        return;
-    }
-    const inner = label.slice(1, -1).trim();
-    return inner.length === 0
-        ? 0
-        : inner
-            .split("+")
-            .map((part) => part.trim())
-            .filter(Boolean).length;
-}
-function graphSpan(node, cursor, stepIndex) {
-    const parallel = node.kind === "parallel-group" || node.kind === "dynamic-parallel-group";
-    if (!parallel) {
-        return {
-            stepIndex,
-            start: node.flatIndex ?? cursor,
-            count: 1,
-            isParallel: false,
-            status: node.status,
-            label: node.label,
-            error: node.error,
-        };
-    }
-    const indexes = (node.children ?? []).flatMap((child) => child.flatIndex === undefined ? [] : [child.flatIndex]);
-    return {
-        stepIndex,
-        start: indexes.length > 0 ? Math.min(...indexes) : cursor,
-        count: node.children?.length ?? 0,
-        isParallel: true,
-        status: node.status,
-        label: node.label,
-        error: node.error,
-    };
-}
-function graphSpans(nodes) {
-    const spans = [];
-    let cursor = 0;
-    for (const node of nodes) {
-        if (node.stepIndex === undefined) {
-            continue;
-        }
-        const span = graphSpan(node, cursor, node.stepIndex);
-        spans.push(span);
-        cursor = Math.max(cursor, span.start + span.count);
-    }
-    return spans.sort((left, right) => left.stepIndex - right.stepIndex);
-}
-export function buildChainStepSpans(details) {
-    const graph = graphSpans(details.workflowGraph?.nodes ?? []);
-    if (graph.length > 0) {
-        return graph;
-    }
-    let start = 0;
-    return (details.chainAgents ?? []).map((label, stepIndex) => {
-        const parallel = parallelLabelCount(label), count = parallel ?? 1;
-        const span = { stepIndex, start, count, isParallel: parallel !== undefined };
-        start += count;
-        return span;
-    });
-}
-function activeChainGroup(details) {
-    if (details.mode !== "chain" || details.currentStepIndex === undefined) {
-        return false;
-    }
-    return buildChainStepSpans(details).some((span) => span.stepIndex === details.currentStepIndex && span.isParallel);
-}
-export function buildAsyncChainStepSpans(total, stepCount, parallelGroups = []) {
-    const spans = [];
-    let flat = 0;
-    for (let stepIndex = 0; stepIndex < total; stepIndex++) {
-        const group = parallelGroups.find((candidate) => candidate.stepIndex === stepIndex);
-        if (group) {
-            spans.push({ stepIndex, start: group.start, count: group.count, isParallel: true });
-            flat = Math.max(flat, group.start + group.count);
-            continue;
-        }
-        spans.push({ stepIndex, start: flat, count: flat < stepCount ? 1 : 0, isParallel: false });
-        flat++;
-    }
-    return spans;
-}
-export function workflowGraphHasStatus(details, statuses) {
-    return details.workflowGraph?.nodes.some((node) => statuses.includes(node.status)) ?? false;
-}
-function hasChainRows(details, label) {
-    return (details.mode === "chain" &&
-        (label.hasParallelInChain || (details.workflowGraph?.nodes.length ?? 0) > 0) &&
-        !label.showActiveGroupOnly);
-}
-function placeholder(span, details) {
-    const single = span.isParallel ? undefined : details.chainAgents?.[span.stepIndex];
-    const agentName = single ?? span.label ?? details.chainAgents?.[span.stepIndex] ?? `step-${span.stepIndex + 1}`;
-    return {
-        kind: "placeholder",
-        rowNumber: span.stepIndex + 1,
-        stepLabel: `Step ${span.stepIndex + 1}`,
-        agentName,
-        status: span.status ?? "pending",
-        error: span.error,
-    };
-}
-export function buildChainRenderEntries(details, label) {
-    if (!hasChainRows(details, label)) {
-        return;
-    }
-    const entries = [];
-    for (const span of buildChainStepSpans(details)) {
-        const missing = span.isParallel
-            ? span.count === 0
-            : details.results.at(span.start) === undefined;
-        if (missing) {
-            entries.push(placeholder(span, details));
-            continue;
-        }
-        for (let index = span.start; index < span.start + span.count; index++) {
-            const agentName = details.results.at(index)?.agent ??
-                details.chainAgents?.[span.stepIndex] ??
-                `step-${span.stepIndex + 1}`;
-            entries.push({ kind: "result", resultIndex: index, rowNumber: index + 1, agentName });
-        }
-    }
-    return entries;
-}
-function labelBase(details, spans) {
-    const active = activeChainGroup(details);
-    return {
-        itemTitle: details.mode === "parallel" || active ? "Agent" : "Step",
-        hasParallelInChain: details.mode === "chain" && spans.some((span) => span.isParallel),
-        activeParallelGroup: active,
-        groupStartIndex: 0,
-        groupEndIndex: details.results.length,
-        showActiveGroupOnly: false,
-    };
-}
-function activeGroupLabel(details, spans, base, running) {
-    const current = details.currentStepIndex ?? 0, span = spans.at(current), count = span?.count ?? 1, start = span?.start ?? 0;
-    const total = details.totalSteps ?? details.chainAgents?.length ?? 1;
-    const statuses = Array.from({ length: count }, (_, offset) => groupStatus(details, start + offset));
-    return {
-        ...base,
-        totalCount: count,
-        groupStartIndex: start,
-        groupEndIndex: start + count,
-        showActiveGroupOnly: true,
-        headerLabel: `step ${current + 1}/${total} · parallel group: ${outcomeLabel(statuses, count, running)}`,
-    };
-}
-function chainLabel(details, spans, base, running) {
-    const total = details.totalSteps ?? details.chainAgents?.length ?? details.results.length;
-    const logical = details.mode === "chain" && (details.chainAgents?.length ?? 0) > 0;
-    const done = logical
-        ? spans.filter((span) => spanCompleted(details, span)).length
-        : details.results.filter(isDoneResult).length;
-    const current = details.currentStepIndex === undefined
-        ? Math.min(total, done + Number(running))
-        : details.currentStepIndex + 1;
-    return { ...base, totalCount: total, headerLabel: `step ${running ? current : done}/${total}` };
-}
-export function buildMultiProgressLabel(details, running) {
-    const spans = buildChainStepSpans(details), base = labelBase(details, spans);
-    if (details.mode === "parallel") {
-        const total = details.totalSteps ?? details.results.length;
-        return {
-            ...base,
-            totalCount: total,
-            groupEndIndex: total,
-            headerLabel: outcomeLabel(parallelStatuses(details, total), total, running, true),
-        };
-    }
-    return base.activeParallelGroup
-        ? activeGroupLabel(details, spans, base, running)
-        : chainLabel(details, spans, base, running);
-}
-function fallbackName(details, index, direct, fallback) {
-    const agent = details.results.at(index)?.agent;
-    if (direct) {
-        return nonemptyText(agent) ?? fallback;
-    }
-    return nonemptyText(details.chainAgents?.at(index)) ?? nonemptyText(agent) ?? fallback;
-}
-export function renderEntries(details, label, fallback = "step") {
-    const chain = buildChainRenderEntries(details, label);
-    if (chain) {
-        return chain;
-    }
-    const chainCount = details.chainAgents?.length ?? 0;
-    const direct = label.hasParallelInChain || chainCount === 0;
-    const start = label.showActiveGroupOnly ? label.groupStartIndex : 0;
-    let end = direct ? details.results.length : chainCount;
-    if (label.showActiveGroupOnly) {
-        end = label.groupEndIndex;
-    }
-    return Array.from({ length: end - start }, (_, offset) => {
-        const index = start + offset, row = label.showActiveGroupOnly ? index - label.groupStartIndex + 1 : index + 1;
-        return {
-            kind: "result",
-            resultIndex: index,
-            rowNumber: row,
-            agentName: fallbackName(details, index, direct, `${fallback}-${row}`),
-        };
-    });
-}
-export function resultRowLabel(details, label, index, step) {
-    if (details.mode === "chain" && label.hasParallelInChain) {
-        const span = buildChainStepSpans(details).find((candidate) => index >= candidate.start && index < candidate.start + candidate.count);
-        if (span?.isParallel === true) {
-            return `Agent ${index - span.start + 1}/${span.count}`;
-        }
-        if (span) {
-            return `Step ${span.stepIndex + 1}`;
-        }
-    }
-    if (label.itemTitle !== "Agent") {
-        return `Step ${step}`;
-    }
-    const local = label.activeParallelGroup ? Math.max(1, step - label.groupStartIndex) : step;
-    return `Agent ${local}/${label.totalCount}`;
-}

package/dist/tui/workflow-outcomes.js

@@ -1,124 +0,0 @@
-import { formatAgentRunningLabel } from "../shared/status-format.js";
-function pausedResult(result) {
-    return result?.interrupted === true || result?.detached === true;
-}
-function blockedResult(result) {
-    return result?.acceptance?.status === "blocked";
-}
-export function isDoneResult(result) {
-    if (pausedResult(result) || result.timedOut === true || blockedResult(result)) {
-        return false;
-    }
-    const status = result.progress?.status;
-    if (status === "completed") {
-        return true;
-    }
-    return status !== "running" && status !== "pending" && result.exitCode === 0;
-}
-function resultStatus(result) {
-    if (result.progress) {
-        return result.progress.status;
-    }
-    if (result.timedOut === true) {
-        return "timed-out";
-    }
-    if (pausedResult(result)) {
-        return "detached";
-    }
-    if (result.exitCode !== 0) {
-        return "failed";
-    }
-    return blockedResult(result) ? "blocked" : "completed";
-}
-function resultIndex(details, result, position) {
-    const progress = details.progress?.find((entry) => entry.index === position) ??
-        details.progress?.find((entry) => entry.agent === result.agent && entry.status === "running");
-    return result.progress?.index ?? progress?.index ?? position;
-}
-export function parallelStatuses(details, total) {
-    const statuses = Array.from({ length: total }, () => "pending");
-    for (const progress of details.progress ?? []) {
-        if (progress.index >= 0 && progress.index < total) {
-            statuses[progress.index] = progress.status;
-        }
-    }
-    for (const [position, result] of details.results.entries()) {
-        const index = resultIndex(details, result, position);
-        if (index >= 0 && index < total) {
-            statuses[index] = resultStatus(result);
-        }
-    }
-    return statuses;
-}
-function stoppedGroupStatus(status, result) {
-    if (status === "failed" || status === "timed-out" || result?.timedOut === true) {
-        return "failed";
-    }
-    if (status === "paused" || status === "detached" || pausedResult(result)) {
-        return "paused";
-    }
-    return;
-}
-function completedGroupStatus(status, result) {
-    if (result !== undefined && result.exitCode !== 0) {
-        return "failed";
-    }
-    if (status === "blocked" || blockedResult(result)) {
-        return "blocked";
-    }
-    return status === "completed" || (result !== undefined && isDoneResult(result))
-        ? "completed"
-        : "pending";
-}
-export function groupStatus(details, index) {
-    const progress = details.progress?.find((entry) => entry.index === index);
-    const result = details.results.find((entry, position) => (entry.progress?.index ?? position) === index);
-    const status = progress?.status ?? result?.progress?.status;
-    if (status === "running") {
-        return "running";
-    }
-    return stoppedGroupStatus(status, result) ?? completedGroupStatus(status, result);
-}
-export function outcomeLabel(statuses, total, running, blockedFirst = false) {
-    const count = (states) => statuses.filter((status) => states.includes(status)).length;
-    const parts = [`${count(["completed"])}/${total} succeeded`];
-    const blocked = count(["blocked"]), failed = count(["failed", "timed-out"]), paused = count(["paused", "detached"]);
-    if (blockedFirst && blocked > 0) {
-        parts.push(`${blocked} need human action`);
-    }
-    if (running) {
-        parts.unshift(formatAgentRunningLabel(count(["running"])));
-    }
-    if (failed > 0) {
-        parts.push(`${failed} failed`);
-    }
-    if (paused > 0) {
-        parts.push(`${paused} paused`);
-    }
-    if (!blockedFirst && blocked > 0) {
-        parts.push(`${blocked} need human action`);
-    }
-    return parts.join(" · ");
-}
-function completedAt(details, index) {
-    const progress = details.progress?.find((entry) => entry.index === index);
-    const result = details.results.find((entry) => entry.progress?.index === index) ?? details.results.at(index);
-    if (["running", "pending", "failed"].includes(progress?.status ?? "")) {
-        return false;
-    }
-    return result !== undefined && isDoneResult(result);
-}
-export function spanCompleted(details, span) {
-    if (span.status !== undefined && span.status !== "completed") {
-        return false;
-    }
-    if (span.count === 0) {
-        return span.status === "completed";
-    }
-    for (let index = span.start; index < span.start + span.count; index++) {
-        if (!completedAt(details, index)) {
-            return false;
-        }
-    }
-    return true;
-}

package/generated/RunValidators.d.ts

@@ -1,28 +0,0 @@
-// Generated by scripts/generate-run-schemas.mjs; do not edit.
-import type { ValidateFunction } from "ajv";
-import type * as Run from "../src/shared/types.ts";
-import type { SubagentRunConfig } from "../src/runs/background/runner-config.ts";
-import type { NativeFinalizationConfig, NativeFinalizationEvent } from "../src/runs/shared/native-finalization-types.ts";
-export const AsyncStatus: ValidateFunction<Run.AsyncStatus>;
-export const AsyncResultFile: ValidateFunction<Run.AsyncResultFile>;
-export const ForegroundResumeRun: ValidateFunction<Run.ForegroundResumeRun>;
-export const OwnedRun: ValidateFunction<Run.OwnedRun>;
-export const AsyncStartedEvent: ValidateFunction<Run.AsyncStartedEvent>;
-export const ControlEvent: ValidateFunction<Run.ControlEvent>;
-export const SupervisorRunContract: ValidateFunction<Run.SupervisorRunContract>;
-export const SupervisorQuestion: ValidateFunction<Run.SupervisorQuestion>;
-export const QuestionAnswer: ValidateFunction<Run.QuestionAnswer>;
-export const QuestionDelivery: ValidateFunction<Run.QuestionDelivery>;
-export const SupervisorQuestionView: ValidateFunction<NonNullable<Run.SupervisorQuestionView["revival"]>>;
-export const HistoryRunRow: ValidateFunction<Run.HistoryRunRow>;
-export const HistoryRunPage: ValidateFunction<Run.HistoryRunPage>;
-export const HistoryPage: ValidateFunction<Run.HistoryPage>;
-export const HistorySearchPage: ValidateFunction<Run.HistorySearchPage>;
-export const HistoryIndexStatus: ValidateFunction<Run.HistoryIndexStatus>;
-export const HistoryEntry: ValidateFunction<Run.HistoryEntry>;
-export const HistoryResult: ValidateFunction<Run.HistoryResult>;
-export const Details: ValidateFunction<Run.Details>;
-export const SubagentExecutionResult: ValidateFunction<Run.SubagentExecutionResult>;
-export const SubagentRunConfig: ValidateFunction<SubagentRunConfig>;
-export const NativeFinalizationConfig: ValidateFunction<NativeFinalizationConfig>;
-export const NativeFinalizationEvent: ValidateFunction<NativeFinalizationEvent>;