@getpipher/armory-todo 0.4.0 → 0.5.1

package/src/todo-store.ts

@@ -19,6 +19,10 @@ 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";
+import { backupFile, snapshotOnDrop, appendAudit, countTodosInFile } from "./backup.ts";
 
 export type Priority = "low" | "med" | "high" | "critical";
 export type Status = "open" | "in_progress" | "parked" | "done" | "cancelled";
@@ -147,6 +151,12 @@ export function loadStore(): Store {
 export function saveStore(store: Store): void {
   store.updatedAt = now();
   const path = getLivePath();
+  // v0.5.1 write-audit + backup (post data-loss hardening): back up the current
+  // file, snapshot pre-write state on a count drop, then audit-log the save.
+  const before = countTodosInFile(path);
+  const after = store.todos.length;
+  backupFile(path);
+  const dropSnap = snapshotOnDrop(path, before, after);
   const dir = dirname(path);
   mkdirSync(dir, { recursive: true });
   const tmp = `${path}.tmp`;
@@ -157,6 +167,7 @@ export function saveStore(store: Store): void {
     // some filesystems ignore mode bits; not fatal
   }
   renameSync(tmp, path);
+  appendAudit("todo", before, after, dropSnap);
 }
 
 function assertPriority(p: unknown): asserts p is Priority {
@@ -182,6 +193,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 +261,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 +328,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";
 }