@getpipher/armory-todo 0.3.1 → 0.4.0

package/src/panel-data.ts

@@ -79,3 +79,34 @@ export function actionsForDoneTodo(d: DoneItem): { label: string; action: string
   if (d.location === "archive") acts.push({ label: "Restore (from archive)", action: "restore" });
   return acts;
 }
+
+// v0.4.0 — project overview (Projects tab) helpers.
+import type { ProjectsOverview } from "./projects.ts";
+
+/** Format the projects overview into SelectList items. Markers: OVER / typo. */
+export function projectOverviewToItems(o: ProjectsOverview): SelectItem[] {
+  return o.rows.map((r) => {
+    const cap = r.maxOpen !== null ? ` [max:${r.maxOpen}]` : "";
+    const over = r.over ? " OVER" : "";
+    const typo = r.typo ? " ?typo" : "";
+    const last = r.lastUpdated ? ` · ${r.lastUpdated.slice(0, 10)}` : " · (no live)";
+    return {
+      value: r.name,
+      label: `${r.name}  ${r.open}/${r.in_progress}/${r.parked}/${r.done} (total ${r.total})${cap}${over}${typo}${last}`,
+    };
+  });
+}
+
+/** Actions for a project row in the Projects tab. */
+export function actionsForProject(): { label: string; action: string }[] {
+  return [
+    { label: "Rename / merge", action: "rename" },
+    { label: "Set maxOpen", action: "setmax" },
+    { label: "Filter active to project", action: "filter" },
+  ];
+}
+
+/** The (no project) summary row — non-selectable (no submenu). */
+export function noProjectSummaryItem(o: ProjectsOverview): SelectItem {
+  return { value: "__noproject__", label: `(no project): ${o.noProject.count} total · ${o.noProject.open} open` };
+}

package/src/panel.ts

@@ -24,10 +24,12 @@ import { listTodos, parkTodo, completeTodo, deleteTodo, updateTodo, type Todo, t
 import { restoreTodo, archiveSummary, listArchived, listDoneUnified } from "./archive.ts";
 import { loadConfig, saveConfig, type TodoConfig } from "./config.ts";
 import { healthReport } from "./health.ts";
-import { todoToItem, archiveSummaryToItems, actionsForTodo, configToSettingItems, todoDoneItem, actionsForDoneTodo } from "./panel-data.ts";
+import { projectsOverview } from "./projects.ts";
+import { renameProject, setProjectMaxOpen, loadRegistry, saveRegistry } from "./registry.ts";
+import { todoToItem, archiveSummaryToItems, actionsForTodo, configToSettingItems, todoDoneItem, actionsForDoneTodo, projectOverviewToItems, actionsForProject, noProjectSummaryItem } from "./panel-data.ts";
 
-export type Box = "active" | "parked" | "done" | "archive" | "config";
-const BOXES: Box[] = ["active", "parked", "done", "archive", "config"];
+export type Box = "active" | "parked" | "done" | "archive" | "projects" | "config";
+const BOXES: Box[] = ["active", "parked", "done", "archive", "projects", "config"];
 
 export interface TodoPanelOpts {
   theme: Theme;
@@ -52,6 +54,9 @@ export class TodoPanel extends Container {
   private settingsList: SettingsList | null = null;
   private config: TodoConfig;
   private healthFlags: string[] = [];
+  private projectFilterName = "";      // set by the "Filter active to project" action
+  private projectEditKind: "rename" | "setmax" | null = null;
+  private projectEditName = "";       // which project is being edited
 
   constructor(opts: TodoPanelOpts) {
     super();
@@ -101,7 +106,10 @@ export class TodoPanel extends Container {
     this.addChild(new Spacer(1));
 
     if (this.editMode && this.editInput) {
-      this.addChild(new Text(this.theme.fg("accent", `  Edit [${this.editId}]:`), 0, 0));
+      const prompt = this.projectEditKind === "rename" ? `  Rename project '${this.projectEditName}' to:`
+        : this.projectEditKind === "setmax" ? `  Set maxOpen for '${this.projectEditName}' (number or 'clear'):`
+        : `  Edit [${this.editId}]:`;
+      this.addChild(new Text(this.theme.fg("accent", prompt), 0, 0));
       this.addChild(this.editInput);
       this.addChild(new Text(this.theme.fg("dim", "  enter save • esc cancel"), 0, 0));
     } else if (this.actionMode && this.actionList) {
@@ -137,7 +145,8 @@ export class TodoPanel extends Container {
   private refreshList(): void {
     const filter = this.filterInput.getValue();
     if (this.currentBox === "active") {
-      const todos = listTodos({ text: filter || undefined, limit: 50 });
+      const project = this.projectFilterName || undefined;
+      const todos = listTodos({ project, text: filter || undefined, limit: 50 });
       this.setSelectItems(todos.map(todoToItem));
     } else if (this.currentBox === "parked") {
       const todos = listTodos({ status: "parked", text: filter || undefined, limit: 50 });
@@ -153,6 +162,10 @@ export class TodoPanel extends Container {
         const res = listArchived({ text: filter, limit: 50 });
         this.setSelectItems(res.items.map(todoToItem));
       }
+    } else if (this.currentBox === "projects") {
+      const overview = projectsOverview();
+      const rows = projectOverviewToItems(overview);
+      this.setSelectItems([noProjectSummaryItem(overview), ...rows]);
     }
   }
 
@@ -188,9 +201,87 @@ export class TodoPanel extends Container {
       this.renderShell();
       return;
     }
+    if (this.currentBox === "projects") {
+      if (item.value === "__noproject__") return;   // (no project) summary — no submenu
+      this.openProjectSubmenu(item.value);
+      return;
+    }
     this.openActionSubmenu(item.value);
   }
 
+  private openProjectSubmenu(name: string): void {
+    const acts = actionsForProject();
+    const items: SelectItem[] = acts.map((a) => ({ value: a.action, label: a.label }));
+    this.actionList = new SelectList(items, 8, {
+      selectedPrefix: (s) => this.theme.fg("accent", s),
+      selectedText: (s) => this.theme.fg("accent", s),
+      description: (s) => this.theme.fg("muted", s),
+      scrollInfo: (s) => this.theme.fg("dim", s),
+      noMatch: (s) => this.theme.fg("warning", s),
+    });
+    this.actionList.onSelect = (a) => this.executeProjectAction(name, a.value);
+    this.actionList.onCancel = () => { this.actionMode = false; this.actionList = null; this.renderShell(); };
+    this.actionMode = true;
+    this.renderShell();
+  }
+
+  private async executeProjectAction(name: string, action: string): Promise<void> {
+    try {
+      if (action === "filter") {
+        this.projectFilterName = name;
+        this.currentBox = "active";
+        this.filterInput.setValue("");   // clear text filter; scope is via projectFilterName
+        this.actionMode = false; this.actionList = null;
+        this.refreshList();
+        this.renderShell();
+        this.onNotify(`Filtered active to project: ${name}`);
+        return;
+      }
+      if (action === "rename" || action === "setmax") {
+        this.projectEditKind = action;
+        this.projectEditName = name;
+        this.editInput = new Input();
+        this.editInput.setValue("");   // don't pre-fill: setValue leaves cursor at 0 (typing would prepend); the prompt labels the target
+        this.editInput.onSubmit = (value) => {
+          try {
+            if (this.projectEditKind === "rename") {
+              const r = renameProject(this.projectEditName, value.trim());
+              this.onNotify(`Renamed ${this.projectEditName} → ${r.newName} (${r.liveRenamed} live + ${r.archivedRenamed} archived${r.merged ? ", merged" : ""})`);
+            } else if (this.projectEditKind === "setmax") {
+              const v = value.trim().toLowerCase();
+              const max = v === "clear" || v === "" ? null : Number(v);
+              if (max !== null && !Number.isFinite(max)) throw new Error("maxOpen must be a number or 'clear'");
+              const reg = loadRegistry();
+              setProjectMaxOpen(reg, this.projectEditName, max);
+              saveRegistry(reg);
+              this.onNotify(`${this.projectEditName} maxOpen = ${max === null ? "cleared" : max}`);
+            }
+          } catch (err) { this.onNotify((err as Error).message, "error"); }
+          this.exitProjectEdit();
+        };
+        this.editInput.onEscape = () => this.exitProjectEdit();
+        this.actionMode = false; this.actionList = null;
+        this.editMode = true;
+        this.renderShell();
+        return;
+      }
+    } catch (err) {
+      this.onNotify((err as Error).message, "error");
+    }
+    this.actionMode = false; this.actionList = null;
+    this.refreshList();
+    this.renderShell();
+  }
+
+  private exitProjectEdit(): void {
+    this.editMode = false;
+    this.editInput = null;
+    this.projectEditKind = null;
+    this.projectEditName = "";
+    this.refreshList();
+    this.renderShell();
+  }
+
   private openActionSubmenu(id: string): void {
     let acts: { label: string; action: string }[];
     if (this.currentBox === "done") {
@@ -335,6 +426,7 @@ export class TodoPanel extends Container {
     const next = (idx + dir + BOXES.length) % BOXES.length;
     this.currentBox = BOXES[next]!;
     this.filterInput.setValue("");
+    this.projectFilterName = "";   // reset project scope on tab switch
     this.actionMode = false;
     this.actionList = null;
     this.refreshList();
@@ -344,7 +436,7 @@ export class TodoPanel extends Container {
   handleInput(data: string): void {
     if (this.editMode && this.editInput) {
       if (matchesKey(data, "escape") || matchesKey(data, "esc")) {
-        this.exitEditMode();
+        if (this.projectEditKind) this.exitProjectEdit(); else this.exitEditMode();
         return;
       }
       this.editInput.handleInput(data);

package/src/paths.ts

@@ -4,6 +4,7 @@
 //   todo.json          — live store (open, in_progress, parked)
 //   todo-archive.json  — sealed history (done, cancelled)
 //   todo.config.json   — prune ages + health thresholds
+//   projects.json      — project registry (canonical names + maxOpen slots, v0.4.0)
 //
 // The legacy v1 single file was ~/.pi/agent/todo.json; migrate.ts handles
 // moving it into the folder on first load.
@@ -30,6 +31,10 @@ export function getConfigPath(): string {
   return join(getTodoDir(), "todo.config.json");
 }
 
+export function getRegistryPath(): string {
+  return join(getTodoDir(), "projects.json");
+}
+
 /** The pre-v2 single-file store location. Used by migrate.ts. */
 export function getLegacyPath(): string {
   return LEGACY_PATH;

package/src/projects.ts

@@ -0,0 +1,91 @@
+// Per-project scope overview for armory-todo (Feature A). Pure read that
+// reconciles the registry first (lazy sync), then aggregates counts across
+// the live store + archived done. The `projects` action + panel Projects tab
+// + the per-project health flags all consume this shape (or its derivatives).
+
+import { loadStore, type Todo } from "./todo-store.ts";
+import { loadArchive } from "./archive.ts";
+import { loadRegistry, reconcileRegistry, saveRegistry, getProjectEntry } from "./registry.ts";
+import { levenshtein } from "./levenshtein.ts";
+
+export interface ProjectOverviewRow {
+  name: string;
+  open: number;
+  in_progress: number;
+  parked: number;
+  done: number;       // live done + archived done
+  total: number;      // open + in_progress + parked + done
+  maxOpen: number | null;
+  over: boolean;      // open > maxOpen (only when maxOpen !== null)
+  typo: boolean;      // total === 1 AND a near-sibling (levenshtein ≤ 2) exists
+  lastUpdated: string; // max updatedAt across the project's live todos (ISO), or "" if none
+}
+
+export interface ProjectsOverview {
+  rows: ProjectOverviewRow[];   // sorted: open desc → total desc → name asc
+  totalTodos: number;           // sum of rows' total
+  noProject: { count: number; open: number };  // the (no project) bucket, not a row
+}
+
+export function projectsOverview(): ProjectsOverview {
+  const live = loadStore();
+  const archive = loadArchive();
+  const archivedDone = archive.todos.filter((t) => t.status === "done");
+
+  // reconcile registry first (lazy sync), persist iff changed
+  const reg = loadRegistry();
+  const { reg: synced, changed } = reconcileRegistry(reg, live.todos, archive.todos);
+  if (changed) saveRegistry(synced);
+
+  const liveBy = new Map<string, Todo[]>();
+  for (const t of live.todos) {
+    const key = t.project.trim();
+    const list = liveBy.get(key) ?? [];
+    list.push(t);
+    liveBy.set(key, list);
+  }
+  const archivedDoneBy = new Map<string, number>();
+  for (const t of archivedDone) {
+    const key = t.project.trim();
+    archivedDoneBy.set(key, (archivedDoneBy.get(key) ?? 0) + 1);
+  }
+
+  const names = new Set<string>([...liveBy.keys(), ...archivedDoneBy.keys()].filter((n) => n !== ""));
+
+  let totalTodos = 0;
+  const rows: ProjectOverviewRow[] = [];
+  for (const name of names) {
+    const liveForName = liveBy.get(name) ?? [];
+    const open = liveForName.filter((t) => t.status === "open").length;
+    const in_progress = liveForName.filter((t) => t.status === "in_progress").length;
+    const parked = liveForName.filter((t) => t.status === "parked").length;
+    const done = liveForName.filter((t) => t.status === "done").length + (archivedDoneBy.get(name) ?? 0);
+    const total = open + in_progress + parked + done;
+    totalTodos += total;
+    const entry = getProjectEntry(synced, name);
+    const maxOpen = entry?.maxOpen ?? null;
+    const over = maxOpen !== null && open > maxOpen;
+    const lastUpdated = liveForName.length
+      ? liveForName.map((t) => t.updatedAt).sort().at(-1) ?? ""
+      : "";
+    rows.push({ name, open, in_progress, parked, done, total, maxOpen, over, typo: false, lastUpdated });
+  }
+
+  // typo: total === 1 AND a near-sibling (levenshtein ≤ 2) among other names
+  for (const row of rows) {
+    if (row.total === 1) {
+      row.typo = [...names].some((other) => other !== row.name && levenshtein(row.name, other) <= 2);
+    }
+  }
+
+  // (no project) bucket
+  const noProjectLive = live.todos.filter((t) => t.project.trim() === "");
+  const noProjectArchivedDone = archivedDone.filter((t) => t.project.trim() === "");
+  const noProject = {
+    count: noProjectLive.length + noProjectArchivedDone.length,
+    open: noProjectLive.filter((t) => t.status === "open").length,
+  };
+
+  rows.sort((a, b) => b.open - a.open || b.total - a.total || a.name.localeCompare(b.name));
+  return { rows, totalTodos, noProject };
+}

package/src/registry.ts

@@ -0,0 +1,175 @@
+// Project registry for armory-todo — a sibling file to todo.json holding the
+// canonical list of known projects + their per-project advisory cap slot
+// (`maxOpen`). Advisory in v0.4.0 (drives a health flag); enforcement
+// (block-on-add) graduates in v0.5.0.
+//
+// File: <TODO_DIR>/projects.json (0600, atomic write). Lazy-synced on read:
+// `reconcileRegistry` appends any unknown project strings (live + archived)
+// with maxOpen:null. `loadRegistry` is side-effect-free (missing → empty,
+// no file created); seeding happens on the first reconcile call.
+// No env guard — projects.json always lives under TODO_DIR (temp dir in tests).
+
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { getRegistryPath } from "./paths.ts";
+import { loadStore, saveStore, TodoError, type Todo } from "./todo-store.ts";
+import { loadArchive, saveArchive } from "./archive.ts";
+
+export interface ProjectEntry {
+  name: string;
+  maxOpen: number | null;  // null = no advisory cap for this project
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface ProjectRegistry {
+  version: 1;
+  updatedAt: string;
+  projects: ProjectEntry[];
+}
+
+function now(): string { return new Date().toISOString(); }
+
+function emptyRegistry(): ProjectRegistry {
+  return { version: 1, updatedAt: now(), projects: [] };
+}
+
+export { getRegistryPath } from "./paths.ts";
+
+export function loadRegistry(): ProjectRegistry {
+  const path = getRegistryPath();
+  if (!existsSync(path)) return emptyRegistry();
+  try {
+    const raw = readFileSync(path, "utf8");
+    const parsed = JSON.parse(raw) as ProjectRegistry;
+    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.projects)) {
+      throw new Error("invalid registry shape");
+    }
+    if (parsed.version !== 1) throw new Error("invalid registry shape");
+    return parsed;
+  } catch {
+    try {
+      renameSync(path, `${path}.bad-${Date.now()}`);
+    } catch {
+      // best-effort backup
+    }
+    return emptyRegistry();
+  }
+}
+
+export function saveRegistry(reg: ProjectRegistry): void {
+  reg.updatedAt = now();
+  const path = getRegistryPath();
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true });
+  const tmp = `${path}.tmp`;
+  writeFileSync(tmp, JSON.stringify(reg, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+  try { chmodSync(tmp, 0o600); } catch { /* fs may ignore mode bits */ }
+  renameSync(tmp, path);
+}
+
+/**
+ * Lazy sync: append any unknown non-empty project strings (from live + archived
+ * todos) as new entries with maxOpen:null. Returns { reg, changed }. Caller
+ * persists iff changed. Idempotent (a second call with no new names → changed=false).
+ */
+export function reconcileRegistry(
+  reg: ProjectRegistry,
+  liveTodos: Todo[],
+  archivedTodos: Todo[],
+): { reg: ProjectRegistry; changed: boolean } {
+  const known = new Set(reg.projects.map((p) => p.name));
+  const names = new Set<string>();
+  for (const t of liveTodos) { const p = t.project.trim(); if (p) names.add(p); }
+  for (const t of archivedTodos) { const p = t.project.trim(); if (p) names.add(p); }
+  let changed = false;
+  for (const name of names) {
+    if (!known.has(name)) {
+      reg.projects.push({ name, maxOpen: null, createdAt: now(), updatedAt: now() });
+      changed = true;
+    }
+  }
+  if (changed) reg.updatedAt = now();
+  return { reg, changed };
+}
+
+export function getProjectEntry(reg: ProjectRegistry, name: string): ProjectEntry | undefined {
+  return reg.projects.find((p) => p.name === name);
+}
+
+/**
+ * Set a project's maxOpen slot. `max = null` clears. Creates the entry if the
+ * name is unknown (with createdAt/updatedAt = now). Throws if name is "" (the
+ * (no project) group can't be capped). Mutates `reg` in place + returns the entry.
+ */
+export function setProjectMaxOpen(reg: ProjectRegistry, name: string, max: number | null): ProjectEntry {
+  const trimmed = name.trim();
+  if (!trimmed) throw new TodoError("cannot set maxOpen on the (no project) group");
+  if (max !== null && (!Number.isFinite(max) || max < 0)) {
+    throw new TodoError(`maxOpen must be a non-negative number or null (got ${String(max)})`);
+  }
+  let entry = getProjectEntry(reg, trimmed);
+  if (!entry) {
+    entry = { name: trimmed, maxOpen: null, createdAt: now(), updatedAt: now() };
+    reg.projects.push(entry);
+  }
+  entry.maxOpen = max;
+  entry.updatedAt = now();
+  reg.updatedAt = now();
+  return entry;
+}
+
+export interface RenameResult {
+  liveRenamed: number;
+  archivedRenamed: number;
+  merged: boolean;
+  newName: string;
+}
+
+/**
+ * Rename (or merge) a project: rewrite every live + archived todo whose
+ * `project === oldName` to `newName`, remove the `oldName` registry entry,
+ * and ensure the `newName` entry exists. Best-effort multi-file (no WAL):
+ * live → archive → registry, each saved atomically with backup-on-corrupt.
+ * Throws if `oldName` is not in the registry. Self-rename is a no-op success.
+ */
+export function renameProject(oldName: string, newName: string): RenameResult {
+  const old = oldName.trim();
+  const next = newName.trim();
+  if (!old) throw new TodoError("oldName is required");
+  if (!next) throw new TodoError("newName is required");
+  if (old === next) return { liveRenamed: 0, archivedRenamed: 0, merged: false, newName: next };
+
+  const reg = loadRegistry();
+  const oldEntry = getProjectEntry(reg, old);
+  if (!oldEntry) throw new TodoError(`no project named '${old}' in the registry`);
+  const merged = getProjectEntry(reg, next) !== undefined;
+
+  // 1. live store
+  const live = loadStore();
+  let liveRenamed = 0;
+  for (const t of live.todos) {
+    if (t.project === old) { t.project = next; t.updatedAt = now(); liveRenamed++; }
+  }
+  if (liveRenamed > 0) saveStore(live);
+
+  // 2. archive
+  const archive = loadArchive();
+  let archivedRenamed = 0;
+  for (const t of archive.todos) {
+    if (t.project === old) { t.project = next; archivedRenamed++; }
+  }
+  if (archivedRenamed > 0) saveArchive(archive);
+
+  // 3. registry: remove old, ensure next exists
+  reg.projects = reg.projects.filter((p) => p.name !== old);
+  if (!getProjectEntry(reg, next)) {
+    // non-merge: preserve the renamed project's cap + provenance (don't silently drop maxOpen)
+    reg.projects.push({ name: next, maxOpen: oldEntry.maxOpen, createdAt: oldEntry.createdAt, updatedAt: now() });
+  }
+  // merge (next already exists): keep next's existing entry + cap unchanged
+  reg.updatedAt = now();
+  saveRegistry(reg);
+
+  return { liveRenamed, archivedRenamed, merged, newName: next };
+}