@bdsqqq/pi 0.0.1

package/dist/core/sub-agent-render.d.ts

@@ -0,0 +1,56 @@
+import { UsageStats } from "./pi-spawn.js";
+import { ToolCostDetails } from "./tool-cost.js";
+import { Container } from "@mariozechner/pi-tui";
+import { Message } from "@mariozechner/pi-ai";
+
+//#region packages/core/sub-agent-render/index.d.ts
+type DisplayItem = {
+  type: "text";
+  text: string;
+} | {
+  type: "toolCall";
+  id: string;
+  name: string;
+  args: Record<string, any>;
+  isError?: boolean;
+};
+interface SingleResult {
+  agent: string;
+  task: string;
+  exitCode: number;
+  messages: Message[];
+  usage: UsageStats;
+  model?: string;
+  stopReason?: string;
+  errorMessage?: string;
+}
+declare function getFinalOutput(messages: Message[]): string;
+declare function getDisplayItems(messages: Message[]): DisplayItem[];
+/**
+* build the standard tool result for a piSpawn-based sub-agent.
+* all sub-agent tools should use this instead of constructing
+* return values manually — cost tagging is automatic.
+*/
+declare function subAgentResult(text: string, details: SingleResult, isError?: boolean): {
+  content: {
+    type: "text";
+    text: string;
+  }[];
+  details: SingleResult & ToolCostDetails;
+  isError?: boolean;
+};
+declare function formatUsageStats(usage: {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: number;
+  contextTokens?: number;
+  turns?: number;
+}, model?: string): string;
+declare function renderAgentTree(r: SingleResult, container: Container, showExpanded: boolean, theme: any, labelOrOpts?: string | {
+  label?: string;
+  header?: "full" | "statusOnly";
+}): void;
+//#endregion
+export { DisplayItem, SingleResult, formatUsageStats, getDisplayItems, getFinalOutput, renderAgentTree, subAgentResult };

package/dist/core/sub-agent-render.js

@@ -0,0 +1,579 @@
+import { Markdown, Text, TruncatedText } from "@mariozechner/pi-tui";
+import * as os from "node:os";
+import { getMarkdownTheme } from "@mariozechner/pi-coding-agent";
+//#region packages/core/sub-agent-render/index.ts
+/**
+* rendering utilities for sub-agent tool results.
+*
+* extracts DisplayItem, message parsing, and TUI tree rendering
+* from the generic subagent extension. dedicated tools (finder,
+* oracle, Task) use these for consistent renderResult display.
+*
+* reimplemented here because tools/ can't import from sub-agents/
+* (separate nix store paths).
+*/
+function getFinalOutput(messages) {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg && msg.role === "assistant") {
+			for (const part of msg.content) if (typeof part === "object" && part !== null && "type" in part && part.type === "text") return part.text;
+		}
+	}
+	return "";
+}
+function getDisplayItems(messages) {
+	const errorMap = /* @__PURE__ */ new Map();
+	for (const msg of messages) if (msg.role === "toolResult") errorMap.set(msg.toolCallId, msg.isError);
+	const items = [];
+	for (const msg of messages) if (msg.role === "assistant") {
+		for (const part of msg.content) if (part.type === "text") items.push({
+			type: "text",
+			text: part.text
+		});
+		else if (part.type === "toolCall") items.push({
+			type: "toolCall",
+			id: part.id,
+			name: part.name,
+			args: part.arguments,
+			isError: errorMap.get(part.id)
+		});
+	}
+	return items;
+}
+/**
+* build the standard tool result for a piSpawn-based sub-agent.
+* all sub-agent tools should use this instead of constructing
+* return values manually — cost tagging is automatic.
+*/
+function subAgentResult(text, details, isError = false) {
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {
+			...details,
+			cost: details.usage.cost
+		},
+		...isError && { isError: true }
+	};
+}
+function formatTokens(count) {
+	if (count < 1e3) return count.toString();
+	if (count < 1e4) return `${(count / 1e3).toFixed(1)}k`;
+	if (count < 1e6) return `${Math.round(count / 1e3)}k`;
+	return `${(count / 1e6).toFixed(1)}M`;
+}
+function formatUsageStats(usage, model) {
+	const parts = [];
+	if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
+	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
+	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
+	if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
+	if (usage.cacheWrite) parts.push(`W${formatTokens(usage.cacheWrite)}`);
+	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
+	if (usage.contextTokens && usage.contextTokens > 0) parts.push(`ctx:${formatTokens(usage.contextTokens)}`);
+	if (model) parts.push(model);
+	return parts.join(" ");
+}
+function shortenPath(p) {
+	const home = os.homedir();
+	return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+}
+function toolLabel(name) {
+	return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function toolArgSummary(toolName, args) {
+	switch (toolName) {
+		case "bash": {
+			const command = args.cmd ?? args.command ?? "...";
+			return command.split("\n")[0] ?? command;
+		}
+		case "read": {
+			let text = shortenPath(args.file_path || args.path || "...");
+			const readRange = args.read_range;
+			const offset = args.offset;
+			const limit = args.limit;
+			if (readRange) text += `:${readRange[0]}-${readRange[1]}`;
+			else if (offset !== void 0 || limit !== void 0) {
+				const startLine = offset ?? 1;
+				const endLine = limit !== void 0 ? startLine + limit - 1 : "";
+				text += `:${startLine}${endLine ? `-${endLine}` : ""}`;
+			}
+			return text;
+		}
+		case "write": {
+			const rawPath = args.file_path || args.path || "...";
+			const lines = (args.content || "").split("\n").length;
+			let text = shortenPath(rawPath);
+			if (lines > 1) text += ` (${lines} lines)`;
+			return text;
+		}
+		case "edit": return shortenPath(args.file_path || args.path || "...");
+		case "ls": return shortenPath(args.path || ".");
+		case "find": return `${args.filePattern || args.pattern || "*"} in ${shortenPath(args.path || ".")}`;
+		case "grep": return `/${args.pattern || ""}/ in ${shortenPath(args.path || ".")}`;
+		default: return JSON.stringify(args);
+	}
+}
+function renderToolLine(item, fg) {
+	return `${item.isError === true ? fg("error", "✕") : item.isError === false ? fg("success", "✓") : fg("muted", "⋯")} ${fg("accent", toolLabel(item.name))} ${fg("dim", toolArgSummary(item.name, item.args))}`;
+}
+const COLLAPSED_ITEM_COUNT = 10;
+function renderAgentTree(r, container, showExpanded, theme, labelOrOpts) {
+	const fg = theme.fg.bind(theme);
+	const opts = typeof labelOrOpts === "string" ? {
+		label: labelOrOpts,
+		header: "full"
+	} : {
+		label: labelOrOpts?.label,
+		header: labelOrOpts?.header ?? "full"
+	};
+	const MID = fg("muted", "├── ");
+	const END = fg("muted", "╰── ");
+	const CONT = fg("muted", "│   ");
+	const mdTheme = getMarkdownTheme();
+	const isError = r.exitCode !== 0 || r.stopReason === "error" || r.stopReason === "aborted";
+	const icon = r.exitCode === -1 ? fg("warning", "⋯") : isError ? fg("error", "✕") : fg("success", "✓");
+	if (opts.header === "statusOnly") {
+		let header = icon;
+		if (isError && r.stopReason) header += ` ${fg("error", `[${r.stopReason}]`)}`;
+		container.addChild(new Text(header, 0, 0));
+	} else {
+		let header = `${icon} ${fg("toolTitle", theme.bold(opts.label ?? r.agent))}`;
+		if (isError && r.stopReason) header += ` ${fg("error", `[${r.stopReason}]`)}`;
+		container.addChild(new Text(header, 0, 0));
+	}
+	if (isError && r.errorMessage) container.addChild(new Text(MID + fg("error", `Error: ${r.errorMessage}`), 0, 0));
+	const toolCalls = getDisplayItems(r.messages).filter((d) => d.type === "toolCall");
+	const finalOutput = getFinalOutput(r.messages);
+	const children = [];
+	if (showExpanded) children.push({
+		kind: "text",
+		content: r.task
+	});
+	const visibleTools = showExpanded ? toolCalls : toolCalls.slice(-COLLAPSED_ITEM_COUNT);
+	const skippedTools = showExpanded ? 0 : toolCalls.length - visibleTools.length;
+	if (skippedTools > 0) children.push({
+		kind: "text",
+		content: `... ${skippedTools} earlier calls`
+	});
+	for (const tc of visibleTools) children.push({
+		kind: "tool",
+		item: tc
+	});
+	if (finalOutput) children.push({
+		kind: "summary",
+		output: finalOutput.trim()
+	});
+	if (children.length === 0) container.addChild(new Text(END + fg("muted", "(no output)"), 0, 0));
+	else for (let i = 0; i < children.length; i++) {
+		const child = children[i];
+		const isLast = i === children.length - 1;
+		const connector = isLast ? END : MID;
+		if (child.kind === "text") container.addChild(new Text(connector + fg("dim", child.content), 0, 0));
+		else if (child.kind === "tool") container.addChild(new TruncatedText(connector + renderToolLine(child.item, fg), 0, 0));
+		else if (child.kind === "summary") {
+			container.addChild(new Text(connector + fg("muted", "Summary:"), 0, 0));
+			const indent = isLast ? "    " : CONT;
+			container.addChild(new Text(indent, 0, 0));
+			container.addChild(new Markdown(child.output, 0, 0, mdTheme));
+		}
+	}
+	if (!showExpanded && toolCalls.length > COLLAPSED_ITEM_COUNT) container.addChild(new Text(fg("muted", "(Ctrl+O to expand)"), 0, 0));
+	const usageStr = formatUsageStats(r.usage, r.model);
+	if (usageStr) container.addChild(new Text(fg("dim", usageStr), 0, 0));
+}
+if (import.meta.vitest) {
+	const { describe, it, expect } = import.meta.vitest;
+	describe("formatUsageStats", () => {
+		it("formats all fields when present", () => {
+			const result = formatUsageStats({
+				input: 1500,
+				output: 500,
+				cacheRead: 2e3,
+				cacheWrite: 1e3,
+				cost: .0023,
+				contextTokens: 5e3,
+				turns: 2
+			}, "gpt-4");
+			expect(result).toContain("2 turns");
+			expect(result).toContain("↑1.5k");
+			expect(result).toContain("↓500");
+			expect(result).toContain("R2.0k");
+			expect(result).toContain("W1.0k");
+			expect(result).toContain("$0.0023");
+			expect(result).toContain("ctx:5.0k");
+			expect(result).toContain("gpt-4");
+		});
+		it("omits zero/undefined fields", () => {
+			const result = formatUsageStats({
+				input: 100,
+				output: 50,
+				cacheRead: 0,
+				cacheWrite: 0,
+				cost: 0
+			});
+			expect(result).toContain("↑100");
+			expect(result).toContain("↓50");
+			expect(result).not.toContain("turn");
+			expect(result).not.toContain("R");
+			expect(result).not.toContain("W");
+			expect(result).not.toContain("$");
+			expect(result).not.toContain("ctx");
+		});
+		it("formats large token counts", () => {
+			expect(formatUsageStats({
+				input: 15e5,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				cost: 0
+			})).toContain("↑1.5M");
+			expect(formatUsageStats({
+				input: 15e3,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				cost: 0
+			})).toContain("↑15k");
+			expect(formatUsageStats({
+				input: 1500,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				cost: 0
+			})).toContain("↑1.5k");
+			expect(formatUsageStats({
+				input: 500,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				cost: 0
+			})).toContain("↑500");
+		});
+		it("handles single turn", () => {
+			const result = formatUsageStats({
+				input: 100,
+				output: 50,
+				cacheRead: 0,
+				cacheWrite: 0,
+				cost: 0,
+				turns: 1
+			});
+			expect(result).toContain("1 turn");
+			expect(result).not.toContain("1 turns");
+		});
+		it("handles plural turns", () => {
+			expect(formatUsageStats({
+				input: 100,
+				output: 50,
+				cacheRead: 0,
+				cacheWrite: 0,
+				cost: 0,
+				turns: 3
+			})).toContain("3 turns");
+		});
+	});
+	describe("getFinalOutput", () => {
+		it("returns text from last assistant message", () => {
+			expect(getFinalOutput([
+				{
+					role: "user",
+					content: [{
+						type: "text",
+						text: "hello"
+					}],
+					timestamp: 0
+				},
+				{
+					role: "assistant",
+					content: [{
+						type: "text",
+						text: "first response"
+					}],
+					api: "anthropic-messages",
+					provider: "anthropic",
+					model: "claude",
+					usage: {
+						totalTokens: 0,
+						cost: {
+							input: 0,
+							output: 0,
+							cacheRead: 0,
+							cacheWrite: 0,
+							total: 0
+						}
+					},
+					stopReason: "stop",
+					timestamp: 0
+				},
+				{
+					role: "user",
+					content: [{
+						type: "text",
+						text: "more"
+					}],
+					timestamp: 0
+				},
+				{
+					role: "assistant",
+					content: [{
+						type: "text",
+						text: "final response"
+					}],
+					api: "anthropic-messages",
+					provider: "anthropic",
+					model: "claude",
+					usage: {
+						totalTokens: 0,
+						cost: {
+							input: 0,
+							output: 0,
+							cacheRead: 0,
+							cacheWrite: 0,
+							total: 0
+						}
+					},
+					stopReason: "stop",
+					timestamp: 0
+				}
+			])).toBe("final response");
+		});
+		it("returns empty string when no assistant messages", () => {
+			expect(getFinalOutput([{
+				role: "user",
+				content: [{
+					type: "text",
+					text: "hello"
+				}],
+				timestamp: 0
+			}])).toBe("");
+		});
+		it("skips tool calls, returns only text", () => {
+			expect(getFinalOutput([{
+				role: "assistant",
+				content: [{
+					type: "toolCall",
+					id: "tc1",
+					name: "bash",
+					arguments: { cmd: "ls" }
+				}, {
+					type: "text",
+					text: "here's the output"
+				}],
+				api: "anthropic-messages",
+				provider: "anthropic",
+				model: "claude",
+				usage: {
+					totalTokens: 0,
+					cost: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+						total: 0
+					}
+				},
+				stopReason: "stop",
+				timestamp: 0
+			}])).toBe("here's the output");
+		});
+		it("handles empty message array", () => {
+			expect(getFinalOutput([])).toBe("");
+		});
+	});
+	describe("getDisplayItems", () => {
+		it("extracts text and tool calls from messages", () => {
+			const items = getDisplayItems([
+				{
+					role: "user",
+					content: [{
+						type: "text",
+						text: "q"
+					}]
+				},
+				{
+					role: "assistant",
+					content: [{
+						type: "text",
+						text: "response"
+					}, {
+						type: "toolCall",
+						id: "tc1",
+						name: "read",
+						arguments: { path: "/file" }
+					}]
+				},
+				{
+					role: "toolResult",
+					toolCallId: "tc1",
+					content: [{
+						type: "text",
+						text: "file content"
+					}]
+				}
+			]);
+			expect(items).toHaveLength(2);
+			expect(items[0]).toEqual({
+				type: "text",
+				text: "response"
+			});
+			expect(items[1]).toEqual({
+				type: "toolCall",
+				id: "tc1",
+				name: "read",
+				args: { path: "/file" },
+				isError: void 0
+			});
+		});
+		it("marks tool calls as error when toolResult has isError", () => {
+			const items = getDisplayItems([{
+				role: "assistant",
+				content: [{
+					type: "toolCall",
+					id: "tc1",
+					name: "bash",
+					arguments: { cmd: "false" }
+				}]
+			}, {
+				role: "toolResult",
+				toolCallId: "tc1",
+				content: [{
+					type: "text",
+					text: "error"
+				}],
+				isError: true
+			}]);
+			expect(items).toHaveLength(1);
+			expect(items[0]).toMatchObject({
+				type: "toolCall",
+				id: "tc1",
+				isError: true
+			});
+		});
+		it("marks tool calls as success when isError is false", () => {
+			expect(getDisplayItems([{
+				role: "assistant",
+				content: [{
+					type: "toolCall",
+					id: "tc1",
+					name: "bash",
+					arguments: { cmd: "true" }
+				}]
+			}, {
+				role: "toolResult",
+				toolCallId: "tc1",
+				content: [{
+					type: "text",
+					text: "done"
+				}],
+				isError: false
+			}])[0]).toMatchObject({
+				type: "toolCall",
+				id: "tc1",
+				isError: false
+			});
+		});
+		it("handles multiple assistant messages", () => {
+			const items = getDisplayItems([{
+				role: "assistant",
+				content: [{
+					type: "text",
+					text: "first"
+				}],
+				api: "anthropic-messages",
+				provider: "anthropic",
+				model: "claude",
+				usage: {
+					totalTokens: 0,
+					cost: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+						total: 0
+					}
+				},
+				stopReason: "stop",
+				timestamp: 0
+			}, {
+				role: "assistant",
+				content: [{
+					type: "text",
+					text: "second"
+				}],
+				api: "anthropic-messages",
+				provider: "anthropic",
+				model: "claude",
+				usage: {
+					totalTokens: 0,
+					cost: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+						total: 0
+					}
+				},
+				stopReason: "stop",
+				timestamp: 0
+			}]);
+			expect(items).toHaveLength(2);
+			expect(items[0]).toEqual({
+				type: "text",
+				text: "first"
+			});
+			expect(items[1]).toEqual({
+				type: "text",
+				text: "second"
+			});
+		});
+	});
+	describe("subAgentResult", () => {
+		it("builds result with cost from usage", () => {
+			const result = subAgentResult("found it", {
+				agent: "finder",
+				task: "search for x",
+				exitCode: 0,
+				messages: [],
+				usage: {
+					turns: 1,
+					input: 100,
+					output: 50,
+					cacheRead: 0,
+					cacheWrite: 0,
+					cost: .002,
+					contextTokens: 0
+				},
+				model: "gemini-flash"
+			});
+			expect(result.content).toEqual([{
+				type: "text",
+				text: "found it"
+			}]);
+			expect(result.details.cost).toBe(.002);
+			expect(result.details.model).toBe("gemini-flash");
+			expect(result.isError).toBeUndefined();
+		});
+		it("sets isError when passed true", () => {
+			expect(subAgentResult("failed", {
+				agent: "oracle",
+				task: "advise",
+				exitCode: 1,
+				messages: [],
+				usage: {
+					turns: 0,
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					cost: 0,
+					contextTokens: 0
+				}
+			}, true).isError).toBe(true);
+		});
+	});
+}
+//#endregion
+export { formatUsageStats, getDisplayItems, getFinalOutput, renderAgentTree, subAgentResult };

package/dist/core/tool-cost.d.ts

@@ -0,0 +1,17 @@
+//#region packages/core/tool-cost/index.d.ts
+/**
+* shared cost contract for tool result details.
+*
+* any tool that incurs costs includes `cost: number` in its
+* details object. editor/index.ts uses the type guard to narrow
+* details at the session read boundary — no casting needed.
+*
+* sub-agent tools satisfy this via SingleResult & ToolCostDetails.
+* direct-cost tools (web_search) return { cost } directly.
+*/
+interface ToolCostDetails {
+  cost: number;
+}
+declare function hasToolCost(v: unknown): v is ToolCostDetails;
+//#endregion
+export { ToolCostDetails, hasToolCost };

package/dist/core/tool-cost.js

@@ -0,0 +1,58 @@
+//#region packages/core/tool-cost/index.ts
+function hasToolCost(v) {
+	return v != null && typeof v === "object" && "cost" in v && typeof v.cost === "number";
+}
+if (import.meta.vitest) {
+	const { describe, it, expect } = import.meta.vitest;
+	describe("hasToolCost", () => {
+		it("returns true for valid ToolCostDetails", () => {
+			expect(hasToolCost({ cost: .0023 })).toBe(true);
+		});
+		it("returns true for object with cost number", () => {
+			expect(hasToolCost({ cost: 0 })).toBe(true);
+			expect(hasToolCost({ cost: 1.5 })).toBe(true);
+			expect(hasToolCost({ cost: -.001 })).toBe(true);
+		});
+		it("returns true for object with additional properties", () => {
+			expect(hasToolCost({
+				cost: .5,
+				turns: 3,
+				model: "gpt-4"
+			})).toBe(true);
+		});
+		it("returns false for null", () => {
+			expect(hasToolCost(null)).toBe(false);
+		});
+		it("returns false for undefined", () => {
+			expect(hasToolCost(void 0)).toBe(false);
+		});
+		it("returns false for non-objects", () => {
+			expect(hasToolCost("string")).toBe(false);
+			expect(hasToolCost(123)).toBe(false);
+			expect(hasToolCost(true)).toBe(false);
+		});
+		it("returns false for object without cost", () => {
+			expect(hasToolCost({})).toBe(false);
+			expect(hasToolCost({ turns: 3 })).toBe(false);
+			expect(hasToolCost({ model: "gpt-4" })).toBe(false);
+		});
+		it("returns false for object with non-number cost", () => {
+			expect(hasToolCost({ cost: "0.002" })).toBe(false);
+			expect(hasToolCost({ cost: null })).toBe(false);
+			expect(hasToolCost({ cost: void 0 })).toBe(false);
+			expect(hasToolCost({ cost: true })).toBe(false);
+		});
+		it("narrowing works correctly", () => {
+			const unknown = {
+				cost: .5,
+				turns: 2
+			};
+			if (hasToolCost(unknown)) {
+				const cost = unknown.cost;
+				expect(cost).toBe(.5);
+			} else expect(true).toBe(false);
+		});
+	});
+}
+//#endregion
+export { hasToolCost };