@oh-my-pi/pi-coding-agent 12.19.3 → 13.0.0

package/src/tools/todo-write.ts

@@ -1,9 +1,7 @@
-import path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { StringEnum } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import { logger, Snowflake } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import chalk from "chalk";
 import { renderPromptTemplate } from "../config/prompt-templates";
@@ -11,138 +9,274 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import todoWriteDescription from "../prompts/tools/todo-write.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
+import type { SessionEntry } from "../session/session-manager";
 import { renderStatusLine, renderTreeList } from "../tui";
 import { PREVIEW_LIMITS } from "./render-utils";
 
-const todoWriteSchema = Type.Object({
-	todos: Type.Array(
-		Type.Object({
-			id: Type.Optional(Type.String({ description: "Stable todo id" })),
-			content: Type.String({ description: "Task description (e.g., 'Run tests')" }),
-			status: StringEnum(["pending", "in_progress", "completed"]),
-		}),
-		{ description: "The updated todo list" },
-	),
-});
+// =============================================================================
+// Types
+// =============================================================================
 
-type TodoStatus = "pending" | "in_progress" | "completed";
+export type TodoStatus = "pending" | "in_progress" | "completed" | "abandoned";
 
 export interface TodoItem {
 	id: string;
 	content: string;
 	status: TodoStatus;
+	notes?: string;
 }
 
-interface TodoFile {
-	updatedAt: number;
-	todos: TodoItem[];
+export interface TodoPhase {
+	id: string;
+	name: string;
+	tasks: TodoItem[];
 }
 
 export interface TodoWriteToolDetails {
-	todos: TodoItem[];
-	updatedAt: number;
+	phases: TodoPhase[];
 	storage: "session" | "memory";
 }
 
-const TODO_FILE_NAME = "todos.json";
+// =============================================================================
+// Schema
+// =============================================================================
+
+const StatusEnum = StringEnum(["pending", "in_progress", "completed", "abandoned"] as const);
+
+const InputTask = Type.Object({
+	content: Type.String(),
+	status: Type.Optional(StatusEnum),
+	notes: Type.Optional(Type.String()),
+});
+
+const InputPhase = Type.Object({
+	name: Type.String(),
+	tasks: Type.Optional(Type.Array(InputTask)),
+});
+
+const todoWriteSchema = Type.Object({
+	ops: Type.Array(
+		Type.Union([
+			Type.Object({
+				op: Type.Literal("replace"),
+				phases: Type.Array(InputPhase),
+			}),
+			Type.Object({
+				op: Type.Literal("add_phase"),
+				name: Type.String(),
+				tasks: Type.Optional(Type.Array(InputTask)),
+			}),
+			Type.Object({
+				op: Type.Literal("add_task"),
+				phase: Type.String({ description: "Phase ID, e.g. phase-1" }),
+				content: Type.String(),
+				notes: Type.Optional(Type.String()),
+			}),
+			Type.Object({
+				op: Type.Literal("update"),
+				id: Type.String({ description: "Task ID, e.g. task-3" }),
+				status: Type.Optional(StatusEnum),
+				content: Type.Optional(Type.String()),
+				notes: Type.Optional(Type.String()),
+			}),
+			Type.Object({
+				op: Type.Literal("remove_task"),
+				id: Type.String({ description: "Task ID, e.g. task-3" }),
+			}),
+		]),
+	),
+});
 
 type TodoWriteParams = Static<typeof todoWriteSchema>;
 
-function normalizeTodoStatus(status?: string): TodoStatus {
-	switch (status) {
-		case "in_progress":
-			return "in_progress";
-		case "completed":
-		case "done":
-		case "complete":
-			return "completed";
-		default:
-			return "pending";
+// =============================================================================
+// File format
+// =============================================================================
+
+interface TodoFile {
+	phases: TodoPhase[];
+	nextTaskId: number;
+	nextPhaseId: number;
+}
+
+// =============================================================================
+// State helpers
+// =============================================================================
+
+function makeEmptyFile(): TodoFile {
+	return { phases: [], nextTaskId: 1, nextPhaseId: 1 };
+}
+
+function findTask(phases: TodoPhase[], id: string): TodoItem | undefined {
+	for (const phase of phases) {
+		const task = phase.tasks.find(t => t.id === id);
+		if (task) return task;
 	}
+	return undefined;
 }
 
-function normalizeTodos(items: Array<{ id?: string; content?: string; status?: string }>): TodoItem[] {
-	return items.map(item => {
-		if (!item.content) {
-			throw new Error("Todo content is required.");
-		}
-		const content = item.content.trim();
-		if (!content) {
-			throw new Error("Todo content cannot be empty.");
-		}
-		return {
-			id: item.id && item.id.trim().length > 0 ? item.id : Snowflake.next(),
-			content,
-			status: normalizeTodoStatus(item.status),
-		};
-	});
+function buildPhaseFromInput(
+	input: { name: string; tasks?: Array<{ content: string; status?: TodoStatus; notes?: string }> },
+	phaseId: string,
+	nextTaskId: number,
+): { phase: TodoPhase; nextTaskId: number } {
+	const tasks: TodoItem[] = [];
+	let tid = nextTaskId;
+	for (const t of input.tasks ?? []) {
+		tasks.push({ id: `task-${tid++}`, content: t.content, status: t.status ?? "pending", notes: t.notes });
+	}
+	return { phase: { id: phaseId, name: input.name, tasks }, nextTaskId: tid };
 }
 
-function validateSequentialTodos(todos: TodoItem[]): { valid: boolean; error?: string } {
-	if (todos.length === 0) return { valid: true };
+function getNextIds(phases: TodoPhase[]): { nextTaskId: number; nextPhaseId: number } {
+	let maxTaskId = 0;
+	let maxPhaseId = 0;
 
-	const firstIncompleteIndex = todos.findIndex(todo => todo.status !== "completed");
-	if (firstIncompleteIndex >= 0) {
-		for (let i = firstIncompleteIndex + 1; i < todos.length; i++) {
-			if (todos[i].status === "completed") {
-				return {
-					valid: false,
-					error: `Error: Cannot complete "${todos[i].content}" before completing "${todos[firstIncompleteIndex].content}". Todos must be completed sequentially.`,
-				};
-			}
+	for (const phase of phases) {
+		const phaseMatch = /^phase-(\d+)$/.exec(phase.id);
+		if (phaseMatch) {
+			const value = Number.parseInt(phaseMatch[1], 10);
+			if (Number.isFinite(value) && value > maxPhaseId) maxPhaseId = value;
 		}
-	}
 
-	const inProgressIndices = todos.reduce<number[]>((acc, todo, index) => {
-		if (todo.status === "in_progress") acc.push(index);
-		return acc;
-	}, []);
-
-	for (const idx of inProgressIndices) {
-		const hasPriorIncomplete = todos.slice(0, idx).some(t => t.status === "pending");
-		if (hasPriorIncomplete) {
-			return {
-				valid: false,
-				error: `Cannot start "${todos[idx].content}" while earlier tasks are still pending.`,
-			};
+		for (const task of phase.tasks) {
+			const taskMatch = /^task-(\d+)$/.exec(task.id);
+			if (!taskMatch) continue;
+			const value = Number.parseInt(taskMatch[1], 10);
+			if (Number.isFinite(value) && value > maxTaskId) maxTaskId = value;
 		}
 	}
 
-	return { valid: true };
+	return { nextTaskId: maxTaskId + 1, nextPhaseId: maxPhaseId + 1 };
 }
 
-async function loadTodoFile(filePath: string): Promise<TodoFile | null> {
-	const file = Bun.file(filePath);
-	if (!(await file.exists())) return null;
-	try {
-		const text = await file.text();
-		const data = JSON.parse(text) as TodoFile;
-		if (!data || !Array.isArray(data.todos)) return null;
-		return data;
-	} catch (error) {
-		logger.warn("Failed to read todo file", { path: filePath, error: String(error) });
-		return null;
+function fileFromPhases(phases: TodoPhase[]): TodoFile {
+	const { nextTaskId, nextPhaseId } = getNextIds(phases);
+	return { phases, nextTaskId, nextPhaseId };
+}
+
+function clonePhases(phases: TodoPhase[]): TodoPhase[] {
+	return phases.map(phase => ({ ...phase, tasks: phase.tasks.map(task => ({ ...task })) }));
+}
+
+export function getLatestTodoPhasesFromEntries(entries: SessionEntry[]): TodoPhase[] {
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const entry = entries[i];
+		if (entry.type !== "message") continue;
+
+		const message = entry.message as { role?: string; toolName?: string; details?: unknown; isError?: boolean };
+		if (message.role !== "toolResult" || message.toolName !== "todo_write" || message.isError) continue;
+
+		const details = message.details as { phases?: unknown } | undefined;
+		if (!details || !Array.isArray(details.phases)) continue;
+
+		return clonePhases(details.phases as TodoPhase[]);
 	}
+
+	return [];
 }
 
-function formatTodoSummary(todos: TodoItem[]): string {
-	if (todos.length === 0) return "Todo list cleared.";
-	const completed = todos.filter(t => t.status === "completed").length;
-	const inProgress = todos.filter(t => t.status === "in_progress").length;
-	const pending = todos.filter(t => t.status === "pending").length;
-	return `Saved ${todos.length} todos (${pending} pending, ${inProgress} in progress, ${completed} completed).`;
+function applyOps(file: TodoFile, ops: TodoWriteParams["ops"]): { file: TodoFile; errors: string[] } {
+	const errors: string[] = [];
+
+	for (const op of ops) {
+		switch (op.op) {
+			case "replace": {
+				const next = makeEmptyFile();
+				for (const inputPhase of op.phases) {
+					const phaseId = `phase-${next.nextPhaseId++}`;
+					const { phase, nextTaskId } = buildPhaseFromInput(inputPhase, phaseId, next.nextTaskId);
+					next.phases.push(phase);
+					next.nextTaskId = nextTaskId;
+				}
+				file = next;
+				break;
+			}
+
+			case "add_phase": {
+				const phaseId = `phase-${file.nextPhaseId++}`;
+				const { phase, nextTaskId } = buildPhaseFromInput(op, phaseId, file.nextTaskId);
+				file.phases.push(phase);
+				file.nextTaskId = nextTaskId;
+				break;
+			}
+
+			case "add_task": {
+				const target = file.phases.find(p => p.id === op.phase);
+				if (!target) {
+					errors.push(`Phase "${op.phase}" not found`);
+					break;
+				}
+				target.tasks.push({
+					id: `task-${file.nextTaskId++}`,
+					content: op.content,
+					status: "pending",
+					notes: op.notes,
+				});
+				break;
+			}
+
+			case "update": {
+				const task = findTask(file.phases, op.id);
+				if (!task) {
+					errors.push(`Task "${op.id}" not found`);
+					break;
+				}
+				if (op.status !== undefined) task.status = op.status;
+				if (op.content !== undefined) task.content = op.content;
+				if (op.notes !== undefined) task.notes = op.notes;
+				break;
+			}
+
+			case "remove_task": {
+				let removed = false;
+				for (const phase of file.phases) {
+					const idx = phase.tasks.findIndex(t => t.id === op.id);
+					if (idx !== -1) {
+						phase.tasks.splice(idx, 1);
+						removed = true;
+						break;
+					}
+				}
+				if (!removed) errors.push(`Task "${op.id}" not found`);
+				break;
+			}
+		}
+	}
+
+	return { file, errors };
 }
 
-function formatTodoLine(item: TodoItem, uiTheme: Theme, prefix: string): string {
-	const checkbox = uiTheme.checkbox;
-	switch (item.status) {
-		case "completed":
-			return uiTheme.fg("success", `${prefix}${checkbox.checked} ${chalk.strikethrough(item.content)}`);
-		case "in_progress":
-			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${item.content}`);
-		default:
-			return uiTheme.fg("dim", `${prefix}${checkbox.unchecked} ${item.content}`);
+function formatSummary(phases: TodoPhase[], errors: string[]): string {
+	const tasks = phases.flatMap(p => p.tasks);
+	if (tasks.length === 0) return errors.length > 0 ? `Errors: ${errors.join("; ")}` : "Todo list cleared.";
+
+	// Find current phase
+	let currentIdx = phases.findIndex(p => p.tasks.some(t => t.status === "pending" || t.status === "in_progress"));
+	if (currentIdx === -1) currentIdx = phases.length - 1;
+	const current = phases[currentIdx];
+	const done = current.tasks.filter(t => t.status === "completed" || t.status === "abandoned").length;
+
+	const lines: string[] = [];
+	if (errors.length > 0) lines.push(`Errors: ${errors.join("; ")}`);
+	lines.push(
+		`Phase ${currentIdx + 1}/${phases.length} "${current.name}" — ${done}/${current.tasks.length} tasks complete`,
+	);
+	for (const phase of phases) {
+		lines.push(`  ${phase.name}:`);
+		for (const task of phase.tasks) {
+			const sym =
+				task.status === "completed"
+					? "✓"
+					: task.status === "in_progress"
+						? "→"
+						: task.status === "abandoned"
+							? "✗"
+							: "○";
+			lines.push(`    ${sym} ${task.id} ${task.content}`);
+		}
 	}
+	return lines.join("\n");
 }
 
 // =============================================================================
@@ -167,40 +301,15 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 		_onUpdate?: AgentToolUpdateCallback<TodoWriteToolDetails>,
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<TodoWriteToolDetails>> {
-		const todos = normalizeTodos(params.todos ?? []);
-		const validation = validateSequentialTodos(todos);
-		if (!validation.valid) {
-			throw new Error(validation.error ?? "Todos must be completed sequentially.");
-		}
-		const updatedAt = Date.now();
-
-		const sessionFile = this.session.getSessionFile();
-		if (!sessionFile) {
-			return {
-				content: [{ type: "text", text: formatTodoSummary(todos) }],
-				details: { todos, updatedAt, storage: "memory" },
-			};
-		}
-
-		const todoPath = path.join(sessionFile.slice(0, -6), TODO_FILE_NAME);
-		const existing = await loadTodoFile(todoPath);
-		const storedTodos = existing?.todos ?? [];
-		const merged = todos.length > 0 ? todos : [];
-		const fileData: TodoFile = { updatedAt, todos: merged };
-
-		try {
-			await Bun.write(todoPath, JSON.stringify(fileData, null, 2));
-		} catch (error) {
-			logger.error("Failed to write todo file", { path: todoPath, error: String(error) });
-			return {
-				content: [{ type: "text", text: "Failed to save todos." }],
-				details: { todos: storedTodos, updatedAt, storage: "session" },
-			};
-		}
+		const previousPhases = this.session.getTodoPhases?.() ?? [];
+		const current = fileFromPhases(previousPhases);
+		const { file: updated, errors } = applyOps(current, params.ops);
+		this.session.setTodoPhases?.(updated.phases);
+		const storage = this.session.getSessionFile() ? "session" : "memory";
 
 		return {
-			content: [{ type: "text", text: formatTodoSummary(merged) }],
-			details: { todos: merged, updatedAt, storage: "session" },
+			content: [{ type: "text", text: formatSummary(updated.phases, errors) }],
+			details: { phases: updated.phases, storage },
 		};
 	}
 }
@@ -210,14 +319,28 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 // =============================================================================
 
 interface TodoWriteRenderArgs {
-	todos?: Array<{ id?: string; content?: string; status?: string }>;
+	ops?: Array<{ op: string }>;
+}
+
+function formatTodoLine(item: TodoItem, uiTheme: Theme, prefix: string): string {
+	const checkbox = uiTheme.checkbox;
+	switch (item.status) {
+		case "completed":
+			return uiTheme.fg("success", `${prefix}${checkbox.checked} ${chalk.strikethrough(item.content)}`);
+		case "in_progress":
+			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${item.content}`);
+		case "abandoned":
+			return uiTheme.fg("error", `${prefix}${checkbox.unchecked} ${chalk.strikethrough(item.content)}`);
+		default:
+			return uiTheme.fg("dim", `${prefix}${checkbox.unchecked} ${item.content}`);
+	}
 }
 
 export const todoWriteToolRenderer = {
 	renderCall(args: TodoWriteRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const count = args.todos?.length ?? 0;
-		const meta = count > 0 ? [`${count} items`] : ["empty"];
-		const text = renderStatusLine({ icon: "pending", title: "Todo Write", meta }, uiTheme);
+		const count = args.ops?.length ?? 0;
+		const label = count === 1 ? (args.ops?.[0]?.op ?? "update") : `${count} ops`;
+		const text = renderStatusLine({ icon: "pending", title: "Todo Write", meta: [label] }, uiTheme);
 		return new Text(text, 0, 0);
 	},
 
@@ -227,29 +350,36 @@ export const todoWriteToolRenderer = {
 		uiTheme: Theme,
 		_args?: TodoWriteRenderArgs,
 	): Component {
-		const todos = result.details?.todos ?? [];
+		const phases = (result.details?.phases ?? []).filter(p => p.tasks.length > 0);
+		const allTasks = phases.flatMap(p => p.tasks);
 		const header = renderStatusLine(
-			{ icon: "success", title: "Todo Write", meta: [`${todos.length} items`] },
+			{ icon: "success", title: "Todo Write", meta: [`${allTasks.length} tasks`] },
 			uiTheme,
 		);
-		if (todos.length === 0) {
+		if (allTasks.length === 0) {
 			const fallback = result.content?.find(c => c.type === "text")?.text ?? "No todos";
 			return new Text(`${header}\n${uiTheme.fg("dim", fallback)}`, 0, 0);
 		}
 
 		const { expanded } = options;
-		const treeLines = renderTreeList(
-			{
-				items: todos,
-				expanded,
-				maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
-				itemType: "todo",
-				renderItem: todo => formatTodoLine(todo, uiTheme, ""),
-			},
-			uiTheme,
-		);
-		const text = [header, ...treeLines].join("\n");
-		return new Text(text, 0, 0);
+		const lines: string[] = [header];
+		for (const phase of phases) {
+			if (phases.length > 1) {
+				lines.push(uiTheme.fg("accent", `  ${uiTheme.tree.hook} ${phase.name}`));
+			}
+			const treeLines = renderTreeList(
+				{
+					items: phase.tasks,
+					expanded,
+					maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
+					itemType: "todo",
+					renderItem: todo => formatTodoLine(todo, uiTheme, ""),
+				},
+				uiTheme,
+			);
+			lines.push(...treeLines);
+		}
+		return new Text(lines.join("\n"), 0, 0);
 	},
 	mergeCallAndResult: true,
 };

package/src/internal-urls/plan-protocol.ts

@@ -1,95 +0,0 @@
-/**
- * Protocol handler for plan:// URLs.
- *
- * Resolves plan references to plan files under the plans directory.
- *
- * URL forms:
- * - plan://<sessionId> (defaults to plan.md)
- * - plan://<sessionId>/plan.md
- * - plan://<plan-id>.md (resolves directly under plans dir)
- */
-import * as path from "node:path";
-import { isEnoent } from "@oh-my-pi/pi-utils";
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
-
-export interface PlanProtocolOptions {
-	getPlansDirectory: (cwd?: string) => string;
-	cwd: string;
-}
-
-function parsePlanUrl(input: string): InternalUrl {
-	let parsed: URL;
-	try {
-		parsed = new URL(input);
-	} catch {
-		throw new Error(`Invalid URL: ${input}`);
-	}
-
-	const hostMatch = input.match(/^([a-z][a-z0-9+.-]*):\/\/([^/?#]*)/i);
-	let rawHost = hostMatch ? hostMatch[2] : parsed.hostname;
-	try {
-		rawHost = decodeURIComponent(rawHost);
-	} catch {
-		// Leave rawHost as-is if decoding fails.
-	}
-	(parsed as InternalUrl).rawHost = rawHost;
-	return parsed as InternalUrl;
-}
-
-function normalizeRelativePath(host: string, pathname: string): string {
-	const trimmedHost = host.replace(/^\/+/, "").replace(/\/+$/, "");
-	const trimmedPath = pathname.replace(/^\/+/, "");
-
-	if (!trimmedHost) {
-		throw new Error("plan:// URL requires a session or plan identifier");
-	}
-
-	if (trimmedPath) {
-		return path.join(trimmedHost, trimmedPath);
-	}
-
-	if (trimmedHost.endsWith(".md")) {
-		return trimmedHost;
-	}
-
-	return path.join(trimmedHost, "plan.md");
-}
-
-export function resolvePlanUrlToPath(input: string | InternalUrl, options: PlanProtocolOptions): string {
-	const url = typeof input === "string" ? parsePlanUrl(input) : input;
-	const host = url.rawHost || url.hostname;
-	const relativePath = normalizeRelativePath(host, url.pathname ?? "");
-	const plansDir = path.resolve(options.getPlansDirectory(options.cwd));
-	const resolved = path.resolve(plansDir, relativePath);
-
-	if (resolved !== plansDir && !resolved.startsWith(`${plansDir}${path.sep}`)) {
-		throw new Error("plan:// URL escapes the plans directory");
-	}
-
-	return resolved;
-}
-
-export class PlanProtocolHandler implements ProtocolHandler {
-	readonly scheme = "plan";
-
-	constructor(private readonly options: PlanProtocolOptions) {}
-
-	async resolve(url: InternalUrl): Promise<InternalResource> {
-		const planPath = resolvePlanUrlToPath(url, this.options);
-		try {
-			const content = await Bun.file(planPath).text();
-			return {
-				url: url.href,
-				content,
-				contentType: "text/markdown",
-				size: Buffer.byteLength(content, "utf-8"),
-				sourcePath: planPath,
-			};
-		} catch (error) {
-			if (isEnoent(error)) {
-				throw new Error(`Plan file not found: ${url.href}`);
-			}
-			throw error;
-		}
-	}
-}