@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/tui/history-cards.js

@@ -1,202 +0,0 @@
-import { isDeepStrictEqual } from "node:util";
-import { AssistantMessageComponent, UserMessageComponent, ToolExecutionComponent, createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createPowerShellToolDefinition, createReadToolDefinition, createWriteToolDefinition, getMarkdownTheme, renderDiff, } from "@earendil-works/pi-coding-agent";
-import { Container, Spacer, Text, } from "@earendil-works/pi-tui";
-import { formatModelThinking } from "../shared/formatters.js";
-import { stripAcceptanceReport } from "../runs/shared/acceptance-reports.js";
-import { readableText } from "./agent-history.js";
-import { short } from "./view-model.js";
-import { hasText } from "./text-values.js";
-function sameDisplay(left, right) {
-    // Detail loaders stay fresh in contentItems; only the native display component is reused.
-    return isDeepStrictEqual({ ...left, load: undefined }, { ...right, load: undefined });
-}
-function previewStop(reason) {
-    if (reason === "error" || reason === "aborted" || reason === "length") {
-        return reason;
-    }
-    return "stop";
-}
-/** Bounded previews/live text are native display adapters only, never journal or completion evidence. */
-function assistantDisplay(item) {
-    if (item.assistant) {
-        return item.assistant;
-    }
-    const preview = item.previewAssistant;
-    return {
-        role: "assistant",
-        content: preview ? [...preview.content] : [{ type: "text", text: item.text }],
-        timestamp: item.timestamp,
-        api: "",
-        provider: "",
-        model: "",
-        stopReason: previewStop(preview?.stopReason),
-        errorMessage: preview?.errorMessage,
-        usage: {
-            input: 0,
-            output: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            totalTokens: 0,
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-        },
-    };
-}
-function sanitizedMessage(message) {
-    return {
-        ...message,
-        content: message.content.map((part) => part.type === "text"
-            ? { ...part, text: stripAcceptanceReport(readableText(part.text)) }
-            : part),
-    };
-}
-/** Native cards and width-dependent line locations have one cache owner. */
-export class HistoryCards {
-    lines = [];
-    contentItems = [];
-    components = new Map();
-    toolDefinitions;
-    tui;
-    theme;
-    cwd;
-    constructor(tui, theme, cwd) {
-        this.tui = tui;
-        this.theme = theme;
-        this.cwd = cwd;
-        this.toolDefinitions = new Map([
-            createReadToolDefinition,
-            createBashToolDefinition,
-            createEditToolDefinition,
-            createWriteToolDefinition,
-            createFindToolDefinition,
-            createGrepToolDefinition,
-            createLsToolDefinition,
-            createPowerShellToolDefinition,
-        ].map((create) => {
-            const definition = create(cwd());
-            return [definition.name, definition];
-        }));
-    }
-    clear() {
-        this.components.clear();
-    }
-    dispatch(id, event) {
-        this.components.get(id)?.component.handleMouse?.(event);
-    }
-    prune(items) {
-        const ids = new Set(items.map((item) => item.id));
-        for (const id of this.components.keys()) {
-            if (!ids.has(id)) {
-                this.components.delete(id);
-            }
-        }
-    }
-    render(width, items, options) {
-        this.contentItems = items;
-        this.prune(items);
-        this.lines = [];
-        const lines = [];
-        for (const item of items) {
-            const expanded = options.detail || (options.toolExpansion.get(item.id) ?? options.toolsExpanded);
-            const component = this.card(item, expanded, options.detail), start = lines.length;
-            if (item.id === options.selectedId && !options.editorFocus) {
-                lines.push(this.theme.fg("accent", short(`› ${item.title}`, width)));
-            }
-            const contentStart = lines.length;
-            lines.push(...component.render(width));
-            this.lines.push({
-                id: item.id,
-                entryIds: item.entryIds ?? [item.id],
-                start,
-                contentStart,
-                end: lines.length,
-            });
-        }
-        return lines;
-    }
-    card(item, expanded, detail) {
-        const signature = `${expanded}:${detail}`, cached = this.components.get(item.id);
-        if (cached?.signature === signature && cached.item === item) {
-            return cached.component;
-        }
-        if (cached?.signature === signature && sameDisplay(cached.item, item)) {
-            this.components.set(item.id, { ...cached, item });
-            return cached.component;
-        }
-        const component = this.create(item, { expanded, detail });
-        this.components.set(item.id, { signature, item, component });
-        return component;
-    }
-    create(item, presentation) {
-        const c = new Container();
-        if (presentation.detail && hasText(item.model)) {
-            c.addChild(new Text(this.theme.fg("muted", `Message model: ${readableText(formatModelThinking(item.model))}`), 0, 0));
-        }
-        c.addChild(this.body(item, presentation));
-        if (presentation.detail && hasText(item.details)) {
-            c.addChild(new Text(item.details, 0, 1));
-        }
-        c.addChild(new Spacer(1));
-        return c;
-    }
-    body(item, presentation) {
-        if (item.call || item.result) {
-            return this.tool(item, presentation);
-        }
-        if (item.kind === "assistant" || item.kind === "thinking") {
-            const message = assistantDisplay(item);
-            return new AssistantMessageComponent(presentation.detail ? message : sanitizedMessage(message), !presentation.detail, getMarkdownTheme(), "Thinking · open details to read");
-        }
-        if (item.kind === "user") {
-            return this.user(item);
-        }
-        const c = new Container();
-        c.addChild(new Text(this.theme.fg("muted", readableText(item.title)), 0, 0));
-        c.addChild(new Text(item.text, 0, 0));
-        if (hasText(item.diff)) {
-            c.addChild(new Text(renderDiff(item.diff), 0, 0));
-        }
-        return c;
-    }
-    user(item) {
-        const c = new Container();
-        if (item.id.startsWith("outgoing:") || hasText(item.messageId)) {
-            c.addChild(new Text(this.theme.fg("muted", item.title), 0, 0));
-        }
-        c.addChild(new UserMessageComponent(item.text, getMarkdownTheme(), 1));
-        return c;
-    }
-    nativeTool(item) {
-        const fallback = {
-            renderCall: () => new Text(this.theme.fg("toolTitle", this.theme.bold(readableText(item.title))), 0, 0),
-        };
-        const options = { compactView: true, showImages: false };
-        if (item.call) {
-            const call = item.call;
-            return new ToolExecutionComponent(call.name, call.id, call.arguments, options, this.toolDefinitions.get(call.name) ?? fallback, this.tui, this.cwd());
-        }
-        if (item.result) {
-            const result = item.result;
-            return new ToolExecutionComponent(result.toolName, result.toolCallId, {}, options, fallback, this.tui, this.cwd());
-        }
-        return;
-    }
-    tool(item, presentation) {
-        const c = new Container(), result = item.result, tool = this.nativeTool(item);
-        if (!tool) {
-            return c;
-        }
-        // Saved data only: execution/args-complete hooks would invent timing or re-read today's files.
-        if (result) {
-            tool.updateResult(result);
-        }
-        tool.setExpanded(presentation.expanded);
-        c.addChild(tool);
-        if (presentation.detail && hasText(item.diff) && item.call?.name !== "edit") {
-            c.addChild(new Text(renderDiff(item.diff), 0, 0));
-        }
-        if (!result) {
-            c.addChild(new Text(this.theme.fg("dim", "Result not recorded · exit unconfirmed"), 1, 0));
-        }
-        return c;
-    }
-}

package/dist/tui/history-display.js

@@ -1,238 +0,0 @@
-import { hasText } from "./text-values.js";
-import { readableText, contentText, isRecord } from "./history-text.js";
-import { stripAcceptanceReport } from "../runs/shared/acceptance-reports.js";
-import { extractToolArgsPreview } from "../shared/utils.js";
-function inlineAssistantError(message) {
-    return (!message.content.some((part) => part.type === "toolCall") &&
-        ["error", "aborted"].includes(message.stopReason ?? ""));
-}
-function messageModel(message) {
-    if (!hasText(message.model)) {
-        return;
-    }
-    return hasText(message.provider) ? `${message.provider}/${message.model}` : message.model;
-}
-function customTitle(human, from, customType) {
-    if (human) {
-        return "User · delivered to conversation";
-    }
-    return typeof from === "string" && from.length > 0 ? `From ${from}` : customType;
-}
-function resultDisplay(result, call) {
-    const details = result.details;
-    return {
-        text: contentText(result.content),
-        diff: isRecord(details) && typeof details.diff === "string"
-            ? readableText(details.diff)
-            : undefined,
-        details: readableText({ ...(call ? { call } : {}), result }),
-    };
-}
-function lazyItem(facts, format, resultReader) {
-    let display;
-    const get = () => {
-        display ??= format();
-        return display;
-    };
-    return {
-        ...facts,
-        get result() {
-            return resultReader?.() ?? facts.result;
-        },
-        get title() {
-            return get().title;
-        },
-        get text() {
-            return get().text;
-        },
-        get details() {
-            return get().details;
-        },
-        get diff() {
-            return get().diff;
-        },
-    };
-}
-/** The builder owns pairing; public cards expose getters, not mutable shared snapshots. */
-class NativeHistoryBuilder {
-    items = [];
-    entryIds = [];
-    calls = new Map();
-    append(item) {
-        this.items.push(item);
-        this.entryIds.push(item.id);
-    }
-    add(entry) {
-        const base = { id: entry.id, timestamp: Date.parse(entry.timestamp) };
-        switch (entry.type) {
-            case "custom_message": {
-                const details = entry.details, human = entry.customType === "subagent-human-message";
-                const body = isRecord(details) ? details.bodyText : undefined;
-                const from = isRecord(details) && isRecord(details.from) ? details.from.name : undefined;
-                const message = isRecord(details) && isRecord(details.message) ? details.message.id : undefined;
-                this.append(lazyItem({
-                    ...base,
-                    kind: human ? "user" : "notice",
-                    messageId: human && typeof message === "string" ? message : undefined,
-                }, () => ({
-                    title: customTitle(human, from, entry.customType),
-                    text: contentText(body ?? entry.content),
-                })));
-                break;
-            }
-            case "compaction":
-                this.append(lazyItem({ ...base, kind: "notice" }, () => ({
-                    title: "Context summary · earlier history retained above",
-                    text: readableText(entry.summary),
-                })));
-                break;
-            case "branch_summary":
-                this.append(lazyItem({ ...base, kind: "notice" }, () => ({
-                    title: "Branch summary",
-                    text: readableText(entry.summary),
-                })));
-                break;
-            case "message":
-                this.message(entry);
-                break;
-        }
-    }
-    message(entry) {
-        const message = entry.message, base = { id: entry.id, timestamp: Date.parse(entry.timestamp) };
-        switch (message.role) {
-            case "assistant":
-                this.assistant(entry.id, base.timestamp, message, entry.native?.role === "assistant" ? entry.native : undefined);
-                break;
-            case "user":
-                this.append(lazyItem({ ...base, kind: "user" }, () => ({
-                    title: "User / assignment",
-                    text: contentText(message.content),
-                })));
-                break;
-            case "toolResult": {
-                const pair = this.calls.get(message.toolCallId);
-                if (pair) {
-                    pair.result = message;
-                    pair.entryIds.push(entry.id);
-                    this.entryIds.push(entry.id);
-                }
-                else {
-                    this.append(lazyItem({ ...base, result: message, kind: "result" }, () => ({
-                        title: `${message.toolName} · call not recorded`,
-                        ...resultDisplay(message),
-                    })));
-                }
-                break;
-            }
-            case "bashExecution":
-                this.append(lazyItem({ ...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,
-                    }),
-                })));
-                break;
-            case "custom":
-            case "branchSummary":
-            case "compactionSummary":
-            case "system":
-                break;
-        }
-    }
-    assistant(entryId, timestamp, message, native) {
-        const model = messageModel(message);
-        const ids = message.content.flatMap((part, index) => (part.type === "text" && part.text.length > 0) ||
-            (part.type === "thinking" && part.thinking.length > 0)
-            ? [`${entryId}:${index}`]
-            : []);
-        const first = ids.at(0);
-        if (first !== undefined) {
-            this.items.push(assistantGroup(message, { id: first, timestamp, entryIds: ids, model, native }));
-        }
-        for (const [index, part] of message.content.entries()) {
-            const id = `${entryId}:${index}`;
-            if (part.type === "toolCall") {
-                this.tool(id, timestamp, part, model);
-            }
-            else if (ids.includes(id)) {
-                this.entryIds.push(id);
-            }
-        }
-        if (message.errorMessage !== undefined && message.errorMessage.length > 0) {
-            const id = `${entryId}:error`;
-            if (ids.length > 0 && inlineAssistantError(message)) {
-                ids.push(id);
-                this.entryIds.push(id);
-            }
-            else {
-                this.append(lazyItem({ id, timestamp, kind: "notice", model }, () => ({
-                    title: "Agent error",
-                    text: readableText(message.errorMessage),
-                })));
-            }
-        }
-    }
-    tool(id, timestamp, call, model) {
-        const pair = { entryIds: [id] };
-        const display = () => ({
-            title: `${call.name} ${extractToolArgsPreview(call.arguments)}`.trim() +
-                (pair.result
-                    ? ` · ${pair.result.isError ? "failed" : "result recorded"}`
-                    : " · result not recorded"),
-            ...(pair.result
-                ? resultDisplay(pair.result, call)
-                : {
-                    text: readableText(call.arguments),
-                    details: `${readableText(call)}\n\nCommand result not recorded; exit is unconfirmed. An agent pause or exit does not prove that a command or its descendants exited.`,
-                }),
-        });
-        this.append(lazyItem({ id, timestamp, entryIds: pair.entryIds, kind: "tool", call, model }, display, () => pair.result));
-        this.calls.set(call.id, pair);
-    }
-}
-function assistantGroup(message, facts) {
-    return lazyItem({
-        id: facts.id,
-        timestamp: facts.timestamp,
-        entryIds: facts.entryIds,
-        kind: message.content.some((part) => part.type === "text" && part.text.length > 0)
-            ? "assistant"
-            : "thinking",
-        assistant: facts.native,
-        previewAssistant: facts.native ? undefined : message,
-        model: facts.model,
-    }, () => ({ title: "Agent", text: contentText(message.content) }));
-}
-function finalResultMap(items) {
-    const results = new Map();
-    for (const item of items) {
-        if (item.kind !== "assistant") {
-            continue;
-        }
-        results.set(stripAcceptanceReport(item.text).trim(), item.id);
-        for (const part of item.assistant?.content ?? []) {
-            if (part.type === "text") {
-                results.set(stripAcceptanceReport(readableText(part.text)).trim(), item.id);
-            }
-        }
-    }
-    return results;
-}
-export function displayHistory(entries) {
-    const builder = new NativeHistoryBuilder();
-    for (const entry of entries) {
-        builder.add(entry);
-    }
-    let finalResults;
-    return {
-        items: builder.items,
-        entryIds: builder.entryIds,
-        findFinalResult(text) {
-            finalResults ??= finalResultMap(builder.items);
-            return finalResults.get(text);
-        },
-    };
-}

package/dist/tui/history-json.js

@@ -1,16 +0,0 @@
-import { isRecord } from "./history-text.js";
-export function isJson(value) {
-    if (value === null || typeof value === "string" || typeof value === "boolean") {
-        return true;
-    }
-    if (typeof value === "number") {
-        return Number.isFinite(value);
-    }
-    if (Array.isArray(value)) {
-        return value.every((part) => isJson(part));
-    }
-    return isJsonObject(value);
-}
-export function isJsonObject(value) {
-    return isRecord(value) && Object.values(value).every(isJson);
-}

package/dist/tui/history-metadata.js

@@ -1,152 +0,0 @@
-import { Type, Check } from "../shared/native-typebox.js";
-import { THINKING_LEVELS } from "../shared/model-info.js";
-import { isJson, isJsonObject } from "./history-json.js";
-const cost = Type.Object({
-    input: Type.Number(),
-    output: Type.Number(),
-    cacheRead: Type.Number(),
-    cacheWrite: Type.Number(),
-    total: Type.Number(),
-});
-export const usageSchema = Type.Object({
-    input: Type.Number(),
-    output: Type.Number(),
-    cacheRead: Type.Number(),
-    cacheWrite: Type.Number(),
-    totalTokens: Type.Number(),
-    cost,
-    cacheWrite1h: Type.Optional(Type.Number()),
-    reasoning: Type.Optional(Type.Number()),
-});
-export function nativeUsage(value) {
-    return Check(usageSchema, value) ? { ...value, cost: { ...value.cost } } : undefined;
-}
-const nestedCallFields = Type.Object({
-    id: Type.String(),
-    name: Type.String(),
-    arguments: Type.Optional(Type.Unknown()),
-    argumentsBytes: Type.Optional(Type.Number()),
-    status: Type.Union([Type.Literal("ok"), Type.Literal("error"), Type.Literal("unfinished")]),
-    durationMs: Type.Optional(Type.Number()),
-    error: Type.Optional(Type.String()),
-});
-function nestedCall(value) {
-    if (!Check(nestedCallFields, value)) {
-        return;
-    }
-    const { arguments: args, ...fields } = value;
-    if (args !== undefined && !isJsonObject(args)) {
-        return;
-    }
-    return { ...fields, ...("arguments" in value ? { arguments: args } : {}) };
-}
-const nestedCallsFields = Type.Object({
-    calls: Type.Array(Type.Unknown()),
-    complete: Type.Boolean(),
-});
-export function nativeNestedCalls(value) {
-    if (!Check(nestedCallsFields, value)) {
-        return;
-    }
-    const calls = [];
-    for (const part of value.calls) {
-        const call = nestedCall(part);
-        if (!call) {
-            return;
-        }
-        calls.push(call);
-    }
-    return { calls, complete: value.complete };
-}
-const deferredFields = Type.Object({
-    provider: Type.String(),
-    modelId: Type.String(),
-    api: Type.String(),
-    id: Type.String(),
-    expiresAt: Type.Optional(Type.Number()),
-    pollAfterMs: Type.Optional(Type.Number()),
-    data: Type.Optional(Type.Unknown()),
-});
-function deferred(value) {
-    if (!Check(deferredFields, value)) {
-        return;
-    }
-    const { data, ...fields } = value;
-    if (data !== undefined && !isJson(data)) {
-        return;
-    }
-    return { ...fields, ...("data" in value ? { data } : {}) };
-}
-const diagnosticFields = Type.Object({
-    type: Type.String(),
-    timestamp: Type.Number(),
-    error: Type.Optional(Type.Object({
-        name: Type.Optional(Type.String()),
-        message: Type.String(),
-        stack: Type.Optional(Type.String()),
-        code: Type.Optional(Type.Union([Type.String(), Type.Number()])),
-    })),
-    details: Type.Optional(Type.Unknown()),
-});
-function diagnostic(value) {
-    if (!Check(diagnosticFields, value)) {
-        return;
-    }
-    const { details, ...fields } = value;
-    if (details !== undefined && !isJsonObject(details)) {
-        return;
-    }
-    return { ...fields, ...("details" in value ? { details } : {}) };
-}
-function diagnostics(value) {
-    if (!Array.isArray(value)) {
-        return;
-    }
-    const parsed = [];
-    for (const part of value) {
-        const item = diagnostic(part);
-        if (!item) {
-            return;
-        }
-        parsed.push(item);
-    }
-    return parsed;
-}
-const metadataFields = Type.Object({
-    responseModel: Type.Optional(Type.String()),
-    responseId: Type.Optional(Type.String()),
-    providerThinkingLevel: Type.Optional(Type.String()),
-    thinkingLevel: Type.Optional(Type.Union(THINKING_LEVELS.map((level) => Type.Literal(level)))),
-    rawStopReason: Type.Optional(Type.String()),
-    endTurn: Type.Optional(Type.Boolean()),
-});
-function scalarMetadata(value) {
-    if (!Check(metadataFields, value)) {
-        return;
-    }
-    return {
-        ...("responseModel" in value ? { responseModel: value.responseModel } : {}),
-        ...("responseId" in value ? { responseId: value.responseId } : {}),
-        ...("providerThinkingLevel" in value
-            ? { providerThinkingLevel: value.providerThinkingLevel }
-            : {}),
-        ...("thinkingLevel" in value ? { thinkingLevel: value.thinkingLevel } : {}),
-        ...("rawStopReason" in value ? { rawStopReason: value.rawStopReason } : {}),
-        ...("endTurn" in value ? { endTurn: value.endTurn } : {}),
-    };
-}
-export function assistantMetadata(value) {
-    const pending = value.deferred, notes = value.diagnostics;
-    const deferredValue = pending === undefined ? undefined : deferred(pending), diagnosticValues = notes === undefined ? undefined : diagnostics(notes);
-    const scalars = scalarMetadata(value);
-    if ((pending !== undefined && deferredValue === undefined) ||
-        (notes !== undefined && diagnosticValues === undefined) ||
-        !scalars) {
-        return;
-    }
-    return {
-        ...scalars,
-        ...("deferred" in value ? { deferred: deferredValue } : {}),
-        ...("diagnostics" in value ? { diagnostics: diagnosticValues } : {}),
-    };
-}