@xynogen/pix-todo 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-todo",
-	"version": "0.1.5",
+	"version": "0.1.7",
 	"description": "Pi tool — durable execution checklist (todo)",
 	"type": "module",
 	"main": "src/index.ts",

package/src/todo.test.ts

@@ -1,5 +1,9 @@
 import { beforeEach, describe, expect, test } from "bun:test";
-import registerTodo, { renderTodoLines, type TodoItem } from "./todo.ts";
+import registerTodo, {
+	renderTodoLines,
+	renderTodoSummaryLine,
+	type TodoItem,
+} from "./todo.ts";
 
 // registerTodo wraps its body in once(pi, "pix-todo") — a per-instance
 // WeakMap guard that dedupes activation across pix-core + a standalone install.
@@ -41,9 +45,23 @@ function makeHost(
 		Array<(event: unknown, ctx?: unknown) => unknown>
 	> = {};
 
+	let capturedRender:
+		| ((
+				result: unknown,
+				options: unknown,
+				theme: unknown,
+				context: unknown,
+		  ) => { render(width: number): string[] })
+		| null = null;
+
 	const pi = {
-		registerTool(def: { name: string; execute: typeof capturedExecute }) {
+		registerTool(def: {
+			name: string;
+			execute: typeof capturedExecute;
+			renderResult?: typeof capturedRender;
+		}) {
 			capturedExecute = def.execute;
+			if (def.renderResult) capturedRender = def.renderResult;
 		},
 		appendEntry(type: string, data: unknown) {
 			appendCalls.push({ type, data });
@@ -68,6 +86,9 @@ function makeHost(
 		get execute() {
 			return capturedExecute!;
 		},
+		get render() {
+			return capturedRender!;
+		},
 		appendCalls,
 		async emit(ev: string, event?: unknown, ctx?: unknown) {
 			for (const fn of handlers[ev] ?? []) await fn(event, ctx);
@@ -314,6 +335,72 @@ describe("todo actions", () => {
 		expect(out).toContain("Todos 0/1 done");
 	});
 
+	test("opening a new in_progress closes the previous one", async () => {
+		const host = makeHost();
+		registerTodo(host.pi);
+		await host.emit(
+			"session_start",
+			{},
+			{ sessionManager: host.sessionManager },
+		);
+		await run(host.execute, { action: "set", items: "a\nb\nc" });
+		await run(host.execute, { action: "update", id: 1, status: "in_progress" });
+		const result = await run(host.execute, {
+			action: "update",
+			id: 2,
+			status: "in_progress",
+		});
+		const out = text(result);
+		expect(out).toContain("● 1. a"); // auto-closed to done
+		expect(out).toContain("◐ 2. b"); // now active
+		expect(out).toContain("○ 3. c");
+		expect(out).toContain("Todos 1/3 done");
+	});
+
+	test("opening a later item cascade-closes skipped pending items", async () => {
+		const host = makeHost();
+		registerTodo(host.pi);
+		await host.emit(
+			"session_start",
+			{},
+			{ sessionManager: host.sessionManager },
+		);
+		await run(host.execute, { action: "set", items: "a\nb\nc\nd" });
+		// Jump straight to id 4 without opening 1-3; they should all auto-close.
+		const result = await run(host.execute, {
+			action: "update",
+			id: 4,
+			status: "in_progress",
+		});
+		const out = text(result);
+		expect(out).toContain("● 1. a");
+		expect(out).toContain("● 2. b");
+		expect(out).toContain("● 3. c");
+		expect(out).toContain("◐ 4. d");
+		expect(out).toContain("Todos 3/4 done");
+	});
+
+	test("cascade-close leaves a blocked earlier item untouched", async () => {
+		const host = makeHost();
+		registerTodo(host.pi);
+		await host.emit(
+			"session_start",
+			{},
+			{ sessionManager: host.sessionManager },
+		);
+		await run(host.execute, { action: "set", items: "a\nb\nc" });
+		await run(host.execute, { action: "update", id: 1, status: "blocked" });
+		const result = await run(host.execute, {
+			action: "update",
+			id: 3,
+			status: "in_progress",
+		});
+		const out = text(result);
+		expect(out).toContain("⊘ 1. a"); // still blocked, not force-closed
+		expect(out).toContain("● 2. b"); // pending -> done
+		expect(out).toContain("◐ 3. c");
+	});
+
 	test("update unknown id returns error", async () => {
 		const host = makeHost();
 		registerTodo(host.pi);
@@ -396,8 +483,10 @@ describe("todo actions", () => {
 			{ sessionManager: host.sessionManager },
 		);
 		await run(host.execute, { action: "set", items: "a\nb\nc\nd" });
-		await run(host.execute, { action: "update", id: 1, status: "pending" });
+		// Open id 2 first (cascade-closes nothing earlier we assert on), then set
+		// the others directly so each glyph is exercised without cascade interfering.
 		await run(host.execute, { action: "update", id: 2, status: "in_progress" });
+		await run(host.execute, { action: "update", id: 1, status: "pending" });
 		await run(host.execute, { action: "update", id: 3, status: "done" });
 		await run(host.execute, { action: "update", id: 4, status: "blocked" });
 		const out = text(await run(host.execute, { action: "list" }));
@@ -652,3 +741,51 @@ describe("renderTodoLines (colored TUI render)", () => {
 		expect(out).toContain("[muted]Todos 1/4 done:[/]");
 	});
 });
+
+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 () => {
+		const host = makeHost();
+		registerTodo(host.pi);
+		await host.emit(
+			"session_start",
+			{},
+			{ sessionManager: host.sessionManager },
+		);
+		await run(host.execute, { action: "set", items: "alpha\nbravo" });
+
+		// 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");
+
+		// Mutate underlying todos via a new execute call.
+		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");
+	});
+});
+
+describe("renderTodoSummaryLine (collapsed one-liner)", () => {
+	test("empty list renders muted placeholder", () => {
+		expect(renderTodoSummaryLine([], tagTheme)).toBe("[muted](no todos)[/]");
+	});
+
+	test("renders single dim done/total line with check", () => {
+		const items: TodoItem[] = [
+			{ id: 1, text: "a", status: "done" },
+			{ id: 2, text: "b", status: "pending" },
+		];
+		expect(renderTodoSummaryLine(items, tagTheme)).toBe(
+			"[muted]Todos 1/2 done ✓[/]",
+		);
+	});
+});

package/src/todo.ts

@@ -15,6 +15,9 @@ import { Type } from "typebox";
 
 import { once } from "./once.ts";
 
+/** Seconds before a todo card collapses to a one-line dim summary. */
+const COLLAPSE_AFTER_SEC = 10;
+
 export type TodoStatus = "pending" | "in_progress" | "done" | "blocked";
 
 export interface TodoItem {
@@ -43,6 +46,16 @@ export type TodoTheme = {
 	bold: (text: string) => string;
 };
 
+/** 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)");
+	const done = items.filter((t) => t.status === "done").length;
+	return theme.fg("muted", `Todos ${done}/${items.length} done ✓`);
+}
+
 /** 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)");
@@ -98,7 +111,7 @@ export default function registerTodo(pi: ExtensionAPI): void {
 				"todo(action, items?, id?, status?, text?) — action: list|set|add|update|clear. Use to track implementation progress, especially when executing a plan.",
 			promptGuidelines: [
 				"When you start executing a multi-step plan in BUILD mode, seed the todo list with `todo(action:'set', items: <plan Implementation Phases>)`.",
-				"Mark each item in_progress before working it and done when finished via `todo(action:'update', id, status)`.",
+				"Mark each item in_progress before working it via `todo(action:'update', id, status)`; opening one auto-closes every earlier item, so just open the next and skipped steps mark done themselves.",
 				"Call `todo(action:'list')` to recover your place after long runs or context compaction.",
 			],
 			parameters: Type.Object({
@@ -138,8 +151,26 @@ export default function registerTodo(pi: ExtensionAPI): void {
 					}),
 				),
 			}),
-			renderResult(_result, _options, theme) {
-				return new Text(renderTodoLines(todos, theme as TodoTheme), 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.
+				if (!state.collapsed && !state.timer) {
+					state.timer = setTimeout(() => {
+						state.collapsed = true;
+						context.invalidate();
+					}, COLLAPSE_AFTER_SEC * 1000);
+				}
+				const render = state.collapsed
+					? renderTodoSummaryLine
+					: renderTodoLines;
+				return new Text(render(state.snapshot, theme as TodoTheme), 0, 0);
 			},
 
 			async execute(_id, params) {
@@ -183,7 +214,21 @@ export default function registerTodo(pi: ExtensionAPI): void {
 					case "update": {
 						const t = todos.find((x) => x.id === params.id);
 						if (!t) return fail(`No todo with id ${params.id}.`);
-						if (params.status) t.status = params.status;
+						if (params.status) {
+							// Sequential-progress invariant: opening a task means everything
+							// before it is finished. Cascade-close every earlier pending or
+							// in_progress item (ids are sequential) so the model never has to
+							// mark skipped steps done by hand. `blocked` is left untouched.
+							if (params.status === "in_progress")
+								for (const other of todos)
+									if (
+										other.id < t.id &&
+										(other.status === "pending" ||
+											other.status === "in_progress")
+									)
+										other.status = "done";
+							t.status = params.status;
+						}
 						if (params.text) t.text = params.text;
 						persistTodos();
 						return ok(todoSummary());