@leo-alvarenga/pi-todo-list 0.4.2 → 0.5.3

package/README.md

@@ -11,7 +11,7 @@ The agent manages tasks with a `todo` tool while you watch them live in a panel
   self-blocks, dependency cycles) are rejected before any state change.
 - **Live TUI panel** above the input editor — a header line with a
   collapse/expand chevron and per-status counters, Nerd Font status glyphs
-  (  pending, 󱥸  in-progress,   completed), blocked-task hints, and a hardcoded
+  ( pending, 󱥸 in-progress,  completed), blocked-task hints, and a hardcoded
   8-row budget with a `… +N more` summary line. The panel hides itself
   entirely while the list is empty.
 - **Toggle with `Alt+T`** — collapsed by default; collapsed shows just the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leo-alvarenga/pi-todo-list",
-  "version": "0.4.2",
+  "version": "0.5.3",
   "description": "Session-aware todo list overlay for Pi: todo tool, /todos command, and a live TUI panel",
   "license": "MIT",
   "repository": "github.com/leo-alvarenga/pi-mono",
@@ -26,6 +26,9 @@
     "@earendil-works/pi-tui": "*",
     "typebox": "*"
   },
+  "dependencies": {
+    "@leo-alvarenga/pi-ext-core": "^0.3.2"
+  },
   "pi": {
     "extensions": [
       "./src/index.ts"

package/skills/track-progress.md

@@ -10,4 +10,4 @@ Track work with the todo tools unless the user explicitly says not to:
 - `todo add` — record each item the user wants tracked (text or texts).
 - `todo update` — set `status: completed` as items finish; update status on every progress change (in-progress, blocked, …).
 - `todo remove` — drop tasks that are no longer relevant.
-- "complete everything" / "done with all" → `todo_complete_all`, not a loop of `todo update`.
+- "complete everything" / "done with all" → `todo_complete_all`, not a loop of `todo update`.

package/src/command.ts

@@ -1,7 +1,8 @@
 import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 
-import { groupByStatus } from "./core";
+import { applyAction } from "./core";
+import { groupByStatus } from "./query";
 import { REPORT_ENTRY } from "./constants";
 import type { TodoStore } from "./state";
 import type { Todo } from "./types";
@@ -42,6 +43,25 @@ export function registerTodosCommand(pi: ExtensionAPI, store: TodoStore): void {
     },
   });
 
+  pi.registerCommand("todos-clear", {
+    description: "Manually clears all todos",
+    handler: async (_args, ctx) => {
+      const state = store.getState(ctx);
+      if (!state.todos.length) return;
+
+      const result = applyAction(state, {
+        action: "clear",
+      });
+
+      if (!result.ok) {
+        ctx.ui.notify("Could not clear todos", "error");
+        return;
+      }
+
+      store.commit(ctx, result.state);
+    },
+  });
+
   pi.registerEntryRenderer<{ todos: Todo[] }>(
     REPORT_ENTRY,
     (entry, _options, theme) => {

package/src/core.ts

@@ -1,5 +1,6 @@
 import { MAX_TEXT_LENGTH } from "./constants";
 import type { Todo, TodoAction, TodoState, TodoStatus } from "./types";
+import { wouldCreateCycle } from "./query";
 
 export type Patch = {
   text?: string;
@@ -129,37 +130,6 @@ function remove(state: TodoState, id: number): ActionResult {
   };
 }
 
-const blockedSuffix = (t: Todo, todos: Todo[]): string => {
-  const waiting = t.blockedBy.filter((b) => {
-    const bt = todos.find((x) => x.id === b);
-
-    return !bt || bt.status !== "completed";
-  });
-
-  if (waiting.length > 0) {
-    return ` (blocked by ${waiting.map((b) => `#${b}`).join(", ")})`;
-  }
-
-  return "";
-};
-
-function list(state: TodoState): ActionResult {
-  if (state.todos.length === 0) {
-    return { ok: true, state, text: "No todos" };
-  }
-
-  return {
-    state,
-    ok: true,
-    text: state.todos
-      .map(
-        (t) =>
-          `[${t.status === "completed" ? "x" : " "}] #${t.id}: ${t.text}${blockedSuffix(t, state.todos)}`,
-      )
-      .join("\n"),
-  };
-}
-
 function clear(): ActionResult {
   return {
     ok: true,
@@ -170,7 +140,8 @@ function clear(): ActionResult {
 
 function addMany(state: TodoState, texts: string[]): ActionResult {
   const cleaned = texts.map(cleanText);
-  if (cleaned.some((t) => !t)) return { ok: false, error: "text required for add" };
+  if (cleaned.some((t) => !t))
+    return { ok: false, error: "text required for add" };
   if (cleaned.some((t) => t && t.length > MAX_TEXT_LENGTH)) return textError();
 
   let nextId = state.nextId;
@@ -206,10 +177,6 @@ function removeMany(state: TodoState, ids: number[]): ActionResult {
   };
 }
 
-/**
- * Apply a tool action against a copy of the state.
- * Returns the new state only when validation passes; the caller commits it.
- */
 export function applyAction(
   state: TodoState,
   params: {
@@ -224,7 +191,8 @@ export function applyAction(
 ): ActionResult {
   switch (params.action) {
     case "add":
-      if (params.texts !== undefined && params.texts.length > 0) return addMany(state, params.texts);
+      if (params.texts !== undefined && params.texts.length > 0)
+        return addMany(state, params.texts);
       return add(state, params.text ?? "");
 
     case "update":
@@ -235,7 +203,8 @@ export function applyAction(
       return update(state, params.id, params);
 
     case "remove":
-      if (params.ids !== undefined && params.ids.length > 0) return removeMany(state, params.ids);
+      if (params.ids !== undefined && params.ids.length > 0)
+        return removeMany(state, params.ids);
       if (params.id === undefined) {
         return { ok: false, error: "id required for remove" };
       }
@@ -243,57 +212,24 @@ export function applyAction(
       return remove(state, params.id);
 
     case "list":
-      return list(state);
+      return { ...list(state), ok: true, state };
 
     case "clear":
-      return clear();
+      return clear() as any;
   }
 }
 
-/**
- * True if `changedId` can reach itself by following blockedBy edges
- * (direct, or through a chain) — i.e. the update would create a cycle.
- */
-export function wouldCreateCycle(todos: Todo[], changedId: number): boolean {
-  const adj = new Map<number, number[]>();
-  for (const t of todos) adj.set(t.id, [...t.blockedBy]);
-
-  const done = new Set<number>();
-  const visiting = new Set<number>();
-
-  const dfs = (id: number): boolean => {
-    if (visiting.has(id)) return true;
-    if (done.has(id)) return false;
-
-    visiting.add(id);
-
-    for (const dep of adj.get(id) ?? []) {
-      if (dfs(dep)) return true;
-    }
-
-    visiting.delete(id);
-    done.add(id);
-
-    return false;
-  };
-
-  return dfs(changedId);
-}
-
-export function groupByStatus(todos: Todo[]): {
-  completed: Todo[];
-  inProgress: Todo[];
-  pending: Todo[];
-} {
-  const completed: Todo[] = [];
-  const inProgress: Todo[] = [];
-  const pending: Todo[] = [];
-
-  for (const t of todos) {
-    if (t.status === "completed") completed.push(t);
-    else if (t.status === "in-progress") inProgress.push(t);
-    else pending.push(t);
+function list(state: TodoState): { text: string } {
+  if (state.todos.length === 0) {
+    return { text: "No todos" };
   }
 
-  return { completed, inProgress, pending };
+  return {
+    text: state.todos
+      .map(
+        (t) =>
+          `[${t.status === "completed" ? "x" : " "}] #${t.id}: ${t.text}`,
+      )
+      .join("\n"),
+  };
 }

package/src/index.ts

@@ -4,23 +4,30 @@ import { registerTodosCommand } from "./command";
 import { STATE_ENTRY, WIDGET_KEY } from "./constants";
 import { TodoStore } from "./state";
 import { registerTodoTool, registerTodoCompleteAllTool } from "./tool";
-import { registerTodoWidget, refreshWidget } from "./widget";
+import { registerTodoWidget } from "./widget";
 
 export default function (pi: ExtensionAPI): void {
   const store = new TodoStore(
     (snapshot) => pi.appendEntry(STATE_ENTRY, snapshot),
-    (ctx) => refreshWidget(ctx, store),
+    undefined,
   );
 
+  const panelControls = registerTodoWidget(pi, store);
+
   registerTodoTool(pi, store);
   registerTodoCompleteAllTool(pi, store);
   registerTodosCommand(pi, store);
-  registerTodoWidget(pi, store);
 
-  pi.on("session_start", (_event, ctx) => store.replay(ctx));
-  pi.on("session_tree", (_event, ctx) => store.replay(ctx));
+  pi.on("session_start", (_event, ctx) => {
+    store.replay(ctx);
+    panelControls.refresh(ctx);
+  });
+  pi.on("session_tree", (_event, ctx) => {
+    store.replay(ctx);
+    panelControls.refresh(ctx);
+  });
   pi.on("session_before_compact", (_event, ctx) => store.persistSnapshot(ctx));
   pi.on("session_shutdown", (_event, ctx) => {
     if (ctx.hasUI) ctx.ui.setWidget(WIDGET_KEY, undefined);
   });
-}
+}

package/src/query.ts

@@ -0,0 +1,73 @@
+import type { Todo, TodoState } from "./types";
+
+const blockedSuffix = (t: Todo, todos: Todo[]): string => {
+  const waiting = t.blockedBy.filter((b) => {
+    const bt = todos.find((x) => x.id === b);
+    return !bt || bt.status !== "completed";
+  });
+
+  if (waiting.length > 0) {
+    return ` (blocked by ${waiting.map((b) => `#${b}`).join(", ")})`;
+  }
+
+  return "";
+};
+
+export function list(state: TodoState): { text: string } {
+  if (state.todos.length === 0) {
+    return { text: "No todos" };
+  }
+
+  return {
+    text: state.todos
+      .map(
+        (t) =>
+          `[${t.status === "completed" ? "x" : " "}] #${t.id}: ${t.text}${blockedSuffix(t, state.todos)}`,
+      )
+      .join("\n"),
+  };
+}
+
+export function wouldCreateCycle(todos: Todo[], changedId: number): boolean {
+  const adj = new Map<number, number[]>();
+  for (const t of todos) adj.set(t.id, [...t.blockedBy]);
+
+  const done = new Set<number>();
+  const visiting = new Set<number>();
+
+  const dfs = (id: number): boolean => {
+    if (visiting.has(id)) return true;
+    if (done.has(id)) return false;
+
+    visiting.add(id);
+
+    for (const dep of adj.get(id) ?? []) {
+      if (dfs(dep)) return true;
+    }
+
+    visiting.delete(id);
+    done.add(id);
+
+    return false;
+  };
+
+  return dfs(changedId);
+}
+
+export function groupByStatus(todos: Todo[]): {
+  completed: Todo[];
+  inProgress: Todo[];
+  pending: Todo[];
+} {
+  const completed: Todo[] = [];
+  const inProgress: Todo[] = [];
+  const pending: Todo[] = [];
+
+  for (const t of todos) {
+    if (t.status === "completed") completed.push(t);
+    else if (t.status === "in-progress") inProgress.push(t);
+    else pending.push(t);
+  }
+
+  return { completed, inProgress, pending };
+}

package/src/state.ts

@@ -1,82 +1,45 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
+import { createSessionStore, SessionRecordStore } from "@leo-alvarenga/pi-ext-core";
+
 import { STATE_ENTRY } from "./constants";
 import type { TodoDetails, TodoState } from "./types";
 
-/**
- * Session-scoped todo state.
- *
- * State is keyed by the active session id so forked/parallel sessions never
- * overwrite each other, and it is replayed from the session branch on every
- * session event, so it survives /reload and compaction without the extension
- * writing any of its own files.
- */
 export class TodoStore {
-  private readonly stateBySession = new Map<string, TodoState>();
+  private store: SessionRecordStore<TodoState>;
 
   constructor(
     private readonly persist: (snapshot: TodoState) => void,
-    private readonly emitChange: (ctx: ExtensionContext) => void,
-  ) {}
-
-  private sid(ctx: ExtensionContext): string {
-    return ctx.sessionManager.getSessionId();
+    private readonly onRefresh?: (ctx: ExtensionContext) => void,
+  ) {
+    this.store = createSessionStore<TodoState>({
+      empty: () => ({ todos: [], nextId: 1 }),
+      entryType: STATE_ENTRY,
+      snapshotOf: (entry) => {
+        if (entry.type === "custom" && entry.customType === STATE_ENTRY) {
+          return entry.data as TodoState | undefined;
+        }
+      },
+      onChange: (state, ctx) => {
+        this.persist(state);
+        this.onRefresh?.(ctx);
+      },
+    });
   }
 
   getState(ctx: ExtensionContext): TodoState {
-    const sid = this.sid(ctx);
-
-    let s = this.stateBySession.get(sid);
-    if (!s) this.stateBySession.set(sid, (s = { todos: [], nextId: 1 }));
-
-    return s;
+    return this.store.getState(ctx);
   }
 
-  /** Commit a validated snapshot: update memory, persist, refresh the panel. */
-  commit(ctx: ExtensionContext, next: TodoState): void {
-    this.stateBySession.set(this.sid(ctx), next);
-    this.persist(next);
-    this.emitChange(ctx);
+  commit(ctx: ExtensionContext, state: TodoState): void {
+    this.store.commit(ctx, state);
   }
 
-  /** Rebuild the current session's state from the session branch (no disk writes). */
   replay(ctx: ExtensionContext): void {
-    const s = this.getState(ctx);
-    s.todos = [];
-    s.nextId = 1;
-
-    for (const entry of ctx.sessionManager.getBranch()) {
-      if (entry.type === "custom" && entry.customType === STATE_ENTRY) {
-        const d = entry.data as TodoState | undefined;
-
-        if (d) {
-          s.todos = d.todos;
-          s.nextId = d.nextId;
-        }
-
-        continue;
-      }
-
-      if (
-        entry.type === "message" &&
-        entry.message.role === "toolResult" &&
-        entry.message.toolName === "todo"
-      ) {
-        const d = entry.message.details as TodoDetails | undefined;
-
-        if (d && !d.error) {
-          s.todos = d.todos;
-          s.nextId = d.nextId;
-        }
-      }
-    }
-
-    this.emitChange(ctx);
+    this.store.replay(ctx);
   }
 
-  /** Persist the latest snapshot right before compaction so it lands after the cut point. */
   persistSnapshot(ctx: ExtensionContext): void {
-    const s = this.getState(ctx);
-    if (s.todos.length > 0) this.persist(s);
+    this.store.persistSnapshot(ctx);
   }
 }

package/src/tool.ts

@@ -10,12 +10,32 @@ import type { TodoDetails, TodoState } from "./types";
 
 const TodoParams = Type.Object({
   action: StringEnum(["add", "update", "remove", "list", "clear"] as const),
-  text: Type.Optional(Type.String({ description: "Task text (required for add; optional for update)" })),
-  texts: Type.Optional(Type.Array(Type.String(), { description: "Task texts; add all at once (optional; used with action=add)" })),
-  id: Type.Optional(Type.Number({ description: "Task id (required for remove; alternative to ids)" })),
-  ids: Type.Optional(Type.Array(Type.Number(), { description: "Task ids; remove all at once (optional; used with action=remove)" })),
+  text: Type.Optional(
+    Type.String({
+      description: "Task text (required for add; optional for update)",
+    }),
+  ),
+  texts: Type.Optional(
+    Type.Array(Type.String(), {
+      description:
+        "Task texts; add all at once (optional; used with action=add)",
+    }),
+  ),
+  id: Type.Optional(
+    Type.Number({
+      description: "Task id (required for remove; alternative to ids)",
+    }),
+  ),
+  ids: Type.Optional(
+    Type.Array(Type.Number(), {
+      description:
+        "Task ids; remove all at once (optional; used with action=remove)",
+    }),
+  ),
   status: Type.Optional(StringEnum([...STATUSES] as const)),
-  blockedBy: Type.Optional(Type.Array(Type.Number(), { description: "Task ids this task depends on" })),
+  blockedBy: Type.Optional(
+    Type.Array(Type.Number(), { description: "Task ids this task depends on" }),
+  ),
 });
 
 export function registerTodoTool(pi: ExtensionAPI, store: TodoStore): void {
@@ -25,7 +45,8 @@ export function registerTodoTool(pi: ExtensionAPI, store: TodoStore): void {
     parameters: TodoParams,
     description:
       "Manage the session todo list. Actions: add (text or texts), update (id, optional status/text/blockedBy), remove (id or ids), list, clear",
-    promptSnippet: "Manage the session todo list: add/update/remove/list/clear tasks",
+    promptSnippet:
+      "Manage the session todo list: add/update/remove/list/clear tasks",
     promptGuidelines: [
       "Always track the work using the todo tools.",
       "Record each item the user wants tracked with todo add.",
@@ -33,7 +54,7 @@ export function registerTodoTool(pi: ExtensionAPI, store: TodoStore): void {
       "When the user says 'complete everything' / 'done with all', use todo_complete_all instead of looping todo update.",
     ],
 
-    async execute(toolCallId, params, _signal, _onUpdate, ctx) {
+    async execute(_, params, _signal, _onUpdate, ctx) {
       const current = store.getState(ctx);
       const result = applyAction(current, params);
 
@@ -52,29 +73,41 @@ export function registerTodoTool(pi: ExtensionAPI, store: TodoStore): void {
       store.commit(ctx, result.state);
       return {
         content: [{ type: "text", text: result.text }],
-        details: { action: params.action, todos: [...result.state.todos], nextId: result.state.nextId } satisfies TodoDetails,
+        details: {
+          action: params.action,
+          todos: [...result.state.todos],
+          nextId: result.state.nextId,
+        } satisfies TodoDetails,
       };
     },
 
     renderCall(args, theme, _context) {
-      let text = theme.fg("toolTitle", theme.bold("todo ")) + theme.fg("muted", args.action);
+      let text =
+        theme.fg("toolTitle", theme.bold("todo ")) +
+        theme.fg("muted", args.action);
       if (args.text) text += ` ${theme.fg("dim", `"${args.text}"`)}`;
-      if (args.id !== undefined) text += ` ${theme.fg("accent", `#${args.id}`)}`;
+      if (args.id !== undefined)
+        text += ` ${theme.fg("accent", `#${args.id}`)}`;
       return new Text(text, 0, 0);
     },
 
     renderResult(result, _options, theme, _context) {
       const details = result.details as TodoDetails | undefined;
-      if (details?.error) return new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
+      if (details?.error)
+        return new Text(theme.fg("error", `Error: ${details.error}`), 0, 0);
       const text = result.content[0];
       const msg = text?.type === "text" ? text.text : "";
-      if (details?.action === "list") return new Text(theme.fg("muted", msg), 0, 0);
+      if (details?.action === "list")
+        return new Text(theme.fg("muted", msg), 0, 0);
       return new Text(theme.fg("success", "✓ ") + theme.fg("muted", msg), 0, 0);
     },
   });
 }
 
-export function registerTodoCompleteAllTool(pi: ExtensionAPI, store: TodoStore): void {
+export function registerTodoCompleteAllTool(
+  pi: ExtensionAPI,
+  store: TodoStore,
+): void {
   pi.registerTool({
     name: "todo_complete_all",
     label: "Complete All Todos",
@@ -86,26 +119,40 @@ export function registerTodoCompleteAllTool(pi: ExtensionAPI, store: TodoStore):
 
     async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
       const current = store.getState(ctx);
+
       const n = current.todos.length;
       const cleared: TodoState = { todos: [], nextId: 1 };
+
       store.commit(ctx, cleared);
+
       return {
-        content: [{ type: "text", text: `All ${n} todos completed and cleared` }],
-        details: { action: "clear", todos: [], nextId: 1 } satisfies TodoDetails,
+        content: [
+          { type: "text", text: `All ${n} todos completed and cleared` },
+        ],
+        details: {
+          action: "clear",
+          todos: [],
+          nextId: 1,
+        } satisfies TodoDetails,
       };
     },
 
     renderCall(_args, theme) {
-      return new Text(theme.fg("toolTitle", theme.bold("todo_complete_all")), 0, 0);
+      return new Text(
+        theme.fg("toolTitle", theme.bold("todo_complete_all")),
+        0,
+        0,
+      );
     },
 
     renderResult(result, _options, theme) {
       const text = result.content[0];
       return new Text(
-        theme.fg("success", "✓ ") + theme.fg("muted", text?.type === "text" ? text.text : ""),
+        theme.fg("success", "✓ ") +
+          theme.fg("muted", text?.type === "text" ? text.text : ""),
         0,
         0,
       );
     },
   });
-}
+}

package/src/widget.ts

@@ -1,76 +1,28 @@
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-  Theme,
-} from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { createPanelWidget, PanelWidgetSpec } from "@leo-alvarenga/pi-ext-core";
 
 import { PANEL_TOGGLE_CHORD, WIDGET_KEY } from "./constants";
 import type { TodoStore } from "./state";
 import type { TodoState } from "./types";
 import { getStyledTodoList } from "./utils";
 
-let collapsed = true;
-const hideIfEmpty = true;
-
-class TodoWidget {
-  private cachedWidth: number | undefined;
-  private cachedLines: string[] | undefined;
-
-  constructor(
-    private readonly theme: Theme,
-    private readonly snapshot: () => TodoState,
-    private readonly isCollapsed: () => boolean,
-  ) {}
-
-  render(width: number): string[] {
-    if (hideIfEmpty && this.snapshot().todos.length === 0) {
-      return [];
-    }
-
-    if (this.cachedLines !== undefined && this.cachedWidth === width) {
-      return this.cachedLines;
-    }
-
-    const lines = getStyledTodoList(
-      this.snapshot().todos,
-      this.theme,
-      width,
-      this.isCollapsed(),
-    );
-
-    this.cachedWidth = width;
-    this.cachedLines = lines;
-
-    return lines;
-  }
-
-  invalidate(): void {
-    this.cachedWidth = undefined;
-    this.cachedLines = undefined;
-  }
+export function registerTodoWidget(pi: ExtensionAPI, store: TodoStore) {
+  const spec: PanelWidgetSpec<TodoState> = {
+    widgetKey: WIDGET_KEY,
+    maxRows: 20,
+    emptyText: "No todos",
+    toggleChord: PANEL_TOGGLE_CHORD,
+    isEmpty: (s) => s.todos.length === 0,
+    store,
+    moreLabel: (n) => `…and ${n} more`,
+    header: (s, theme, isCollapsed) =>
+      theme.fg("muted", isCollapsed ? "▶ Todos" : "▼ Todos"),
+    rows: (s, theme) => getStyledTodoList(s.todos, theme, 80, false),
+  };
+
+  const controls = createPanelWidget(pi, spec);
+  controls.register();
+  return controls;
 }
 
-export function refreshWidget(ctx: ExtensionContext, store: TodoStore): void {
-  if (!ctx.hasUI) return;
-
-  ctx.ui.setWidget(
-    WIDGET_KEY,
-    (_tui, theme) =>
-      new TodoWidget(
-        theme,
-        () => store.getState(ctx),
-        () => collapsed,
-      ),
-  );
-}
-
-export function registerTodoWidget(pi: ExtensionAPI, store: TodoStore): void {
-  pi.registerShortcut(PANEL_TOGGLE_CHORD, {
-    description: "Toggle todos panel",
-    handler: (ctx) => {
-      collapsed = !collapsed;
-
-      refreshWidget(ctx, store);
-    },
-  });
-}