agent-yes 1.122.2 → 1.123.0

package/ts/todoParse.spec.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect } from "vitest";
+import { parseTaskCounts } from "./todoParse.ts";
+
+const lines = (s: string) => s.split("\n");
+
+describe("parseTaskCounts", () => {
+  it("counts a standard ⎿-anchored todo block (done as numerator)", () => {
+    const out = parseTaskCounts(
+      lines(
+        [
+          "⏺ Update Todos",
+          "  ⎿  ☒ Wire up the parser",
+          "     ☒ Add the badge",
+          "     ◼ Compute in /api/ls",
+          "     ◻ Render in the console",
+          "     ◻ Tests",
+        ].join("\n"),
+      ),
+    );
+    expect(out).toEqual({ done: 2, total: 5 });
+  });
+
+  it("treats ✔ ☑ ✓ ☒ all as done, ◼ as in-progress, ◻ ☐ as pending", () => {
+    const out = parseTaskCounts(
+      lines(["⎿ ✔ a", "  ☑ b", "  ✓ c", "  ☒ d", "  ◼ e", "  ◻ f", "  ☐ g"].join("\n")),
+    );
+    expect(out).toEqual({ done: 4, total: 7 });
+  });
+
+  it("returns null with no ⎿ anchor (avoid false positives from prose glyphs)", () => {
+    const out = parseTaskCounts(
+      lines(["I finished ✔ the thing", "and ◻ another note", "✓ done-ish"].join("\n")),
+    );
+    expect(out).toBeNull();
+  });
+
+  it("requires ≥2 marker lines", () => {
+    expect(parseTaskCounts(lines(["⎿ ☒ only one"].join("\n")))).toBeNull();
+  });
+
+  it("picks the MOST RECENT block when several are present", () => {
+    const out = parseTaskCounts(
+      lines(
+        ["⎿ ☒ old1", "  ◻ old2", "  ◻ old3", "...work...", "⎿ ☒ new1", "  ☒ new2", "  ◻ new3"].join(
+          "\n",
+        ),
+      ),
+    );
+    expect(out).toEqual({ done: 2, total: 3 });
+  });
+
+  it("accepts the anchor on the line directly above the markers", () => {
+    const out = parseTaskCounts(lines(["  ⎿", "  ☒ a", "  ◻ b"].join("\n")));
+    expect(out).toEqual({ done: 1, total: 2 });
+  });
+
+  it("stops the block at a non-marker (wrapped/continuation) line", () => {
+    // a prose line between two markers splits the run; the qualifying block is the
+    // contiguous one with the anchor.
+    const out = parseTaskCounts(lines(["⎿ ☒ a", "  ☒ b", "some interruption", "  ◻ c"].join("\n")));
+    expect(out).toEqual({ done: 2, total: 2 });
+  });
+
+  it("returns null for empty / no-todo output", () => {
+    expect(parseTaskCounts([])).toBeNull();
+    expect(parseTaskCounts(lines("just some logs\nnothing here"))).toBeNull();
+  });
+});

package/ts/todoParse.ts

@@ -0,0 +1,88 @@
+/**
+ * Parse an agent's todo/task list out of its RENDERED TUI screen.
+ *
+ * Source of truth for EVERY CLI (claude, codex, gemini, …) is the screen the
+ * agent draws — never a CLI-specific session file. The durable copy is the
+ * per-pid raw log (`<cwd>/.agent-yes/<pid>.raw.log`); rendering it through a
+ * headless xterm (see renderRawLog) collapses the reflow/redraw frames into the
+ * final coherent text, which is what we scan here.
+ *
+ * The todo list in these TUIs renders as a tree block anchored by the `⎿`
+ * branch glyph, one marker per line:
+ *
+ *     ⎿  ☒ Wire up the parser
+ *        ☒ Add the badge
+ *        ◼ Compute in /api/ls      ← in progress
+ *        ◻ Render in the console   ← pending
+ *        ◻ Tests
+ *
+ * Badge = `${done}/${total}` (done is the numerator → "2/5").
+ *
+ * This parse is deliberately conservative: we only report a count when a block
+ * is confidently detected (the `⎿` anchor + ≥2 consecutive marker lines), so an
+ * agent that merely prints a check glyph in prose never produces a phantom badge.
+ */
+
+// Marker glyphs, by state. Kept as single code points so a line is classified by
+// its first non-indent glyph.
+const DONE = new Set(["✔", "☑", "✓", "☒"]);
+const IN_PROGRESS = new Set(["◼"]);
+const PENDING = new Set(["◻", "☐"]);
+const ANCHOR = "⎿";
+
+export interface TaskCounts {
+  done: number;
+  total: number;
+}
+
+type Marker = "done" | "inprogress" | "pending";
+
+// Classify a rendered line: strip leading whitespace and an optional leading `⎿`
+// (+ its whitespace), then look at the first glyph. Returns null for non-marker
+// lines (prose, blank lines, wrapped titles).
+function markerOf(line: string): Marker | null {
+  let s = line.replace(/^\s+/, "");
+  if (s.startsWith(ANCHOR)) s = s.slice(ANCHOR.length).replace(/^\s+/, "");
+  const ch = [...s][0];
+  if (ch === undefined) return null;
+  if (DONE.has(ch)) return "done";
+  if (IN_PROGRESS.has(ch)) return "inprogress";
+  if (PENDING.has(ch)) return "pending";
+  return null;
+}
+
+/**
+ * Find the MOST RECENT confidently-detected todo block in the rendered lines and
+ * return its {done, total}. Returns null when none qualifies (caller omits the
+ * badge entirely — never shows "0/0").
+ *
+ * A block is a maximal run of consecutive marker lines. It only counts when it
+ * is anchored — the `⎿` glyph appears on the run's first line or the line
+ * directly above it — and has ≥2 marker lines. The last qualifying block wins,
+ * since the agent's current todo state is the one drawn most recently.
+ */
+export function parseTaskCounts(lines: string[]): TaskCounts | null {
+  let best: TaskCounts | null = null;
+  const n = lines.length;
+  let i = 0;
+  while (i < n) {
+    if (markerOf(lines[i]!) === null) {
+      i++;
+      continue;
+    }
+    // Start of a marker run at i.
+    let hasAnchor = i > 0 && lines[i - 1]!.includes(ANCHOR);
+    const counts = { done: 0, inprogress: 0, pending: 0 };
+    let j = i;
+    for (; j < n; j++) {
+      const mk = markerOf(lines[j]!);
+      if (mk === null) break;
+      if (lines[j]!.includes(ANCHOR)) hasAnchor = true;
+      counts[mk]++;
+    }
+    const total = counts.done + counts.inprogress + counts.pending;
+    if (hasAnchor && total >= 2) best = { done: counts.done, total };
+    i = j === i ? i + 1 : j;
+  }
+  return best;
+}

package/ts/utils.spec.ts

@@ -19,7 +19,10 @@ describe("utils", () => {
       const start = Date.now();
       await sleepms(0);
       const end = Date.now();
-      expect(end - start).toBeLessThan(50); // Should be quick
+      // Generous bound: catches a real regression (e.g. sleepms ignoring 0 and
+      // hanging) without flaking on a GC pause / loaded CI runner. The await
+      // itself already proves it resolves; this just guards against a hang.
+      expect(end - start).toBeLessThan(1000);
     });
   });
 

package/dist/SUPPORTED_CLIS-DcOKE9Nz.js

@@ -1,8 +0,0 @@
-import "./ts-CIf0uaR7.js";
-import "./logger-B9h0djqx.js";
-import "./versionChecker-DjxKi4qe.js";
-import "./pidStore-B5vBu8Px.js";
-import "./globalPidIndex-gZuTvTBs.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-BTu2brih.js";
-
-export { SUPPORTED_CLIS };

package/dist/pidStore-7y1cTcAE.js

@@ -1,5 +0,0 @@
-import "./logger-B9h0djqx.js";
-import { t as PidStore } from "./pidStore-B5vBu8Px.js";
-import "./globalPidIndex-gZuTvTBs.js";
-
-export { PidStore };

package/dist/reaper-HqcUms2d.js

@@ -1,3 +0,0 @@
-import { n as sweep, t as register } from "./reaper-Dj8R7ltI.js";
-
-export { sweep };

package/dist/subcommands-D8sHibKu.js

@@ -1,6 +0,0 @@
-import "./logger-B9h0djqx.js";
-import "./globalPidIndex-gZuTvTBs.js";
-import "./remotes-D2fqaRU8.js";
-import { a as finalizedLines, c as listRecords, d as renderRawLog, f as resolveOne, g as writeToIpc, h as stopTipForCli, i as cursorAbs, l as matchKeyword, m as snapshotStatus, n as cmdHelp, o as isPidAlive, p as runSubcommand, r as controlCodeFromName, s as isSubcommand, t as GRACEFUL_EXIT_COMMANDS, u as readNotes } from "./subcommands-D9BWZilr.js";
-
-export { cmdHelp, isSubcommand, runSubcommand };