@getpipher/armory-todo 0.3.1 → 0.5.0

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 };
+}

package/src/todo-store.ts

@@ -19,6 +19,9 @@ import {
 import { dirname } from "node:path";
 import { getLivePath, getTodoDir, getLegacyPath } from "./paths.ts";
 import { migrateIfNeeded, migrateV2ToV3 } from "./migrate.ts";
+import { loadConfig } from "./config.ts";
+import { loadRegistry, getProjectEntry } from "./registry.ts";
+import { checkNotesCap, checkProjectCap, overBudgetProjects } from "./caps.ts";
 
 export type Priority = "low" | "med" | "high" | "critical";
 export type Status = "open" | "in_progress" | "parked" | "done" | "cancelled";
@@ -182,6 +185,19 @@ export function addTodo(input: AddInput): Todo {
   if (input.priority) assertPriority(input.priority);
   const notes = (input.notes ?? "").trim();
   const store = loadStore();
+  // v0.5.0 caps — checked BEFORE any mutation (atomic: nothing is written on breach).
+  const config = loadConfig();
+  checkNotesCap(notes, config.health.maxNotesBytes);
+  const projectTrimmed = (input.project ?? "").trim();
+  if (projectTrimmed !== "") {
+    const reg = loadRegistry();
+    const entry = getProjectEntry(reg, projectTrimmed);
+    const maxOpen = entry?.maxOpen ?? null;
+    if (maxOpen !== null) {
+      const currentOpen = store.todos.filter((t) => t.project === projectTrimmed && t.status === "open").length;
+      checkProjectCap({ project: projectTrimmed, currentOpen, maxOpen });
+    }
+  }
   const todo: Todo = {
     id: genId(),
     title,
@@ -237,6 +253,25 @@ export function listTodos(filter: ListFilter = {}): Todo[] {
 export function updateTodo(id: string, patch: UpdateInput): Todo {
   const store = loadStore();
   const todo = findOrFail(store, id);
+  // v0.5.0 caps — checked BEFORE any mutation (atomic). Notes re-checked only
+  // when notes is being written (so a title edit on a grandfathered oversize
+  // note isn't trapped). Project cap re-checked only on a real move of an
+  // open/in_progress todo (un-park is intentionally NOT re-checked).
+  if (patch.notes !== undefined) {
+    checkNotesCap(patch.notes.trim(), loadConfig().health.maxNotesBytes);
+  }
+  if (patch.project !== undefined) {
+    const target = patch.project.trim();
+    if (target !== todo.project && (todo.status === "open" || todo.status === "in_progress") && target !== "") {
+      const reg = loadRegistry();
+      const entry = getProjectEntry(reg, target);
+      const maxOpen = entry?.maxOpen ?? null;
+      if (maxOpen !== null) {
+        const currentOpen = store.todos.filter((t) => t.project === target && t.status === "open" && t.id !== todo.id).length;
+        checkProjectCap({ project: target, currentOpen, maxOpen });
+      }
+    }
+  }
   if (patch.title !== undefined) todo.title = normalizeTitle(patch.title);
   if (patch.notes !== undefined) todo.notes = patch.notes.trim();
   if (patch.project !== undefined) todo.project = patch.project.trim();
@@ -285,17 +320,43 @@ export function clearTodos(status: Status = "done"): number {
   return removed;
 }
 
-/** Compact markdown summary of open + in_progress TODOs for system-prompt injection. */
-export function renderOpenBlock(max = 15): string {
-  const todos = listTodos(); // actionable set, sorted
+/** Compact markdown summary of open + in_progress TODOs for system-prompt
+ *  injection. v0.5.0: cap-aware — when actionable > activeMaxOpen (from
+ *  config, or the `max` override), switches to a lean summary (counts +
+ *  over-budget projects + pointer) instead of the row list, keeping the
+ *  prompt bounded when bloated. Under cap → the familiar row list (capped
+ *  at activeMaxOpen rows). */
+export function renderOpenBlock(max?: number): string {
+  const todos = listTodos({ limit: Number.MAX_SAFE_INTEGER }); // actionable set, sorted — unpaginated so the count + slice are exact
   if (todos.length === 0) return "## Open TODOs\n(none — no pending cross-session TODOs)\n";
-  const shown = todos.slice(0, max);
-  const lines = shown.map((t) => {
-    const tag = t.project ? ` (${t.project})` : "";
-    const pin = t.status === "in_progress" ? " ⏵" : "";
-    const dot = t.notes.trim() ? " •" : "";
-    return `- [${t.id}] (${t.priority})${pin}${dot} ${t.title}${tag}`;
-  });
-  const overflow = todos.length > max ? `\n- … +${todos.length - max} more (use \`todo list\`)` : "";
-  return `## Open TODOs (${todos.length})\n${lines.join("\n")}${overflow}\n`;
+  let cap: number;
+  try { cap = max ?? loadConfig().health.activeMaxOpen; } catch { cap = 15; }
+  if (todos.length <= cap) {
+    const shown = todos.slice(0, cap);
+    const lines = shown.map((t) => {
+      const tag = t.project ? ` (${t.project})` : "";
+      const pin = t.status === "in_progress" ? " ⏵" : "";
+      const dot = t.notes.trim() ? " •" : "";
+      return `- [${t.id}] (${t.priority})${pin}${dot} ${t.title}${tag}`;
+    });
+    return `## Open TODOs (${todos.length})\n${lines.join("\n")}\n`;
+  }
+  // over budget → lean summary (the anti-bloat path)
+  let over: { name: string; open: number; maxOpen: number }[] = [];
+  try {
+    const reg = loadRegistry();
+    over = overBudgetProjects(loadStore().todos, reg);
+  } catch {
+    // fail-open: a bad registry shouldn’t break injection
+  }
+  const projects = new Set(todos.map((t) => t.project.trim()).filter(Boolean));
+  const lines = [
+    `## Open TODOs (${todos.length}) — ⚠ over budget (cap ${cap})`,
+    `${todos.length} open+in_progress across ${projects.size} project${projects.size === 1 ? "" : "s"}`,
+  ];
+  if (over.length > 0) {
+    lines.push(`over-budget: ${over.map((p) => `${p.name} ${p.open}/${p.maxOpen}`).join(", ")}`);
+  }
+  lines.push("run `todo list` or `/todo` to see the full list");
+  return lines.join("\n") + "\n";
 }