@xynogen/pix-todo 0.1.13 → 0.1.15

package/README.md

@@ -8,13 +8,13 @@ Registers the `todo` tool, which gives the agent a persistent task checklist tha
 
 ## Auto-collapse
 
-The checklist card auto-collapses after a configurable delay (default 10 seconds, previously hardcoded). The delay and the per-tool toggle are read from `~/.pi/agent/pix.json`:
+The checklist card uses the shared `@xynogen/pix-data/collapse` state machine and auto-collapses after a configurable delay (default 10 seconds) to a row such as `✓ todo #2 release prep · 1/2 done`. Expanding an elapsed card restores the immutable checklist snapshot for that result, with its colored status glyphs, without restarting the timer. Failed actions keep their exact diagnostic instead of rendering a checklist. The delay and per-tool toggle are read from `~/.pi/agent/pix.json`:
 
 ```jsonc
 {
   "collapse": {
     "enabled": true,
-    "delayMs": 10000,
+    "delaySec": 10,
     "tools": { "todo": true }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-todo",
-	"version": "0.1.13",
+	"version": "0.1.15",
 	"description": "Pi tool — durable execution checklist (todo)",
 	"type": "module",
 	"main": "src/index.ts",
@@ -34,6 +34,8 @@
 		"access": "public"
 	},
 	"dependencies": {
+		"@xynogen/pix-data": "^0.3.2",
+		"@xynogen/pix-pretty": "^1.7.20",
 		"typebox": "^1.1.38"
 	},
 	"peerDependencies": {

package/src/todo.test.ts

@@ -33,6 +33,7 @@ function makeHost(
 				params: Record<string, unknown>,
 		  ) => Promise<{
 				content: Array<{ type: string; text: string }>;
+				details?: unknown;
 				isError?: boolean;
 		  }>)
 		| null = null;
@@ -47,16 +48,21 @@ function makeHost(
 				context: unknown,
 		  ) => { render(width: number): string[] })
 		| null = null;
+	let capturedRenderCall:
+		| ((args: unknown, theme: unknown, context: unknown) => { render(width: number): string[] })
+		| null = null;
 
 	const pi = {
 		registerTool(def: {
 			name: string;
 			parameters: unknown;
 			execute: typeof capturedExecute;
+			renderCall?: typeof capturedRenderCall;
 			renderResult?: typeof capturedRender;
 		}) {
 			capturedParameters = def.parameters;
 			capturedExecute = def.execute;
+			if (def.renderCall) capturedRenderCall = def.renderCall;
 			if (def.renderResult) capturedRender = def.renderResult;
 		},
 		appendEntry(type: string, data: unknown) {
@@ -93,6 +99,10 @@ function makeHost(
 			if (!capturedExecute) throw new Error("execute not captured");
 			return capturedExecute;
 		},
+		get renderCall() {
+			if (!capturedRenderCall) throw new Error("renderCall not captured");
+			return capturedRenderCall;
+		},
 		get render() {
 			if (!capturedRender) throw new Error("render not captured");
 			return capturedRender;
@@ -115,6 +125,7 @@ async function run(
 		params: Record<string, unknown>,
 	) => Promise<{
 		content: Array<{ type: string; text: string }>;
+		details?: unknown;
 		isError?: boolean;
 	}>,
 	params: Record<string, unknown>,
@@ -772,44 +783,112 @@ describe("renderTodoLines (colored TUI render)", () => {
 	});
 });
 
-describe("renderResult snapshot isolation", () => {
-	// The card snapshots `todos` on first render; later execute() mutations must
-	// NOT bleed into an already-rendered card. Guards the invariant the inline
-	// comment defends.
-	test("a rendered card keeps its state after todos mutate", async () => {
+describe("todo card layout", () => {
+	test("keeps the call row empty so the collapsed card is one line", () => {
+		const host = makeHost();
+		registerTodo(host.pi);
+		const call = host.renderCall({ action: "list" }, tagTheme, {});
+		expect(call.render(80).join("\n")).toBe("");
+	});
+
+	test("expanded mode restores a collapsed checklist", async () => {
 		const host = makeHost();
 		registerTodo(host.pi);
 		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
-		await run(host.execute, { action: "set", items: "alpha\nbravo" });
+		const result = await run(host.execute, { action: "set", items: "alpha\nbravo" });
+		const rendered = host
+			.render(result, { expanded: true }, tagTheme, {
+				state: { collapsed: true },
+				invalidate: () => {},
+			})
+			.render(80)
+			.join("\n");
 
-		// Render once with a per-row state bag; snapshot is taken here.
-		const state: Record<string, unknown> = {};
-		const ctx = { state, invalidate: () => {} };
-		const first = host.render({}, {}, tagTheme, ctx).render(80).join("\n");
-		expect(first).toContain("1. alpha");
-		expect(first).toContain("2. bravo");
+		expect(rendered).toContain("1. alpha");
+		expect(rendered).toContain("[muted]○[/]");
+		expect(rendered).not.toContain("[success]✓[/] [toolTitle]<b>todo</b>[/]");
+	});
+
+	test("failed todo actions render their exact error", async () => {
+		const host = makeHost();
+		registerTodo(host.pi);
+		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
+		const result = await run(host.execute, { action: "update", id: 99, status: "done" });
+		const rendered = host
+			.render(result, { expanded: false }, tagTheme, {
+				state: { collapsed: true },
+				invalidate: () => {},
+			})
+			.render(80)
+			.join("\n")
+			.trimEnd();
+
+		expect(rendered).toBe("No todo with id 99.");
+	});
 
-		// Mutate underlying todos via a new execute call.
+	test("a collapsed result is exactly one shared-style line", async () => {
+		const host = makeHost();
+		registerTodo(host.pi);
+		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
+		await run(host.execute, { action: "set", items: "foundation\ntodo renderer" });
+		const result = await run(host.execute, { action: "update", id: 1, status: "done" });
+		const activeResult = await run(host.execute, {
+			action: "update",
+			id: 2,
+			status: "in_progress",
+		});
+		const lines = host
+			.render(activeResult, { expanded: false }, tagTheme, {
+				state: { collapsed: true },
+				invalidate: () => {},
+			})
+			.render(120);
+
+		expect(result.details).toBeDefined();
+		expect(lines).toHaveLength(1);
+		expect(lines[0]?.trimEnd()).toBe(
+			"[success]✓[/] [toolTitle]<b>todo</b>[/] [muted]#2 todo renderer[/] [dim]·[/] [dim]1/2 done[/]",
+		);
+	});
+});
+
+describe("renderResult snapshot isolation", () => {
+	test("successful results carry immutable snapshots", async () => {
+		const host = makeHost();
+		registerTodo(host.pi);
+		await host.emit("session_start", {}, { sessionManager: host.sessionManager });
+		const original = await run(host.execute, { action: "set", items: "alpha\nbravo" });
 		await run(host.execute, { action: "set", items: "changed" });
 
-		// Re-render the SAME row (same state bag) — must still show the snapshot.
-		const second = host.render({}, {}, tagTheme, ctx).render(80).join("\n");
-		expect(second).toContain("1. alpha");
-		expect(second).toContain("2. bravo");
-		expect(second).not.toContain("changed");
+		const details = original.details as { snapshot: TodoItem[] };
+		expect(details.snapshot.map((item) => item.text)).toEqual(["alpha", "bravo"]);
+		const rendered = host
+			.render(original, { expanded: true }, tagTheme, {
+				state: {},
+				invalidate: () => {},
+			})
+			.render(80)
+			.join("\n");
+		expect(rendered).toContain("1. alpha");
+		expect(rendered).toContain("2. bravo");
+		expect(rendered).not.toContain("changed");
 	});
 });
 
 describe("renderTodoSummaryLine (collapsed one-liner)", () => {
-	test("empty list renders muted placeholder", () => {
-		expect(renderTodoSummaryLine([], tagTheme)).toBe("[muted](no todos)[/]");
+	test("empty list renders a compact tool row", () => {
+		expect(renderTodoSummaryLine([], tagTheme)).toBe(
+			"[success]✓[/] [toolTitle]<b>todo</b>[/] [muted]empty[/]",
+		);
 	});
 
-	test("renders single dim done/total line with check", () => {
+	test("renders active work and progress in one row", () => {
 		const items: TodoItem[] = [
 			{ id: 1, text: "a", status: "done" },
-			{ id: 2, text: "b", status: "pending" },
+			{ id: 2, text: "b", status: "in_progress" },
 		];
-		expect(renderTodoSummaryLine(items, tagTheme)).toBe("[muted]Todos 1/2 done ✓[/]");
+		expect(renderTodoSummaryLine(items, tagTheme)).toBe(
+			"[success]✓[/] [toolTitle]<b>todo</b>[/] [muted]#2 b[/] [dim]·[/] [dim]1/2 done[/]",
+		);
 	});
 });

package/src/todo.ts

@@ -9,66 +9,14 @@
  * checklist is seeded by the model via the tool's `set` action.
  */
 
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
+import { type CollapseState, tickCollapse } from "@xynogen/pix-data/collapse";
+import { formatCollapsedToolRow } from "@xynogen/pix-pretty/utils";
 import { Type } from "typebox";
 
 import { once } from "./once.ts";
 
-// ── Collapse config from ~/.pi/agent/pix.json ────────────────────────────────
-
-interface CollapseConf {
-	enabled: boolean;
-	delaySec: number;
-	tools: Record<string, boolean | undefined>;
-}
-
-const DEFAULT_COLLAPSE: CollapseConf = {
-	enabled: true,
-	delaySec: 10,
-	tools: {},
-};
-
-function readCollapseConfig(): CollapseConf {
-	try {
-		const home = process.env.HOME ?? "";
-		if (!home) return DEFAULT_COLLAPSE;
-		const p = join(home, ".pi/agent", "pix.json");
-		if (!existsSync(p)) return DEFAULT_COLLAPSE;
-		const raw = JSON.parse(readFileSync(p, "utf-8")) as Record<string, unknown>;
-		const c = raw?.collapse as Record<string, unknown> | undefined;
-		if (!c || typeof c !== "object") return DEFAULT_COLLAPSE;
-		return {
-			enabled: typeof c.enabled === "boolean" ? c.enabled : true,
-			delaySec: typeof c.delaySec === "number" && c.delaySec > 0 ? c.delaySec : 10,
-			tools:
-				c.tools && typeof c.tools === "object"
-					? (c.tools as Record<string, boolean | undefined>)
-					: {},
-		};
-	} catch {
-		return DEFAULT_COLLAPSE;
-	}
-}
-
-let collapseConf: CollapseConf | null = null;
-function getCollapseConfig(): CollapseConf {
-	if (!collapseConf) collapseConf = readCollapseConfig();
-	return collapseConf;
-}
-
-function shouldCollapseTodo(): boolean {
-	const c = getCollapseConfig();
-	const perTool = c.tools.todo;
-	return typeof perTool === "boolean" ? perTool : c.enabled;
-}
-
-function collapseDelayMs(): number {
-	return getCollapseConfig().delaySec * 1000;
-}
-
 export type TodoStatus = "pending" | "in_progress" | "done" | "blocked";
 
 export interface TodoItem {
@@ -77,6 +25,15 @@ export interface TodoItem {
 	status: TodoStatus;
 }
 
+type TodoAction = "list" | "set" | "add" | "update" | "clear";
+
+interface TodoResultDetails {
+	_type: "todoResult";
+	action: TodoAction;
+	outcome: "success" | "error";
+	snapshot: TodoItem[];
+}
+
 const TODO_GLYPH: Record<TodoStatus, string> = {
 	pending: "○",
 	in_progress: "◐",
@@ -99,9 +56,19 @@ export type TodoTheme = {
 
 /** One-line dim summary used once a card has collapsed. */
 export function renderTodoSummaryLine(items: TodoItem[], theme: TodoTheme): string {
-	if (!items.length) return theme.fg("muted", "(no todos)");
+	if (!items.length) return formatCollapsedToolRow(theme, "todo", "empty");
 	const done = items.filter((t) => t.status === "done").length;
-	return theme.fg("muted", `Todos ${done}/${items.length} done ✓`);
+	const active = items.find((t) => t.status === "in_progress");
+	const blocked = items.filter((t) => t.status === "blocked").length;
+	const meta = [`${done}/${items.length} done`, blocked > 0 ? `${blocked} blocked` : ""]
+		.filter(Boolean)
+		.join(" · ");
+	const target = active
+		? `#${active.id} ${active.text}`
+		: done === items.length
+			? "complete"
+			: "checklist";
+	return formatCollapsedToolRow(theme, "todo", target, meta, "success");
 }
 
 /** Colored checklist for the TUI: glyphs tinted by status, active row bold. */
@@ -202,37 +169,46 @@ export default function registerTodo(pi: ExtensionAPI): void {
 					}),
 				),
 			}),
-			renderResult(_result, _options, theme, context) {
-				// Snapshot this row's todos once (live `todos` mutate across calls;
-				// a card should keep the state it was created with).
-				const state = context.state as {
-					snapshot?: TodoItem[];
-					collapsed?: boolean;
-					timer?: ReturnType<typeof setTimeout>;
-				};
-				if (!state.snapshot) state.snapshot = todos.map((t) => ({ ...t }));
-				// Start the collapse timer once per row; invalidate() triggers rerender.
-				// Config-driven: reads from ~/.pi/agent/pix.json collapse section.
-				if (shouldCollapseTodo() && !state.collapsed && !state.timer) {
-					state.timer = setTimeout(() => {
-						state.collapsed = true;
-						context.invalidate();
-					}, collapseDelayMs());
+			// The result already owns the checklist and its collapsed `✓ todo …` row.
+			// Keeping the call renderer empty prevents a duplicate standalone header.
+			renderCall() {
+				return new Text("", 0, 0);
+			},
+			renderResult(result, options, theme, context) {
+				const details = result.details as TodoResultDetails | undefined;
+				const resultText = result.content
+					.filter((part) => part.type === "text")
+					.map((part) => part.text)
+					.join("\n");
+				if (context.isError || details?.outcome === "error" || !details) {
+					return new Text(resultText, 0, 0);
 				}
-				const render = state.collapsed ? renderTodoSummaryLine : renderTodoLines;
-				return new Text(render(state.snapshot, theme as TodoTheme), 0, 0);
+
+				const collapsed = tickCollapse(
+					"todo",
+					context.state as CollapseState,
+					context.invalidate,
+					options.expanded,
+				);
+				const render = collapsed ? renderTodoSummaryLine : renderTodoLines;
+				return new Text(render(details.snapshot, theme as TodoTheme), 0, 0);
 			},
 
 			async execute(_id, params) {
-				// AgentToolResult now requires a `details` field. These todo results have
-				// no structured details, so emit `undefined` via small local helpers.
+				const action = params.action as TodoAction;
+				const details = (outcome: TodoResultDetails["outcome"]): TodoResultDetails => ({
+					_type: "todoResult",
+					action,
+					outcome,
+					snapshot: todos.map((item) => ({ ...item })),
+				});
 				const ok = (text: string) => ({
 					content: [{ type: "text" as const, text }],
-					details: undefined,
+					details: details("success"),
 				});
 				const fail = (text: string) => ({
 					content: [{ type: "text" as const, text }],
-					details: undefined,
+					details: details("error"),
 					isError: true,
 				});
 				switch (params.action) {