@xynogen/pix-todo 0.1.14 → 0.1.16

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.14",
+	"version": "0.1.16",
 	"description": "Pi tool — durable execution checklist (todo)",
 	"type": "module",
 	"main": "src/index.ts",
@@ -34,6 +34,7 @@
 		"access": "public"
 	},
 	"dependencies": {
+		"@xynogen/pix-data": "^0.3.2",
 		"@xynogen/pix-pretty": "^1.7.20",
 		"typebox": "^1.1.38"
 	},

package/src/todo.test.ts

@@ -27,12 +27,14 @@ function makeHost(
 	}> = [],
 ) {
 	let capturedParameters: unknown;
+	let capturedRenderShell: unknown;
 	let capturedExecute:
 		| ((
 				id: string,
 				params: Record<string, unknown>,
 		  ) => Promise<{
 				content: Array<{ type: string; text: string }>;
+				details?: unknown;
 				isError?: boolean;
 		  }>)
 		| null = null;
@@ -56,10 +58,12 @@ function makeHost(
 			name: string;
 			parameters: unknown;
 			execute: typeof capturedExecute;
+			renderShell?: unknown;
 			renderCall?: typeof capturedRenderCall;
 			renderResult?: typeof capturedRender;
 		}) {
 			capturedParameters = def.parameters;
+			capturedRenderShell = def.renderShell;
 			capturedExecute = def.execute;
 			if (def.renderCall) capturedRenderCall = def.renderCall;
 			if (def.renderResult) capturedRender = def.renderResult;
@@ -98,6 +102,9 @@ function makeHost(
 			if (!capturedExecute) throw new Error("execute not captured");
 			return capturedExecute;
 		},
+		get renderShell() {
+			return capturedRenderShell;
+		},
 		get renderCall() {
 			if (!capturedRenderCall) throw new Error("renderCall not captured");
 			return capturedRenderCall;
@@ -124,6 +131,7 @@ async function run(
 		params: Record<string, unknown>,
 	) => Promise<{
 		content: Array<{ type: string; text: string }>;
+		details?: unknown;
 		isError?: boolean;
 	}>,
 	params: Record<string, unknown>,
@@ -775,46 +783,108 @@ describe("renderTodoLines (colored TUI render)", () => {
 		expect(out).toContain("[text]3. charlie[/]"); // pending body text
 	});
 
-	test("shows the done/total count header", () => {
+	test("shows the done/total count header in blue", () => {
 		const out = renderTodoLines(items, tagTheme);
-		expect(out).toContain("[muted]Todos 1/4 done:[/]");
+		expect(out).toContain("[accent]Todos 1/4 done:[/]");
+		expect(out).not.toContain("[muted]Todos 1/4 done:[/]");
 	});
 });
 
 describe("todo card layout", () => {
+	test("uses the self-rendered shell so the compact checkmark has no leading space", () => {
+		const host = makeHost();
+		registerTodo(host.pi);
+		expect(host.renderShell).toBe("self");
+	});
+
 	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("");
 	});
-});
 
-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 () => {
+	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");
 	});
 });
 

package/src/todo.ts

@@ -9,67 +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 {
@@ -78,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: "◐",
@@ -98,7 +54,7 @@ export type TodoTheme = {
 	bold: (text: string) => string;
 };
 
-/** One-line dim summary used once a card has collapsed. */
+/** One-line shared summary used once a card has collapsed. */
 export function renderTodoSummaryLine(items: TodoItem[], theme: TodoTheme): string {
 	if (!items.length) return formatCollapsedToolRow(theme, "todo", "empty");
 	const done = items.filter((t) => t.status === "done").length;
@@ -112,14 +68,14 @@ export function renderTodoSummaryLine(items: TodoItem[], theme: TodoTheme): stri
 		: done === items.length
 			? "complete"
 			: "checklist";
-	return formatCollapsedToolRow(theme, "todo", target, meta);
+	return formatCollapsedToolRow(theme, "todo", target, meta, "success");
 }
 
 /** Colored checklist for the TUI: glyphs tinted by status, active row bold. */
 export function renderTodoLines(items: TodoItem[], theme: TodoTheme): string {
 	if (!items.length) return theme.fg("muted", "(no todos)");
 	const done = items.filter((t) => t.status === "done").length;
-	const head = theme.fg("muted", `Todos ${done}/${items.length} done:`);
+	const head = theme.fg("accent", `Todos ${done}/${items.length} done:`);
 	const lines = items.map((t) => {
 		const color = TODO_COLOR[t.status];
 		const glyph = theme.fg(color, TODO_GLYPH[t.status]);
@@ -178,6 +134,9 @@ export default function registerTodo(pi: ExtensionAPI): void {
 		pi.registerTool({
 			name: "todo",
 			label: "Todo",
+			// Avoid the default Box shell's one-cell x padding: Todo owns its compact
+			// result row and should align its status glyph with other compact tools.
+			renderShell: "self",
 			description:
 				"Track BUILD-phase execution progress. Durable across context compaction. Actions: list, set (replace all items from newline/numbered text), add, update (change one item's status), clear.",
 			promptSnippet:
@@ -218,37 +177,41 @@ export default function registerTodo(pi: ExtensionAPI): void {
 			renderCall() {
 				return new Text("", 0, 0);
 			},
-			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());
+			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) {