@vitos-pizza/vitos-pizza 0.1.0 → 0.2.0

package/packages/todoist/src/state.ts

@@ -0,0 +1,147 @@
+import type { TodoItem, TodoListFilter, TodoPriority, TodoSnapshot, TodoStatus, TodoStoreEvents } from "./types.ts";
+
+let nextId = 1;
+
+function generateId(): string {
+	return String(nextId++);
+}
+
+function now(): string {
+	return new Date().toISOString();
+}
+
+export class TodoStore {
+	private items = new Map<string, TodoItem>();
+	private events: TodoStoreEvents = {};
+
+	constructor(events?: TodoStoreEvents) {
+		this.events = events ?? {};
+	}
+
+	setOnChange(cb: (snapshot: TodoSnapshot) => void): void {
+		this.events.onChange = cb;
+	}
+
+	add(text: string, priority: TodoPriority = 3, project?: string): TodoItem {
+		const item: TodoItem = {
+			id: generateId(),
+			text,
+			status: "pending",
+			priority,
+			project,
+			createdAt: now(),
+			updatedAt: now(),
+		};
+		this.items.set(item.id, item);
+		this.emitChange();
+		return item;
+	}
+
+	list(filter?: TodoListFilter): TodoItem[] {
+		let result = Array.from(this.items.values());
+
+		if (filter?.status && filter.status !== "all") {
+			result = result.filter((t) => {
+				if (filter.status === "active") return t.status !== "done";
+				if (filter.status === "done") return t.status === "done";
+				return true;
+			});
+		}
+
+		if (filter?.project) {
+			result = result.filter((t) => t.project === filter.project);
+		}
+
+		return result.sort((a, b) => {
+			// Sort by: pending first, in_progress, done last; then by creation time
+			const statusOrder = { pending: 0, in_progress: 1, done: 2 };
+			const aOrder = statusOrder[a.status];
+			const bOrder = statusOrder[b.status];
+			if (aOrder !== bOrder) return aOrder - bOrder;
+			return a.createdAt.localeCompare(b.createdAt);
+		});
+	}
+
+	get(id: string): TodoItem | undefined {
+		return this.items.get(id);
+	}
+
+	update(
+		id: string,
+		changes: { text?: string; status?: TodoStatus; priority?: TodoPriority; project?: string },
+	): TodoItem | null {
+		const item = this.items.get(id);
+		if (!item) return null;
+
+		if (changes.text !== undefined) item.text = changes.text;
+		if (changes.status !== undefined) item.status = changes.status;
+		if (changes.priority !== undefined) item.priority = changes.priority;
+		if (changes.project !== undefined) item.project = changes.project;
+		item.updatedAt = now();
+
+		// Claude Code: when every remaining task is done, clear the list for the next round
+		this.clearIfAllDone();
+		this.emitChange();
+		return item;
+	}
+
+	remove(id: string): boolean {
+		const result = this.items.delete(id);
+		if (result) this.emitChange();
+		return result;
+	}
+
+	clear(): void {
+		this.items.clear();
+		this.emitChange();
+	}
+
+	getSnapshot(): TodoSnapshot {
+		const todos = Array.from(this.items.values());
+		return {
+			todos,
+			totalCount: todos.length,
+			doneCount: todos.filter((t) => t.status === "done").length,
+			todoistConnected: false,
+		};
+	}
+
+	/**
+	 * Rebuild state from a series of historical tool calls (conversation replay).
+	 * Each entry should have: { toolName, input, result }
+	 */
+	restoreFromHistory(
+		entries: Array<{ toolName: string; input: Record<string, unknown>; result?: Record<string, unknown> }>,
+	): void {
+		// Clear and reset id counter
+		this.items.clear();
+		nextId = 1;
+
+		for (const entry of entries) {
+			const details = entry.result?.details as { todos?: TodoItem[] } | undefined;
+			if (!details?.todos) continue;
+			// Use the full snapshot from the last entry — replay forward
+			for (const todo of details.todos) {
+				const idNum = Number.parseInt(todo.id, 10);
+				if (idNum >= nextId) nextId = idNum + 1;
+				this.items.set(todo.id, { ...todo });
+			}
+		}
+	}
+
+	getTodoistConnected(): boolean {
+		return false;
+	}
+
+	/** After a mutation: if every remaining item is done, clear the list (Claude Code). */
+	private clearIfAllDone(): void {
+		if (this.items.size === 0) return;
+		if ([...this.items.values()].every((t) => t.status === "done")) {
+			this.items.clear();
+		}
+	}
+
+	private emitChange(): void {
+		this.events.onChange?.(this.getSnapshot());
+	}
+}

package/packages/todoist/src/tools.ts

@@ -0,0 +1,175 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import type { TodoStore } from "./state.ts";
+
+/** Debug-visible result — short text in transcript; full snapshot in details for replay */
+function silentResult(
+	snap: ReturnType<TodoStore["getSnapshot"]>,
+	summary: string,
+) {
+	return {
+		content: [{ type: "text" as const, text: summary }],
+		details: { todos: snap.todos, totalCount: snap.totalCount, doneCount: snap.doneCount },
+	};
+}
+
+/** Shared complete-vs-delete boundary (Claude Code style). */
+const COMPLETE_VS_DELETE = [
+	"Complete finished work with todo_update status 'done' (shows ☑). Do not use todo_remove to mark work finished.",
+	"When every task in the list is done, the list clears automatically — then start the next multi-step request with fresh todo_add calls.",
+	"Use todo_remove only for cancelled, duplicate, mistaken, or no-longer-relevant tasks.",
+] as const;
+
+export function registerTodoistTools(pi: ExtensionAPI, store: TodoStore): void {
+	pi.registerTool({
+		name: "todo_add",
+		label: "Add Todo",
+		description: "Create a new task in the in-memory todo list.",
+		promptSnippet: "Add a task to the todo list",
+		promptGuidelines: [
+			"Use todo_add when you need to create a new task to track",
+			"After a previous list was fully completed (auto-cleared), start the next multi-step request with fresh todo_add calls",
+			"Priority: 1 (urgent), 2 (high), 3 (normal), 4 (low)",
+			"Project is optional — use it to group related tasks",
+		],
+		parameters: Type.Object({
+			text: Type.String({ description: "Task description" }),
+			priority: Type.Optional(
+				Type.Number({ description: "Priority 1-4 (1=urgent, 4=low)", default: 3 }),
+			),
+			project: Type.Optional(
+				Type.String({ description: "Optional project/group name" }),
+			),
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const input = params as { text: string; priority?: number; project?: string };
+			store.add(
+				input.text,
+				(input.priority ?? 3) as 1 | 2 | 3 | 4,
+				input.project,
+			);
+			const snap = store.getSnapshot();
+			return silentResult(snap, `added: ${input.text} (${snap.totalCount} total)`);
+		},
+	});
+
+	pi.registerTool({
+		name: "todo_list",
+		label: "List Todos",
+		description:
+			"List all tasks in the todo list, optionally filtered by status or project.",
+		promptSnippet: "List tasks from the todo list",
+		promptGuidelines: [
+			"Use todo_list to see current tasks",
+			"Filter by 'active' to see only unfinished tasks",
+			"Filter by 'done' to see completed tasks",
+		],
+		parameters: Type.Object({
+			filter: Type.Optional(
+				StringEnum(["all", "active", "done"] as const, {
+					description: "Filter by status",
+					default: "all",
+				}),
+			),
+			project: Type.Optional(
+				Type.String({ description: "Filter by project name" }),
+			),
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const input = params as {
+				filter?: "all" | "active" | "done";
+				project?: string;
+			};
+			const listed = store.list({
+				status: input.filter ?? "all",
+				project: input.project,
+			});
+			const snap = store.getSnapshot();
+			return silentResult(
+				snap,
+				`listed ${listed.length} (filter=${input.filter ?? "all"})`,
+			);
+		},
+	});
+
+	pi.registerTool({
+		name: "todo_update",
+		label: "Update Todo",
+		description:
+			"Update a task's text, status, or priority. Set status to 'done' when work is finished (checked off). When all tasks are done, the list clears automatically.",
+		promptSnippet: "Update a task in the todo list",
+		promptGuidelines: [
+			"Use todo_update to mark tasks done, change priority, or edit text",
+			"When work is finished, set status to 'done' immediately — do not batch completions",
+			"Set status to 'in_progress' when starting work on a task (ideally one at a time)",
+			...COMPLETE_VS_DELETE,
+		],
+		parameters: Type.Object({
+			id: Type.String({ description: "Task ID to update" }),
+			text: Type.Optional(Type.String({ description: "New task text" })),
+			status: Type.Optional(
+				StringEnum(["pending", "in_progress", "done"] as const, {
+					description: "New status",
+				}),
+			),
+			priority: Type.Optional(
+				Type.Number({ description: "New priority 1-4" }),
+			),
+			project: Type.Optional(
+				Type.String({ description: "New project name" }),
+			),
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const input = params as {
+				id: string;
+				text?: string;
+				status?: "pending" | "in_progress" | "done";
+				priority?: number;
+				project?: string;
+			};
+			const item = store.update(input.id, {
+				text: input.text,
+				status: input.status,
+				priority: input.priority as 1 | 2 | 3 | 4 | undefined,
+				project: input.project,
+			});
+			if (!item) {
+				return silentResult(
+					{ todos: [], totalCount: 0, doneCount: 0, todoistConnected: false },
+					`update failed: id=${input.id} not found`,
+				);
+			}
+			const snap = store.getSnapshot();
+			const bits = [
+				input.status ? `status=${input.status}` : null,
+				input.text ? `text=${input.text}` : null,
+			].filter(Boolean);
+			return silentResult(
+				snap,
+				`updated #${input.id}${bits.length ? ` (${bits.join(", ")})` : ""}`,
+			);
+		},
+	});
+
+	pi.registerTool({
+		name: "todo_remove",
+		label: "Remove Todo",
+		description:
+			"Permanently delete a task that is cancelled, duplicate, mistaken, or no longer relevant. Do not use this to mark finished work — use todo_update with status 'done' instead.",
+		promptSnippet: "Permanently delete a no-longer-relevant task",
+		promptGuidelines: [
+			...COMPLETE_VS_DELETE,
+			"Only call todo_remove when the user cancels the task, the plan changed, the item was a duplicate/mistake, or they explicitly ask to delete it",
+		],
+		parameters: Type.Object({
+			id: Type.String({ description: "Task ID to permanently delete" }),
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const input = params as { id: string };
+			store.remove(input.id);
+			const snap = store.getSnapshot();
+			return silentResult(snap, `removed #${input.id} (${snap.totalCount} left)`);
+		},
+	});
+}

package/packages/todoist/src/types.ts

@@ -0,0 +1,34 @@
+/** Priority: 1 = highest (p1), 4 = lowest (p4) */
+export type TodoPriority = 1 | 2 | 3 | 4;
+
+export type TodoStatus = "pending" | "in_progress" | "done";
+
+export interface TodoItem {
+	id: string;
+	text: string;
+	status: TodoStatus;
+	priority: TodoPriority;
+	project?: string;
+	createdAt: string;
+	updatedAt: string;
+}
+
+/**
+ * Full snapshot carried in tool call details.
+ * Used for conversation replay to rebuild in-memory state.
+ */
+export interface TodoSnapshot {
+	todos: TodoItem[];
+	totalCount: number;
+	doneCount: number;
+	todoistConnected: boolean;
+}
+
+export interface TodoListFilter {
+	status?: "all" | "active" | "done";
+	project?: string;
+}
+
+export interface TodoStoreEvents {
+	onChange?: (snapshot: TodoSnapshot) => void;
+}

package/packages/todoist/src/widget.ts

@@ -0,0 +1,109 @@
+import type { TodoItem, TodoSnapshot } from "./types.ts";
+
+export type WidgetTheme = {
+	fg: (color: string, text: string) => string;
+	bold: (text: string) => string;
+};
+
+const MAX_WIDGET_ROWS = 10;
+
+function formatElapsed(updatedAt: string, nowMs = Date.now()): string {
+	const diff = nowMs - new Date(updatedAt).getTime();
+	const secs = Math.floor(diff / 1000);
+	if (secs < 60) return `${secs}s`;
+	const mins = Math.floor(secs / 60);
+	if (mins < 60) return `${mins}m`;
+	const hrs = Math.floor(mins / 60);
+	return `${hrs}h ${mins % 60}m`;
+}
+
+function sortForWidget(todos: TodoItem[]): TodoItem[] {
+	const statusOrder = { in_progress: 0, pending: 1, done: 2 } as const;
+	return [...todos].sort((a, b) => {
+		const orderDiff = statusOrder[a.status] - statusOrder[b.status];
+		if (orderDiff !== 0) return orderDiff;
+		return a.createdAt.localeCompare(b.createdAt);
+	});
+}
+
+function formatMeta(todo: TodoItem, theme: WidgetTheme, nowMs: number): string {
+	const parts: Array<string | null> = [];
+	if (todo.status === "in_progress") {
+		parts.push(formatElapsed(todo.updatedAt, nowMs));
+	}
+	if (todo.priority <= 2) parts.push(`p${todo.priority}`);
+	if (todo.project) parts.push(todo.project);
+	const meta = parts.filter(Boolean).join(" · ");
+	return meta ? ` ${theme.fg("dim", meta)}` : "";
+}
+
+function formatTodoLine(todo: TodoItem, theme: WidgetTheme, nowMs: number): string {
+	const metaStr = formatMeta(todo, theme, nowMs);
+	if (todo.status === "in_progress") {
+		return `  ${theme.fg("warning", "✳")} ${theme.fg("text", todo.text)}${metaStr}`;
+	}
+	if (todo.status === "done") {
+		return `  ${theme.fg("muted", "☑")} ${theme.fg("muted", todo.text)}${metaStr}`;
+	}
+	return `  ${theme.fg("muted", "◻")} ${theme.fg("text", todo.text)}${metaStr}`;
+}
+
+export type TodoWidgetView = {
+	lines: string[] | undefined;
+	status: string | undefined;
+};
+
+/**
+ * Build widget lines + status for the current snapshot.
+ * Done tasks stay visible with ☑; widget clears only when the list is empty.
+ */
+export function buildTodoWidgetView(
+	snapshot: TodoSnapshot,
+	theme: WidgetTheme,
+	nowMs = Date.now(),
+): TodoWidgetView {
+	if (snapshot.todos.length === 0) {
+		return { lines: undefined, status: undefined };
+	}
+
+	const activeTodos = snapshot.todos.filter((t) => t.status !== "done");
+	const doneCount = snapshot.doneCount;
+	const sorted = sortForWidget(snapshot.todos);
+	const visible = sorted.slice(0, MAX_WIDGET_ROWS);
+	const hidden = sorted.length - visible.length;
+
+	const lines: string[] = [];
+	const headerIcon = activeTodos.some((t) => t.status === "in_progress")
+		? "●"
+		: activeTodos.length > 0
+			? "○"
+			: "☑";
+
+	if (activeTodos.length > 0) {
+		lines.push(
+			theme.fg(
+				"accent",
+				`${headerIcon} ${activeTodos.length} task${activeTodos.length > 1 ? "s" : ""}`,
+			) + (doneCount > 0 ? theme.fg("muted", ` (${doneCount} done)`) : ""),
+		);
+	} else {
+		lines.push(
+			theme.fg("muted", `☑ ${doneCount} done`),
+		);
+	}
+
+	for (const todo of visible) {
+		lines.push(formatTodoLine(todo, theme, nowMs));
+	}
+
+	if (hidden > 0) {
+		lines.push(`  ${theme.fg("dim", `⋯ and ${hidden} more`)}`);
+	}
+
+	const status =
+		activeTodos.length > 0
+			? theme.fg("accent", `● ${activeTodos.length}`)
+			: theme.fg("muted", `☑ ${doneCount}`);
+
+	return { lines, status };
+}

package/packages/todoist/tsconfig.json

@@ -0,0 +1,13 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"allowImportingTsExtensions": true
+	},
+	"include": [
+		"extensions/**/*.ts",
+		"src/**/*.ts",
+		"tests/**/*.ts",
+		"vitest.config.ts"
+	],
+	"exclude": ["node_modules"]
+}

package/packages/todoist/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		environment: "node",
+		include: ["tests/**/*.test.ts"],
+	},
+});

package/packages/ui-enhancements/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitos-pizza/ui-enhancements",
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"description": "TUI and UI enhancements for Vito's Pizzeria Pi distribution",
 	"type": "module",
 	"license": "MIT",

package/packages/ui-enhancements/src/chrome/agent-mode-badge.ts

@@ -1,60 +1,60 @@
-import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
-
-export const AGENT_MODE_CHANGED = "agent-mode:changed";
-
-export type AgentModeDisplayColor = "dim" | "accent" | "warning";
-
-export interface AgentModeChangedPayload {
-	mode: "agent" | "plan" | "execute";
-	label: string;
-	color: AgentModeDisplayColor;
-}
-
-let currentAgentMode: AgentModeChangedPayload | null = null;
-
-function isPayload(value: unknown): value is AgentModeChangedPayload {
-	if (!value || typeof value !== "object") return false;
-	const payload = value as Partial<AgentModeChangedPayload>;
-	return (
-		(payload.mode === "agent" ||
-			payload.mode === "plan" ||
-			payload.mode === "execute") &&
-		typeof payload.label === "string" &&
-		(payload.color === "dim" ||
-			payload.color === "accent" ||
-			payload.color === "warning")
-	);
-}
-
-export function getAgentModeBadge(): AgentModeChangedPayload | null {
-	return currentAgentMode;
-}
-
-export function formatAgentModeSuffix(
-	payload: AgentModeChangedPayload | null,
-	theme: Theme,
-): string {
-	if (!payload || payload.mode === "agent") return "";
-	return theme.fg(payload.color, ` · ${payload.label}`);
-}
-
-export function registerAgentModeBadge(
-	pi: ExtensionAPI,
-	requestRender: () => void,
-): () => void {
-	const unsubChanged = pi.events.on(AGENT_MODE_CHANGED, (value) => {
-		if (!isPayload(value)) return;
-		currentAgentMode = value;
-		requestRender();
-	});
-
-	pi.on("session_shutdown", () => {
-		currentAgentMode = null;
-	});
-
-	return unsubChanged;
-}
-
-export function resetAgentModeBadgeForTests(): void {
-	currentAgentMode = null;
-}
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+
+export const AGENT_MODE_CHANGED = "agent-mode:changed";
+
+export type AgentModeDisplayColor = "dim" | "accent" | "warning";
+
+export interface AgentModeChangedPayload {
+	mode: "agent" | "plan" | "execute";
+	label: string;
+	color: AgentModeDisplayColor;
+}
+
+let currentAgentMode: AgentModeChangedPayload | null = null;
+
+function isPayload(value: unknown): value is AgentModeChangedPayload {
+	if (!value || typeof value !== "object") return false;
+	const payload = value as Partial<AgentModeChangedPayload>;
+	return (
+		(payload.mode === "agent" ||
+			payload.mode === "plan" ||
+			payload.mode === "execute") &&
+		typeof payload.label === "string" &&
+		(payload.color === "dim" ||
+			payload.color === "accent" ||
+			payload.color === "warning")
+	);
+}
+
+export function getAgentModeBadge(): AgentModeChangedPayload | null {
+	return currentAgentMode;
+}
+
+export function formatAgentModeSuffix(
+	payload: AgentModeChangedPayload | null,
+	theme: Theme,
+): string {
+	if (!payload || payload.mode === "agent") return "";
+	return theme.fg(payload.color, ` · ${payload.label}`);
+}
+
+export function registerAgentModeBadge(
+	pi: ExtensionAPI,
+	requestRender: () => void,
+): () => void {
+	const unsubChanged = pi.events.on(AGENT_MODE_CHANGED, (value) => {
+		if (!isPayload(value)) return;
+		currentAgentMode = value;
+		requestRender();
+	});
+
+	pi.on("session_shutdown", () => {
+		currentAgentMode = null;
+	});
+
+	return unsubChanged;
+}
+
+export function resetAgentModeBadgeForTests(): void {
+	currentAgentMode = null;
+}

package/packages/ui-enhancements/src/chrome/border-status.ts

@@ -8,12 +8,13 @@ import type { Component, EditorTheme, TUI } from "@earendil-works/pi-tui";
 import type { UiEnhancementsSettings } from "../config.ts";
 import { loadUiEnhancementsSettings } from "../config.ts";
 import { shortenPath } from "../utils/shorten-path.ts";
-import { fitBorder } from "./format-border.ts";
 import {
 	formatAgentModeSuffix,
 	getAgentModeBadge,
 	registerAgentModeBadge,
 } from "./agent-mode-badge.ts";
+import { fitBorder } from "./format-border.ts";
+import { attachResizeRecovery } from "./resize-recovery.ts";
 
 type GetSettings = () => UiEnhancementsSettings;
 
@@ -46,6 +47,7 @@ export function registerBorderStatusBar(
 	let spinnerIndex = 0;
 	let spinnerTimer: ReturnType<typeof setInterval> | undefined;
 	let activeTui: TUI | undefined;
+	let detachResizeRecovery: (() => void) | undefined;
 	const spinnerFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
 	const stopSpinner = () => {
@@ -55,6 +57,11 @@ export function registerBorderStatusBar(
 		}
 	};
 
+	const stopResizeRecovery = () => {
+		detachResizeRecovery?.();
+		detachResizeRecovery = undefined;
+	};
+
 	pi.on("agent_start", () => {
 		isWorking = true;
 		stopSpinner();
@@ -73,6 +80,7 @@ export function registerBorderStatusBar(
 
 	pi.on("session_shutdown", () => {
 		stopSpinner();
+		stopResizeRecovery();
 		activeTui = undefined;
 	});
 
@@ -84,6 +92,11 @@ export function registerBorderStatusBar(
 		const settings = loadUiEnhancementsSettings(ctx.cwd);
 		if (!settings.borderStatusBar || !ctx.hasUI || ctx.mode !== "tui") return;
 
+		stopResizeRecovery();
+		detachResizeRecovery = attachResizeRecovery({
+			getTarget: () => activeTui,
+		});
+
 		ctx.ui.setWorkingVisible(false);
 		ctx.ui.setFooter(() => new EmptyFooter());