@fitchmultz/pi-subagents 0.0.0-stage → 0.44.5

package/dist/slash/slash-live-state.js

@@ -0,0 +1,246 @@
+import { SLASH_RESULT_TYPE } from "../shared/types.js";
+const liveSnapshots = new Map();
+const finalSnapshots = new Map();
+let versionCounter = 1;
+const EMPTY_MESSAGES = [];
+const EMPTY_USAGE = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    cost: 0,
+    turns: 0,
+};
+function nextVersion() {
+    return versionCounter++;
+}
+function cloneUsage() {
+    return { ...EMPTY_USAGE };
+}
+function createPlaceholderResult(agent, task, status, index = 0) {
+    return {
+        agent,
+        task,
+        exitCode: 0,
+        messages: EMPTY_MESSAGES,
+        usage: cloneUsage(),
+        progress: {
+            index,
+            agent,
+            status,
+            task,
+            recentTools: [],
+            recentOutput: [],
+            toolCount: 0,
+            tokens: 0,
+            durationMs: 0,
+        },
+    };
+}
+function buildParallelInitialResult(params) {
+    const tasks = params.tasks ?? [];
+    return {
+        content: [{ type: "text", text: tasks.map((task) => `${task.agent}: ${task.task}`).join("\n\n") }],
+        details: {
+            mode: "parallel",
+            ...(params.context ? { context: params.context } : {}),
+            results: tasks.map((task, index) => createPlaceholderResult(task.agent, task.task, "running", index)),
+            progress: tasks.map((task, index) => ({
+                index,
+                agent: task.agent,
+                status: "running",
+                task: task.task,
+                recentTools: [],
+                recentOutput: [],
+                toolCount: 0,
+                tokens: 0,
+                durationMs: 0,
+            })),
+        },
+    };
+}
+function isParallelChainStep(step) {
+    return "parallel" in step && Array.isArray(step.parallel);
+}
+function chainStepLabel(step) {
+    if (isParallelChainStep(step)) {
+        return `[${step.parallel.map((entry) => entry.agent).join("+")}]`;
+    }
+    return step.agent;
+}
+function flattenChainResults(chain, fallbackTask) {
+    const results = [];
+    let flatIndex = 0;
+    for (const step of chain) {
+        if (isParallelChainStep(step)) {
+            for (const task of step.parallel) {
+                results.push(createPlaceholderResult(task.agent, task.task ?? fallbackTask ?? "", results.length === 0 ? "running" : "pending", flatIndex));
+                flatIndex++;
+            }
+            continue;
+        }
+        results.push(createPlaceholderResult(step.agent, step.task ?? fallbackTask ?? "", results.length === 0 ? "running" : "pending", flatIndex));
+        flatIndex++;
+    }
+    return results;
+}
+function buildChainInitialResult(params) {
+    const chain = (params.chain ?? []);
+    const results = flattenChainResults(chain, params.task);
+    return {
+        content: [{
+                type: "text",
+                text: results.map((result, index) => `Step ${index + 1}: ${result.agent}\n${result.task}`).join("\n\n"),
+            }],
+        details: {
+            mode: "chain",
+            ...(params.context ? { context: params.context } : {}),
+            results,
+            progress: results.map((result, index) => ({
+                index,
+                agent: result.agent,
+                status: index === 0 ? "running" : "pending",
+                task: result.task,
+                recentTools: [],
+                recentOutput: [],
+                toolCount: 0,
+                tokens: 0,
+                durationMs: 0,
+            })),
+            chainAgents: chain.map((step) => chainStepLabel(step)),
+            totalSteps: chain.length,
+            currentStepIndex: 0,
+        },
+    };
+}
+function buildSingleInitialResult(params) {
+    const agent = params.agent ?? "subagent";
+    const task = params.task ?? "";
+    return {
+        content: [{ type: "text", text: task }],
+        details: {
+            mode: "single",
+            ...(params.context ? { context: params.context } : {}),
+            results: [createPlaceholderResult(agent, task, "running")],
+            progress: [{
+                    index: 0,
+                    agent,
+                    status: "running",
+                    task,
+                    recentTools: [],
+                    recentOutput: [],
+                    toolCount: 0,
+                    tokens: 0,
+                    durationMs: 0,
+                }],
+        },
+    };
+}
+export function buildSlashInitialResult(requestId, params) {
+    const result = (params.tasks?.length ?? 0) > 0
+        ? buildParallelInitialResult(params)
+        : (params.chain?.length ?? 0) > 0
+            ? buildChainInitialResult(params)
+            : buildSingleInitialResult(params);
+    liveSnapshots.set(requestId, { result, version: nextVersion() });
+    finalSnapshots.delete(requestId);
+    return { requestId, result };
+}
+function cloneResultsWithProgress(results, progress) {
+    return results.map((result, index) => {
+        const nextProgress = progress?.find((entry) => entry.index === index)
+            ?? progress?.[index]
+            ?? result.progress;
+        return nextProgress ? { ...result, progress: nextProgress } : result;
+    });
+}
+export function applySlashUpdate(requestId, update) {
+    const snapshot = liveSnapshots.get(requestId);
+    if (!snapshot)
+        return;
+    const progress = update.progress;
+    if (!progress || !snapshot.result.details)
+        return;
+    const currentStepIndex = progress.findIndex((entry) => entry.status === "running");
+    const nextDetails = {
+        ...snapshot.result.details,
+        progress,
+        results: cloneResultsWithProgress(snapshot.result.details.results, progress),
+        ...(snapshot.result.details.mode === "chain" && currentStepIndex >= 0 ? { currentStepIndex } : {}),
+    };
+    liveSnapshots.set(requestId, {
+        result: {
+            ...snapshot.result,
+            details: nextDetails,
+        },
+        version: nextVersion(),
+    });
+}
+export function finalizeSlashResult(response) {
+    const snapshot = {
+        result: response.result,
+        version: nextVersion(),
+    };
+    finalSnapshots.set(response.requestId, snapshot);
+    liveSnapshots.delete(response.requestId);
+    return {
+        requestId: response.requestId,
+        result: response.result,
+    };
+}
+export function failSlashResult(requestId, params, message) {
+    const initial = buildSlashInitialResult(requestId, params).result;
+    const failedResults = initial.details.results.map((result) => ({
+        ...result,
+        exitCode: 1,
+        error: message,
+        progress: result.progress ? { ...result.progress, status: "failed" } : result.progress,
+    }));
+    const result = {
+        content: [{ type: "text", text: message }],
+        details: {
+            ...initial.details,
+            results: failedResults,
+            progress: failedResults.map((entry) => entry.progress).filter(Boolean),
+        },
+    };
+    const snapshot = { result, version: nextVersion() };
+    finalSnapshots.set(requestId, snapshot);
+    liveSnapshots.delete(requestId);
+    return { requestId, result };
+}
+function isSlashMessageDetails(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const v = value;
+    if (typeof v.requestId !== "string" || !v.requestId)
+        return false;
+    if (!v.result || !Array.isArray(v.result.content))
+        return false;
+    return !!v.result.details && Array.isArray(v.result.details.results);
+}
+export function resolveSlashMessageDetails(value) {
+    return isSlashMessageDetails(value) ? value : undefined;
+}
+export function getSlashRenderableSnapshot(details) {
+    return finalSnapshots.get(details.requestId)
+        ?? liveSnapshots.get(details.requestId)
+        ?? { result: details.result, version: 0 };
+}
+export function restoreSlashFinalSnapshots(entries) {
+    liveSnapshots.clear();
+    finalSnapshots.clear();
+    for (const entry of entries) {
+        const e = entry;
+        if (e?.type !== "custom_message" || e.customType !== SLASH_RESULT_TYPE)
+            continue;
+        const details = resolveSlashMessageDetails(e.details);
+        if (!details)
+            continue;
+        finalSnapshots.set(details.requestId, { result: details.result, version: nextVersion() });
+    }
+}
+export function clearSlashSnapshots() {
+    liveSnapshots.clear();
+    finalSnapshots.clear();
+}

package/dist/tui/action-hints.js

@@ -0,0 +1,75 @@
+import { rawKeyHint } from "@earendil-works/pi-coding-agent";
+import { MouseRegion, Text, stripTerminalSequences, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+/** Native custom messages expose global expansion, but need their own per-message click state. */
+export function withMouseExpansion(renderer) {
+    const states = new WeakMap();
+    return (message, options, theme) => {
+        let state = states.get(message);
+        if (!state || state.globalExpanded !== options.expanded) {
+            state = { expanded: options.expanded, globalExpanded: options.expanded };
+            states.set(message, state);
+        }
+        const expansion = state;
+        const draw = () => renderer(message, { ...options, expanded: expansion.expanded }, theme);
+        let content = draw();
+        if (!content)
+            return;
+        return new MouseRegion({ render: (width) => content?.render(width) ?? [], invalidate: () => content?.invalidate() }, (event) => {
+            if (event.type !== "click" || event.button !== "left")
+                return;
+            expansion.expanded = !expansion.expanded;
+            content = draw();
+            return { handled: true };
+        });
+    };
+}
+/** Declare action spans while building text; native Text owns wrapping and clipping. */
+export function actionHints(parts, style = (text) => text, ellipsis) {
+    let text = "", source = "";
+    const ranges = [];
+    for (const part of parts) {
+        const displayed = typeof part === "string" ? part : part.text.replace(/\balt\+/gi, (key) => stripTerminalSequences(rawKeyHint(key, "")).trim());
+        const plain = stripTerminalSequences(displayed).replace(/\t/g, "   ");
+        if (typeof part !== "string")
+            ranges.push({ start: source.length, length: plain.length, run: part.run });
+        text += displayed;
+        source += plain;
+    }
+    text = style(text);
+    const content = new Text("", 0, 0);
+    let hits = [];
+    return new MouseRegion({
+        invalidate() { content.invalidate(); hits = []; },
+        render(width) {
+            const clipped = ellipsis !== undefined && visibleWidth(text) > width;
+            content.setText(ellipsis === undefined ? text : truncateToWidth(text, width, ellipsis));
+            const lines = content.render(width);
+            hits = [];
+            let offset = 0;
+            for (const [row, line] of lines.entries()) {
+                const visible = stripTerminalSequences(line).trimEnd();
+                const shown = clipped ? visible.slice(0, Math.max(0, visible.length - ellipsis.length)) : visible;
+                const from = source.indexOf(shown, offset);
+                if (!shown || from < 0)
+                    continue;
+                const to = from + shown.length;
+                for (const range of ranges) {
+                    const start = Math.max(from, range.start), end = Math.min(to, range.start + range.length);
+                    if (start < end)
+                        hits.push({ row, start: visibleWidth(shown.slice(0, start - from)), end: visibleWidth(shown.slice(0, end - from)), run: range.run });
+                }
+                offset = to;
+            }
+            return lines;
+        },
+    }, (event) => {
+        if (event.button !== "left" || (event.type !== "press" && event.type !== "click"))
+            return;
+        const hit = hits.find((hit) => hit.row === event.y && event.x >= hit.start && event.x < hit.end);
+        if (!hit)
+            return;
+        if (event.type === "click")
+            hit.run();
+        return { handled: true };
+    });
+}

package/dist/tui/agent-history.js

@@ -0,0 +1,197 @@
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+import { stripAcceptanceReport } from "../runs/shared/acceptance-reports.js";
+import { extractToolArgsPreview } from "../shared/utils.js";
+export function readableText(value) {
+    return stripTerminalSequences(typeof value === "string" ? value : JSON.stringify(value, null, 2) ?? "");
+}
+function contentText(content) {
+    if (typeof content === "string")
+        return readableText(content);
+    if (!Array.isArray(content))
+        return readableText(content);
+    return content.map((part) => part.type === "text" ? readableText(part.text)
+        : part.type === "thinking" ? readableText(part.thinking)
+            : part.type === "image" ? `[Image: ${part.mimeType ?? "image"}]` : "").filter(Boolean).join("\n");
+}
+function resultDisplay(result, call) {
+    const details = result.details;
+    return { text: contentText(result.content), diff: typeof details?.diff === "string" ? readableText(details.diff) : undefined,
+        details: readableText({ ...(call ? { call } : {}), result }) };
+}
+/** Keep reading/delivery facts eager; format bodies and raw tool details only when displayed. */
+function historyItem(facts, format) {
+    let display;
+    return {
+        ...facts,
+        get title() { return (display ??= format()).title; },
+        get text() { return (display ??= format()).text; },
+        get details() { return (display ??= format()).details; },
+        get diff() { return (display ??= format()).diff; },
+    };
+}
+/** Read the native entries, not a compacted model context: earlier messages remain inspectable. */
+export function historyItems(entries) {
+    const items = [], entryIds = [];
+    const calls = new Map();
+    const append = (item) => { items.push(item); entryIds.push(item.id); };
+    for (const entry of entries) {
+        const base = { id: entry.id, timestamp: Date.parse(entry.timestamp) };
+        if (entry.type === "custom_message") {
+            const details = entry.details;
+            const human = entry.customType === "subagent-human-message";
+            append(historyItem({ ...base, kind: human ? "user" : "notice", ...(human ? { messageId: details?.message?.id } : {}) }, () => ({ title: human ? "User · delivered to conversation" : details?.from?.name ? `From ${details.from.name}` : entry.customType, text: contentText(details?.bodyText ?? entry.content) })));
+        }
+        else if (entry.type === "compaction") {
+            append(historyItem({ ...base, kind: "notice" }, () => ({ title: "Context summary · earlier history retained above", text: readableText(entry.summary) })));
+        }
+        else if (entry.type === "branch_summary") {
+            append(historyItem({ ...base, kind: "notice" }, () => ({ title: "Branch summary", text: readableText(entry.summary) })));
+        }
+        else if (entry.type === "message") {
+            const message = entry.message;
+            if (message.role === "assistant") {
+                const model = message.model ? (message.provider ? `${message.provider}/${message.model}` : message.model) : undefined;
+                const messageIds = message.content.flatMap((part, index) => part.type === "text" && part.text || part.type === "thinking" && part.thinking ? [`${entry.id}:${index}`] : []);
+                if (messageIds.length)
+                    items.push(historyItem({ ...base, id: messageIds[0], entryIds: messageIds,
+                        kind: message.content.some((part) => part.type === "text" && part.text) ? "assistant" : "thinking",
+                        assistant: message, model }, () => ({ title: "Agent", text: contentText(message.content) })));
+                for (const [index, part] of message.content.entries()) {
+                    const id = `${entry.id}:${index}`;
+                    if (part.type === "toolCall") {
+                        const item = historyItem({ ...base, id, entryIds: [id], kind: "tool", call: part, model }, () => ({
+                            title: `${part.name} ${extractToolArgsPreview(part.arguments ?? {})}`.trim() + (item.result ? ` · ${item.result.isError ? "failed" : "result recorded"}` : " · result not recorded"),
+                            ...(item.result ? resultDisplay(item.result, part) : {
+                                text: readableText(part.arguments),
+                                details: `${readableText(part)}\n\nCommand result not recorded; exit is unconfirmed. An agent pause or exit does not prove that a command or its descendants exited.`,
+                            }),
+                        }));
+                        append(item);
+                        calls.set(part.id, item);
+                    }
+                    else if (messageIds.includes(id))
+                        entryIds.push(id);
+                }
+                if (message.errorMessage) {
+                    const id = `${entry.id}:error`;
+                    if (messageIds.length && !message.content.some((part) => part.type === "toolCall") && ["error", "aborted"].includes(message.stopReason)) {
+                        messageIds.push(id);
+                        entryIds.push(id);
+                    }
+                    else
+                        append(historyItem({ ...base, id, kind: "notice", model }, () => ({ title: "Agent error", text: readableText(message.errorMessage) })));
+                }
+            }
+            else if (message.role === "user") {
+                append(historyItem({ ...base, kind: "user" }, () => ({ title: "User / assignment", text: contentText(message.content) })));
+            }
+            else if (message.role === "toolResult") {
+                const call = calls.get(message.toolCallId);
+                if (call) {
+                    call.result = message;
+                    call.entryIds.push(entry.id);
+                    entryIds.push(entry.id);
+                }
+                else
+                    append(historyItem({ ...base, result: message, kind: "result" }, () => ({
+                        title: `${message.toolName} · call not recorded`, ...resultDisplay(message),
+                    })));
+            }
+            else if (message.role === "bashExecution") {
+                append(historyItem({ ...base, kind: "tool" }, () => ({ title: `Shell: ${readableText(message.command)}`, text: `${readableText(message.output)}\n${typeof message.exitCode === "number" ? `Shell exit code: ${message.exitCode}` : "Shell exit code not recorded"}${message.cancelled ? " · cancelled" : ""}`, details: readableText({ command: message.command, exitCode: message.exitCode, cancelled: message.cancelled }) })));
+            }
+        }
+    }
+    let finalResults;
+    return { items, entryIds, findFinalResult(text) {
+            // Continuations can share a large journal. Index exact, sanitized matches once,
+            // retaining the latest assistant ID just as findLast does.
+            if (!finalResults) {
+                finalResults = new Map();
+                for (const item of items)
+                    if (item.kind === "assistant") {
+                        finalResults.set(stripAcceptanceReport(item.text).trim(), item.id);
+                        for (const part of item.assistant?.content ?? [])
+                            if (part.type === "text")
+                                finalResults.set(stripAcceptanceReport(readableText(part.text)).trim(), item.id);
+                    }
+            }
+            return finalResults.get(text);
+        } };
+}
+/** Canonical run output is already validated; never decode arbitrary tool JSON to find an answer. */
+export function withFinalResult(history, output, runId, timestamp) {
+    const text = readableText(output).trim();
+    if (!text)
+        return history;
+    const matched = history.finalId ?? (history.findFinalResult ? history.findFinalResult(text) : history.items.findLast((item) => item.kind === "assistant" && (stripAcceptanceReport(item.text).trim() === text
+        || item.assistant?.content.some((part) => part.type === "text" && stripAcceptanceReport(readableText(part.text)).trim() === text)))?.id);
+    const existing = history.items.some((item) => item.id === matched) ? matched : undefined;
+    const id = `result:${runId}`;
+    let items;
+    return { get items() { return items ??= existing ? history.items.map((item) => item.id === existing ? { ...item, assistant: undefined, text } : item) : [...history.items, { id, kind: "assistant", title: "Saved result", text, timestamp }]; },
+        entryIds: existing ? history.entryIds : [...history.entryIds, id], finalId: existing ?? id,
+        findFinalResult: existing ? history.findFinalResult : (value) => value === text ? id : history.findFinalResult?.(value),
+        deliveredMessages: existing ? history.deliveredMessages : history.deliveredMessages && new Map([...history.deliveredMessages.keys()].map((id) => [id, true])),
+        configuration: history.configuration, get unavailable() { return history.unavailable; } };
+}
+/** A page retains only bounded previews; full selected records are validated by the process. */
+export async function indexedHistory(index, input) {
+    const page = await index.historyPage(input);
+    const entries = new Map(page.entries.map((entry) => [entry.id, entry]));
+    const boundary = { terminalEntryId: input.terminalEntryId, endedAt: input.endedAt };
+    if (input.terminalEntryId && page.terminalSequence === undefined)
+        throw new Error("Saved terminal entry is unavailable; retry history.");
+    const inBoundary = (entry) => (page.terminalSequence === undefined || entry.sequence <= page.terminalSequence) && (input.endedAt === undefined || (entry.timestamp ?? Infinity) <= input.endedAt);
+    const tools = new Map();
+    for (const entry of page.entries) {
+        const message = entry.entry.message;
+        if (message?.role === "assistant")
+            for (const part of message.content ?? []) {
+                if (part.type === "toolCall")
+                    tools.set(part.id, { ...tools.get(part.id), call: entry });
+            }
+        else if (message?.role === "toolResult")
+            tools.set(message.toolCallId, { ...tools.get(message.toolCallId), result: entry });
+    }
+    // Resolve only tools on this page, not the rest of the conversation. Adjacent-page
+    // pairing preserves physical reading order and never becomes completion evidence.
+    for (const entry of page.entries) {
+        const message = entry.entry.message;
+        const pairs = message?.role === "assistant" ? (message.content ?? []).filter((part) => part.type === "toolCall").map((part) => ({ toolCallId: part.id, kind: "result" }))
+            : message?.role === "toolResult" ? [{ toolCallId: message.toolCallId, kind: "call" }] : [];
+        for (const pair of pairs) {
+            const paired = tools.get(pair.toolCallId)?.[pair.kind] ?? await index.entry({ runId: input.runId, index: input.index, ...pair, ...boundary, signal: input.signal });
+            if (paired && inBoundary(paired))
+                entries.set(paired.id, paired);
+        }
+    }
+    const history = historyItems([...entries.values()].sort((a, b) => a.sequence - b.sequence).map((entry) => entry.entry));
+    const visible = new Set(page.entries.map((entry) => entry.id));
+    history.items = history.items.filter((item) => (item.entryIds ?? [item.id]).some((id) => visible.has(id.split(":")[0])));
+    // Only page-local IDs advance the read marker; paired records can live elsewhere.
+    history.entryIds = history.entryIds.filter((id) => visible.has(id.split(":")[0]));
+    history.unavailable = page.unavailable;
+    history.configuration = page.configuration;
+    history.deliveredMessages = new Map(page.deliveredMessages);
+    history.finalId = page.finalResultId;
+    for (const item of history.items)
+        item.load = async () => {
+            const ids = new Set((item.entryIds ?? [item.id]).map((id) => id.split(":")[0]));
+            const full = [];
+            for (const id of ids) {
+                const entry = entries.get(id);
+                if (!entry)
+                    throw new Error("Selected native entry is unavailable; retry history.");
+                const record = await index.record({ runId: input.runId, index: input.index, ref: entry.ref, ...boundary, signal: input.signal });
+                if (!record)
+                    throw new Error("Selected native entry is unavailable; retry history.");
+                full.push({ ...record, id });
+            }
+            const detail = historyItems(full).items.find((candidate) => candidate.id === item.id);
+            if (!detail)
+                throw new Error("Selected native entry is unavailable; retry history.");
+            return detail;
+        };
+    return { history, page };
+}