@nguyenquangthai/pi-todo 0.2.3 → 0.2.4

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.2.4 (2026-07-15)
+
+- README: add npm/CI/license badges.
+- Add GitHub Actions CI workflow (test + typecheck on push).
+- Overlay: sort items by priority (high → medium → low) within each status group.
+- Overlay: add progress bar (`████░░░░ 60%`) in heading.
+- Overlay: collapse completed/cancelled items into `+N done` when space is tight.
+- README: update overlay description + tool names to match v0.2.3.
+
 ## 0.2.3 (2026-07-15)
 
 - Rename tools to snake_case: `todowrite` → `todo_write`, `todoread` → `todo_read` (pi convention).

package/README.md

@@ -1,8 +1,12 @@
 # pi-todo
 
+[![npm version](https://img.shields.io/npm/v/@nguyenquangthai/pi-todo?color=blue)](https://www.npmjs.com/package/@nguyenquangthai/pi-todo)
+[![License](https://img.shields.io/badge/license-MIT-green)](./LICENSE)
+[![Tests](https://github.com/QuangThai/pi-todo/actions/workflows/ci.yml/badge.svg)](https://github.com/QuangThai/pi-todo/actions)
+
 OpenCode-style session todo checklist for the [pi coding agent](https://pi.dev).
 
-Adds `todowrite` / `todoread`, a live `# Todos` overlay above the editor (`[ ]` / `[•]` / `[✓]` / `[×]`), and branch-replay persistence (survives `/reload`, tree nav, and custom-entry durability across compaction).
+Adds `todo_write` / `todo_read`, a live `# Todos` overlay above the editor (`[ ]` / `[•]` / `[✓]` / `[×]`), and branch-replay persistence (survives `/reload`, tree nav, and custom-entry durability across compaction).
 
 ## Install
 
@@ -22,7 +26,7 @@ Then restart pi or run `/reload`.
 
 ## Tools
 
-### `todowrite`
+### `todo_write`
 
 Full-replace the session todo list. Each call must pass the **complete** list.
 
@@ -44,9 +48,9 @@ Rules enforced by the tool:
 - Status: `pending` | `in_progress` | `completed` | `cancelled`
 - Tool text echo caps at **40** lines (`+N more` in the text body; full list still in `details` / JSON)
 
-### `todoread`
+### `todo_read`
 
-Returns the current list as text + JSON. Prefer the overlay for at-a-glance status; avoid calling it in the same parallel batch as `todowrite`.
+Returns the current list as text + JSON. Prefer the overlay for at-a-glance status; avoid calling it in the same parallel batch as `todo_write`.
 
 ## Overlay
 
@@ -54,11 +58,14 @@ Shown above the editor while any **open** todo remains (`pending` / `in_progress
 
 Hidden when the list is empty or every item is `completed` / `cancelled`.
 
-Heading shows open + running counts, e.g. `# Todos (2 open, 1 running)`:
+Heading shows open + running counts + progress bar, e.g. `# Todos (2 open, 1 running) ████░░░░ 60%`:
 
 - **open** = `pending` + `in_progress`
 - **running** = `in_progress` only (0 or 1 after a valid write)
+- **progress bar** = completed / total (adaptive width)
 
+Items within each status group are sorted by priority (high → medium → low).
+When space is tight, completed/cancelled items collapse into `+N done`.
 A blank line separates the heading from the first todo row for visual breathing room.
 
 ## Development

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nguyenquangthai/pi-todo",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "OpenCode-like session todo checklist for the pi coding agent — todowrite/todoread with a live TUI overlay",
   "type": "module",
   "author": "QuangThai",

package/src/format.ts

@@ -4,6 +4,16 @@ import type { TodoItem, TodoStatus } from "./types.js";
 import { MAX_OVERLAY_LINES, MAX_RESULT_LINES } from "./types.js";
 import { countOpenTodos, countRunningTodos, hasOpenTodos, isTerminalStatus } from "./validate.js";
 
+const PRIORITY_RANK: Record<string, number> = {
+  high: 0,
+  medium: 1,
+  low: 2,
+};
+
+function prioritySort(a: TodoItem, b: TodoItem): number {
+  return (PRIORITY_RANK[a.priority] ?? 2) - (PRIORITY_RANK[b.priority] ?? 2);
+}
+
 export function getTodoMarker(status: TodoStatus): string {
   switch (status) {
     case "completed":
@@ -24,11 +34,26 @@ export function formatPlainTodoLine(todo: TodoItem): string {
 /** Compact checklist for tool responses; caps lines to keep LLM context small. */
 export function formatTodoListText(todos: readonly TodoItem[], summary: string): string {
   if (todos.length === 0) return summary;
+
+  // in_progress first, then pending (sorted by priority), then terminal
+  const sorted = [...todos].sort((a, b) => {
+    const statusRank: Record<string, number> = {
+      in_progress: 0,
+      pending: 1,
+      completed: 2,
+      cancelled: 2,
+    };
+    const diff =
+      (statusRank[a.status] ?? 2) - (statusRank[b.status] ?? 2);
+    if (diff !== 0) return diff;
+    return prioritySort(a, b);
+  });
+
   if (todos.length <= MAX_RESULT_LINES) {
-    return [summary, ...todos.map(formatPlainTodoLine)].join("\n");
+    return [summary, ...sorted.map(formatPlainTodoLine)].join("\n");
   }
-  const shown = todos.slice(0, MAX_RESULT_LINES);
-  const hidden = todos.length - MAX_RESULT_LINES;
+  const shown = sorted.slice(0, MAX_RESULT_LINES);
+  const hidden = sorted.length - MAX_RESULT_LINES;
   return [
     summary,
     ...shown.map(formatPlainTodoLine),
@@ -55,46 +80,54 @@ export function shouldShowOverlay(todos: readonly TodoItem[]): boolean {
 export interface OverlayLayout {
   visible: TodoItem[];
   hiddenCount: number;
+  terminalCount: number;
 }
 
 /**
- * Fit into maxLines (includes heading). On overflow, drop terminal first,
- * then pending from the end; keep in_progress. Preserve original order.
+ * Fit into maxLines (includes heading). On overflow, collapse terminal items
+ * into a "+N done" line. Within each status group, items are sorted by
+ * priority (high → medium → low).
  */
 export function selectOverlayLayout(
   todos: readonly TodoItem[],
   maxLines: number = MAX_OVERLAY_LINES,
 ): OverlayLayout {
   if (!shouldShowOverlay(todos)) {
-    return { visible: [], hiddenCount: 0 };
+    return { visible: [], hiddenCount: 0, terminalCount: 0 };
   }
 
   const bodyBudget = Math.max(1, maxLines - 1);
   if (todos.length <= bodyBudget) {
-    return { visible: [...todos], hiddenCount: 0 };
+    // All fit — show everything
+    return { visible: [...todos].sort(prioritySort), hiddenCount: 0, terminalCount: 0 };
   }
 
   const innerBudget = Math.max(1, bodyBudget - 1);
-  const inProgress = todos.filter((t) => t.status === "in_progress");
-  const pending = todos.filter((t) => t.status === "pending");
-  const terminal = todos.filter((t) => isTerminalStatus(t.status));
-
-  const picked = new Set<TodoItem>();
-  for (const t of inProgress) {
-    if (picked.size >= innerBudget) break;
-    picked.add(t);
-  }
-  for (const t of pending) {
-    if (picked.size >= innerBudget) break;
-    picked.add(t);
-  }
-  for (const t of terminal) {
-    if (picked.size >= innerBudget) break;
-    picked.add(t);
+  const inProgress = todos.filter((t) => t.status === "in_progress").sort(prioritySort);
+  const pending = todos.filter((t) => t.status === "pending").sort(prioritySort);
+  const terminal = todos.filter((t) => isTerminalStatus(t.status)).sort(prioritySort);
+
+  const picked: TodoItem[] = [];
+  const addPicked = (items: TodoItem[]) => {
+    for (const t of items) {
+      if (picked.length >= innerBudget) break;
+      picked.push(t);
+    }
+  };
+
+  addPicked(inProgress);
+  addPicked(pending);
+
+  // Collapse terminal items: only show them individually if there's room
+  if (terminal.length > 0 && picked.length < innerBudget) {
+    addPicked(terminal);
   }
 
-  const visible = todos.filter((t) => picked.has(t));
-  return { visible, hiddenCount: todos.length - visible.length };
+  const terminalCollapsed = terminal.length > 0 && picked.length >= innerBudget;
+  const remaining = todos.length - picked.length;
+  const hiddenCount = terminalCollapsed ? remaining : Math.max(0, remaining - terminal.length);
+
+  return { visible: picked, hiddenCount, terminalCount: terminalCollapsed ? terminal.length : 0 };
 }
 
 export interface RenderOverlayOptions {
@@ -104,8 +137,9 @@ export interface RenderOverlayOptions {
 /**
  * Heading counts (when overlay is visible):
  * - open    = pending + in_progress
- * - running = in_progress only (0 or 1 after a valid todowrite)
+ * - running = in_progress only (0 or 1 after a valid todo_write)
  * Overlay is hidden when open === 0, so "(0 open, 0 running)" is never shown.
+ * Includes a visual progress bar: completed / total.
  */
 export function renderOverlayLines(
   todos: readonly TodoItem[],
@@ -119,9 +153,18 @@ export function renderOverlayLines(
   const truncate = (line: string) => truncateToWidth(line, width, "…");
   const open = countOpenTodos(todos);
   const running = countRunningTodos(todos);
+  const total = todos.length;
+  const done = total - open;
+  const pct = total > 0 ? Math.round((done / total) * 100) : 0;
+  const barWidth = Math.max(4, Math.min(12, Math.floor(width / 8)));
+  const filled = Math.round((barWidth * done) / total);
+  const bar =
+    "█".repeat(filled) + "░".repeat(Math.max(0, barWidth - filled));
+
   const heading = truncate(
     theme.fg("accent", theme.bold(`# Todos`)) +
-      theme.fg("dim", ` (${open} open, ${running} running)`),
+      theme.fg("dim", ` (${open} open, ${running} running)`) +
+      theme.fg("muted", ` ${bar} ${pct}%`),
   );
 
   // Small gap between heading and first row — budget -1 to account for the blank line
@@ -131,6 +174,9 @@ export function renderOverlayLines(
   for (const todo of layout.visible) {
     lines.push(truncate(formatThemedTodoLine(todo, theme)));
   }
+  if (layout.terminalCount > 0) {
+    lines.push(truncate(theme.fg("dim", `+${layout.terminalCount} done`)));
+  }
   if (layout.hiddenCount > 0) {
     lines.push(truncate(theme.fg("dim", `+${layout.hiddenCount} more`)));
   }