@blackbelt-technology/pi-agent-dashboard 0.3.0 → 0.4.1

package/packages/extension/src/__tests__/fork-entryid-timing.test.ts

@@ -1,100 +1,88 @@
 /**
- * Tests for fork entryId timing fix.
+ * Tests for bridge entryId stamping on message_end events.
  *
- * Verifies that the bridge's message_end entryId enrichment captures the
- * correct leaf ID (after pi core persists the entry), not the stale one
- * (before appendMessage runs).
+ * HISTORY: Originally this file modelled pi <0.69's synchronous emit pattern,
+ * where the bridge's `queueMicrotask` deferral ran BEFORE
+ * sessionManager.appendMessage. That design no longer reflects pi 0.70.x:
+ * pi awaits extension handlers inside _emitExtensionEvent, so the microtask
+ * resolves *inside* the awaited dispatcher, before persistence. The fix
+ * (see change: fix-per-message-fork) is `setTimeout(0)` (a macrotask)
+ * combined with reading `event.message.id` (which pi mutates in place
+ * during appendMessage) or a WeakMap populated by the wrapped appendMessage.
  *
- * The bug: pi core emits message_end via _emit() BEFORE calling
- * sessionManager.appendMessage(), so getLeafId() returns the previous leaf.
- * The fix: the bridge defers getLeafId() for message_end using queueMicrotask,
- * allowing appendMessage to run first.
+ * The previous test "message_start should still capture entryId immediately
+ * (no deferral)" codified the off-by-one bug as expected behavior — it has
+ * been REMOVED. The current test suite below models pi 0.70.x semantics
+ * directly. Detailed pi-0.70-specific scenarios live in
+ * `bridge-entry-id-pi-070.test.ts`.
  */
-import { describe, it, expect, vi } from "vitest";
+import { describe, it, expect } from "vitest";
 
-/**
- * Simulates the pi core + bridge interaction for entryId enrichment.
- *
- * Pi core's _processAgentEvent does:
- *   1. _emit(event)          — bridge handler called (async, not awaited)
- *   2. appendMessage(msg)    — updates leafId synchronously
- *
- * The bridge handler (async) should yield via queueMicrotask before reading
- * getLeafId(), so that appendMessage has already run.
- */
-describe("message_end entryId timing", () => {
-  it("deferred getLeafId() captures the post-persist entry ID", async () => {
-    // Simulate sessionManager with mutable leafId
-    let leafId = "user-entry-100"; // stale leaf before appendMessage
+describe("message_end entryId timing on pi 0.70.x", () => {
+  it("setTimeout(0) deferral captures the post-persist entry ID", async () => {
+    // Simulate pi 0.70.x: bridge handler runs awaited, THEN appendMessage runs.
+    let leafId = "user-entry-100";
     const sessionManager = {
       getLeafId: () => leafId,
+      appendMessage: (msg: any) => {
+        msg.id = "assistant-entry-101";
+        leafId = msg.id;
+        return msg.id;
+      },
     };
 
-    let capturedEntryId: string | undefined;
-
-    // Simulate the bridge handler (with the fix: defers via queueMicrotask)
-    const bridgeHandler = async () => {
-      // This is what the fixed bridge does for message_end:
-      await new Promise<void>(resolve => queueMicrotask(resolve));
-      capturedEntryId = sessionManager.getLeafId();
+    const event = { type: "message_end", message: { role: "assistant" } as any };
+    let captured: string | undefined;
+    let sendDone!: () => void;
+    const sentP = new Promise<void>((r) => { sendDone = r; });
+
+    // Bridge handler: schedules a setTimeout(0) and returns synchronously.
+    // The awaited dispatcher then unwinds, appendMessage runs, AND finally
+    // the timeout fires.
+    const bridgeHandler = (ev: any) => {
+      setTimeout(() => {
+        captured = ev.message.id ?? sessionManager.getLeafId();
+        sendDone();
+      }, 0);
     };
 
-    // Simulate pi core's _processAgentEvent:
-    // 1. _emit calls handler (async, NOT awaited)
-    const handlerPromise = bridgeHandler();
-    // 2. appendMessage runs synchronously, updating leafId
-    leafId = "assistant-entry-101";
-
-    // Wait for the deferred handler to complete
-    await handlerPromise;
+    // Simulate the dispatcher: await handler, then call appendMessage.
+    await bridgeHandler(event);
+    sessionManager.appendMessage(event.message);
+    await sentP;
 
-    expect(capturedEntryId).toBe("assistant-entry-101");
+    expect(captured).toBe("assistant-entry-101");
   });
 
-  it("immediate getLeafId() would capture the stale entry ID (demonstrates the bug)", async () => {
+  it("queueMicrotask deferral would NOT work on pi 0.70.x (regression demonstration)", async () => {
+    // Reproduces why we abandoned queueMicrotask: it resolves inside the
+    // awaited dispatcher, before appendMessage runs.
     let leafId = "user-entry-100";
-    const sessionManager = {
-      getLeafId: () => leafId,
-    };
+    let captured: string | undefined;
 
-    let capturedEntryId: string | undefined;
-
-    // Simulate the OLD (buggy) bridge handler: reads getLeafId() immediately
-    const buggyBridgeHandler = async () => {
-      // No deferral — reads leafId before appendMessage runs
-      capturedEntryId = sessionManager.getLeafId();
+    const buggyBridge = async () => {
+      await new Promise<void>((resolve) => queueMicrotask(resolve));
+      captured = leafId;
     };
 
-    // Simulate pi core's _processAgentEvent:
-    const handlerPromise = buggyBridgeHandler();
-    leafId = "assistant-entry-101"; // too late — handler already read it
-
-    await handlerPromise;
+    // Pi 0.70.x: await the bridge, THEN persist. Mirroring the real ordering:
+    const handlerP = buggyBridge();
+    await handlerP;
+    leafId = "assistant-entry-101"; // appendMessage runs after await
 
-    // Bug: captures the stale leaf, not the assistant's entry
-    expect(capturedEntryId).toBe("user-entry-100");
+    expect(captured).toBe("user-entry-100");
+    expect(captured).not.toBe("assistant-entry-101");
   });
 
-  it("message_start should still capture entryId immediately (no deferral)", async () => {
-    let leafId = "previous-assistant-entry-99";
-    const sessionManager = {
-      getLeafId: () => leafId,
-    };
-
-    let capturedEntryId: string | undefined;
-
-    // Simulate bridge handler for message_start (immediate, no deferral)
-    const messageStartHandler = async () => {
-      capturedEntryId = sessionManager.getLeafId();
-    };
-
-    const handlerPromise = messageStartHandler();
-    // User entry gets written after message_start
-    leafId = "user-entry-100";
-
-    await handlerPromise;
+  it("entry_persisted is the back-fill mechanism for user message_start (where event.message.id is unavailable)", () => {
+    // Behavioural assertion (pure data shape): when the bridge sends a
+    // user message_start, it stamps a nonce; later when pi persists the
+    // user entry, the bridge sends entry_persisted { nonce, entryId }.
+    // The reducer pairs them by nonce. See change: fix-per-message-fork.
+    const start = { type: "message_start", message: { role: "user" }, nonce: "n-1" };
+    const persisted = { type: "entry_persisted", entryId: "user-200", nonce: "n-1" };
 
-    // message_start should capture the leaf BEFORE the user entry is written
-    expect(capturedEntryId).toBe("previous-assistant-entry-99");
+    expect(start.nonce).toBe(persisted.nonce);
+    expect(persisted.entryId).toBe("user-200");
   });
 });

package/packages/extension/src/__tests__/git-info.test.ts

@@ -1,112 +1,124 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { gatherGitInfo, detectBranch, detectRemoteUrl, detectPrNumber } from "../git-info.js";
-
-const { execSyncMock } = vi.hoisted(() => ({
-  execSyncMock: vi.fn(),
+/**
+ * Tests for git-info.ts.
+ *
+ * The file now delegates to `@blackbelt-technology/pi-dashboard-shared/platform/git.js`
+ * (the Recipe-based tool module). We mock that module so the tests focus
+ * on the git-info orchestration logic (branch detection, detached HEAD
+ * fallback, PR detection) without spawning git.
+ *
+ * See change: platform-command-executor.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const { currentBranchOr, headShaOr, remoteUrlOr, prNumberOr } = vi.hoisted(() => ({
+  currentBranchOr: vi.fn(),
+  headShaOr: vi.fn(),
+  remoteUrlOr: vi.fn(),
+  prNumberOr: vi.fn(),
 }));
 
-vi.mock("node:child_process", () => ({
-  default: { execSync: execSyncMock },
-  execSync: execSyncMock,
+vi.mock("@blackbelt-technology/pi-dashboard-shared/platform/git.js", () => ({
+  currentBranchOr,
+  headShaOr,
+  remoteUrlOr,
+  prNumberOr,
 }));
 
+import { gatherGitInfo, detectBranch, detectRemoteUrl, detectPrNumber } from "../git-info.js";
+
 describe("git-info", () => {
   beforeEach(() => {
-    execSyncMock.mockReset();
+    currentBranchOr.mockReset();
+    headShaOr.mockReset();
+    remoteUrlOr.mockReset();
+    prNumberOr.mockReset();
   });
 
   describe("detectBranch", () => {
     it("returns branch name", () => {
-      execSyncMock.mockReturnValue("main\n");
+      currentBranchOr.mockReturnValue("main");
       expect(detectBranch("/test")).toBe("main");
     });
 
     it("returns undefined when not a git repo", () => {
-      execSyncMock.mockImplementation(() => { throw new Error("not a git repo"); });
+      currentBranchOr.mockReturnValue(undefined);
       expect(detectBranch("/test")).toBeUndefined();
     });
 
     it("returns short SHA for detached HEAD", () => {
-      execSyncMock
-        .mockReturnValueOnce("HEAD\n")       // rev-parse --abbrev-ref HEAD
-        .mockReturnValueOnce("abc1234\n");   // rev-parse --short HEAD
+      currentBranchOr.mockReturnValue("HEAD");
+      headShaOr.mockReturnValue("abc1234");
       expect(detectBranch("/test")).toBe("abc1234");
     });
 
     it("returns 'HEAD' as fallback if short SHA fails", () => {
-      execSyncMock
-        .mockReturnValueOnce("HEAD\n")
-        .mockImplementationOnce(() => { throw new Error("fail"); });
+      currentBranchOr.mockReturnValue("HEAD");
+      headShaOr.mockReturnValue(undefined);
       expect(detectBranch("/test")).toBe("HEAD");
     });
   });
 
   describe("detectRemoteUrl", () => {
-    it("returns remote URL", () => {
-      execSyncMock.mockReturnValue("git@github.com:user/repo.git\n");
-      expect(detectRemoteUrl("/test")).toBe("git@github.com:user/repo.git");
+    it("returns origin remote URL", () => {
+      remoteUrlOr.mockReturnValue("git@github.com:org/repo.git");
+      expect(detectRemoteUrl("/test")).toBe("git@github.com:org/repo.git");
     });
 
-    it("returns undefined when no origin", () => {
-      execSyncMock.mockImplementation(() => { throw new Error("no remote"); });
+    it("returns undefined when no remote is configured", () => {
+      remoteUrlOr.mockReturnValue(undefined);
       expect(detectRemoteUrl("/test")).toBeUndefined();
     });
   });
 
   describe("detectPrNumber", () => {
-    it("returns PR number from gh CLI", () => {
-      execSyncMock.mockReturnValue("42\n");
+    it("returns PR number when gh finds one", () => {
+      prNumberOr.mockReturnValue(42);
       expect(detectPrNumber("/test")).toBe(42);
     });
 
-    it("returns undefined when gh CLI fails", () => {
-      execSyncMock.mockImplementation(() => { throw new Error("gh not found"); });
+    it("returns undefined when gh is missing or no PR exists", () => {
+      prNumberOr.mockReturnValue(undefined);
       expect(detectPrNumber("/test")).toBeUndefined();
     });
   });
 
   describe("gatherGitInfo", () => {
-    it("returns full git info with links", () => {
-      execSyncMock
-        .mockReturnValueOnce("feat/foo\n")    // branch
-        .mockReturnValueOnce("git@github.com:user/repo.git\n")  // remote
-        .mockReturnValueOnce("7\n");          // PR
-
-      const info = gatherGitInfo("/test");
-      expect(info).toEqual({
-        gitBranch: "feat/foo",
-        gitBranchUrl: "https://github.com/user/repo/tree/feat%2Ffoo",
-        gitPrNumber: 7,
-        gitPrUrl: "https://github.com/user/repo/pull/7",
-      });
-    });
-
     it("returns undefined when not a git repo", () => {
-      execSyncMock.mockImplementation(() => { throw new Error("not a git repo"); });
+      currentBranchOr.mockReturnValue(undefined);
       expect(gatherGitInfo("/test")).toBeUndefined();
     });
 
-    it("returns info without PR when gh fails", () => {
-      execSyncMock
-        .mockReturnValueOnce("main\n")
-        .mockReturnValueOnce("git@github.com:user/repo.git\n")
-        .mockImplementationOnce(() => { throw new Error("gh not found"); });
+    it("returns GitInfo for a repo with branch + remote + PR", () => {
+      currentBranchOr.mockReturnValue("feature/x");
+      remoteUrlOr.mockReturnValue("git@github.com:org/repo.git");
+      prNumberOr.mockReturnValue(123);
 
       const info = gatherGitInfo("/test");
-      expect(info?.gitBranch).toBe("main");
-      expect(info?.gitPrNumber).toBeUndefined();
-      expect(info?.gitPrUrl).toBeUndefined();
+      expect(info?.gitBranch).toBe("feature/x");
+      expect(info?.gitPrNumber).toBe(123);
+      // Branch URLs URL-encode slashes (feature/x → feature%2Fx) in some builders
+      expect(info?.gitBranchUrl).toMatch(/feature(\/|%2F)x/);
+      expect(info?.gitPrUrl).toContain("123");
     });
 
-    it("returns info without links when no remote", () => {
-      execSyncMock
-        .mockReturnValueOnce("main\n")
-        .mockImplementationOnce(() => { throw new Error("no remote"); })
-        .mockImplementationOnce(() => { throw new Error("gh not found"); });
+    it("returns GitInfo without links when there's no remote", () => {
+      currentBranchOr.mockReturnValue("main");
+      remoteUrlOr.mockReturnValue(undefined);
+      prNumberOr.mockReturnValue(undefined);
 
       const info = gatherGitInfo("/test");
       expect(info?.gitBranch).toBe("main");
       expect(info?.gitBranchUrl).toBeUndefined();
     });
+
+    it("handles detached HEAD with short SHA", () => {
+      currentBranchOr.mockReturnValue("HEAD");
+      headShaOr.mockReturnValue("abc1234");
+      remoteUrlOr.mockReturnValue(undefined);
+      prNumberOr.mockReturnValue(undefined);
+
+      const info = gatherGitInfo("/test");
+      expect(info?.gitBranch).toBe("abc1234");
+    });
   });
 });

package/packages/extension/src/__tests__/multiselect-list.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect, vi } from "vitest";
+import { MultiSelectList } from "../multiselect-list.js";
+
+function make(options: string[] = ["A", "B", "C"], title = "Pick", message?: string) {
+  const list = new MultiSelectList(title, options, message);
+  const onConfirm = vi.fn();
+  const onCancel = vi.fn();
+  list.onConfirm = onConfirm;
+  list.onCancel = onCancel;
+  return { list, onConfirm, onCancel };
+}
+
+describe("MultiSelectList", () => {
+  describe("keybindings", () => {
+    it("space toggles the checked state of the current item and nothing else", () => {
+      const { list, onConfirm } = make();
+      list.handleInput(" "); // toggle index 0 → A checked
+      list.handleInput("\r");
+      expect(onConfirm).toHaveBeenCalledWith(["A"]);
+    });
+
+    it("arrow down moves cursor and space toggles the new current item", () => {
+      const { list, onConfirm } = make();
+      list.handleInput("\u001b[B"); // cursor → 1 (B)
+      list.handleInput(" "); // B checked
+      list.handleInput("\r");
+      expect(onConfirm).toHaveBeenCalledWith(["B"]);
+    });
+
+    it("j / k navigation works like arrows", () => {
+      const { list, onConfirm } = make();
+      list.handleInput("j"); // cursor → 1
+      list.handleInput("j"); // cursor → 2
+      list.handleInput(" "); // C checked
+      list.handleInput("k"); // cursor → 1
+      list.handleInput(" "); // B checked
+      list.handleInput("\r");
+      // selected values returned in ORIGINAL order
+      expect(onConfirm).toHaveBeenCalledWith(["B", "C"]);
+    });
+
+    it("enter with nothing checked confirms with []", () => {
+      const { list, onConfirm } = make();
+      list.handleInput("\r");
+      expect(onConfirm).toHaveBeenCalledWith([]);
+    });
+
+    it("escape cancels; no confirm is fired", () => {
+      const { list, onConfirm, onCancel } = make();
+      list.handleInput(" "); // check A
+      list.handleInput("\u001b");
+      expect(onCancel).toHaveBeenCalledTimes(1);
+      expect(onConfirm).not.toHaveBeenCalled();
+    });
+
+    it("pressing 'a' does NOT bulk-toggle (no select-all in TUI)", () => {
+      const { list, onConfirm } = make();
+      list.handleInput("a");
+      list.handleInput("\r");
+      expect(onConfirm).toHaveBeenCalledWith([]);
+    });
+
+    it("cursor does not go below 0", () => {
+      const { list } = make();
+      list.handleInput("k");
+      list.handleInput("k");
+      expect(list.getCursor()).toBe(0);
+    });
+
+    it("cursor does not go past last item", () => {
+      const { list } = make(["A", "B"]);
+      list.handleInput("j");
+      list.handleInput("j");
+      list.handleInput("j");
+      expect(list.getCursor()).toBe(1);
+    });
+
+    it("toggling twice returns item to unchecked", () => {
+      const { list, onConfirm } = make();
+      list.handleInput(" ");
+      list.handleInput(" ");
+      list.handleInput("\r");
+      expect(onConfirm).toHaveBeenCalledWith([]);
+    });
+
+    it("selected order follows original option order, not toggle order", () => {
+      const { list, onConfirm } = make(["A", "B", "C", "D"]);
+      // toggle D first, then A, then C
+      list.handleInput("j");
+      list.handleInput("j");
+      list.handleInput("j");
+      list.handleInput(" "); // D
+      list.handleInput("k");
+      list.handleInput("k");
+      list.handleInput("k");
+      list.handleInput(" "); // A
+      list.handleInput("j");
+      list.handleInput("j");
+      list.handleInput(" "); // C
+      list.handleInput("\r");
+      expect(onConfirm).toHaveBeenCalledWith(["A", "C", "D"]);
+    });
+  });
+
+  describe("render", () => {
+    it("includes footer hint", () => {
+      const { list } = make();
+      const lines = list.render(80);
+      expect(lines.some((l) => l.includes("space toggle"))).toBe(true);
+      expect(lines.some((l) => l.includes("enter confirm"))).toBe(true);
+      expect(lines.some((l) => l.includes("esc cancel"))).toBe(true);
+    });
+
+    it("renders [ ] for unchecked and [x] for checked items", () => {
+      const { list } = make();
+      list.handleInput(" "); // check A
+      const lines = list.render(80);
+      expect(lines.some((l) => l.includes("[x] A"))).toBe(true);
+      expect(lines.some((l) => l.includes("[ ] B"))).toBe(true);
+    });
+
+    it("renders cursor marker on current item", () => {
+      const { list } = make();
+      list.handleInput("j"); // cursor → 1
+      const lines = list.render(80);
+      // Cursor line should start with "▸ " somewhere
+      expect(lines.some((l) => l.startsWith("▸ ") && l.includes("B"))).toBe(true);
+    });
+
+    it("includes title and message when provided", () => {
+      const { list } = make(["A", "B"], "Pick one or more", "Some context");
+      const lines = list.render(80);
+      expect(lines.some((l) => l.includes("Pick one or more"))).toBe(true);
+      expect(lines.some((l) => l.includes("Some context"))).toBe(true);
+    });
+  });
+});

package/packages/extension/src/__tests__/no-session-replacement-calls.test.ts

@@ -0,0 +1,99 @@
+/**
+ * Repo-level invariant: the bridge MUST NOT call pi's session-replacement
+ * APIs (`pi.newSession(...)`, `ctx.fork(...)`, `ctx.switchSession(...)`)
+ * from any code under `packages/extension/src/`.
+ *
+ * Rationale: pi 0.69.0+ invalidates captured pre-replacement `pi`/`ctx`/
+ * session-bound objects on next access after these calls. The bridge
+ * holds long-lived caches (`cachedCtx`, `cachedModelRegistry`,
+ * `cachedHasUI` in `bridge.ts`; `modelRegistry` in `provider-register.ts`)
+ * that depend on pi being the ONLY originator of session replacement, so
+ * we can re-capture inside the resulting `session_start` handler keyed on
+ * `event.reason ∈ {"new","fork","resume"}`.
+ *
+ * If this test fails: do NOT add the call. Either drive the user-facing
+ * action through the dashboard server (which prompts the user, who
+ * triggers replacement via pi's UI), or wrap your post-switch work in
+ * the `withSession` callback that pi 0.69+ exposes on each replacement
+ * API and capture the freshly-emitted ReplacedSessionContext there.
+ *
+ * See change: pi-zero-seventy-compat.
+ */
+import { describe, it, expect } from "vitest";
+import fs from "node:fs/promises";
+import path from "node:path";
+import url from "node:url";
+
+/**
+ * Each pattern matches `<receiver>.<method>(` allowing for whitespace and
+ * tolerating common variations like `await pi.newSession(...)`. Prefixed
+ * with a non-word boundary so we don't flag method names embedded in
+ * longer identifiers.
+ */
+const PATTERNS: ReadonlyArray<{ name: string; re: RegExp }> = [
+  { name: "pi.newSession",     re: /(?:^|[^.\w])pi\.newSession\s*\(/ },
+  { name: "ctx.fork",          re: /(?:^|[^.\w])ctx\.fork\s*\(/ },
+  { name: "ctx.switchSession", re: /(?:^|[^.\w])ctx\.switchSession\s*\(/ },
+];
+
+/**
+ * Per-line opt-out marker. Use only for documented exceptions (e.g. a
+ * future migration cell that intentionally drives a replacement and
+ * fully re-binds via `withSession`):
+ *   await pi.newSession({ withSession: ... }); // ban:session-replacement-ok
+ */
+const OPT_OUT_MARKER = "ban:session-replacement-ok";
+
+async function* walk(dir: string): AsyncGenerator<string> {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "__tests__") continue;
+      yield* walk(full);
+    } else if (entry.isFile() && /\.(ts|tsx|mts|cts)$/.test(entry.name)) {
+      yield full;
+    }
+  }
+}
+
+describe("no session-replacement API calls in packages/extension/src/", () => {
+  it("bridge code never invokes pi.newSession / ctx.fork / ctx.switchSession", async () => {
+    const here = path.dirname(url.fileURLToPath(import.meta.url));
+    const srcDir = path.resolve(here, "..");
+    const repoRoot = path.resolve(here, "..", "..", "..", "..");
+
+    const violations: Array<{ file: string; line: number; pattern: string; text: string }> = [];
+
+    for await (const file of walk(srcDir)) {
+      const content = await fs.readFile(file, "utf-8");
+      const lines = content.split(/\r?\n/);
+      lines.forEach((line, idx) => {
+        if (line.includes(OPT_OUT_MARKER)) return;
+        for (const { name, re } of PATTERNS) {
+          if (re.test(line)) {
+            violations.push({
+              file: path.relative(repoRoot, file),
+              line: idx + 1,
+              pattern: name,
+              text: line.trim(),
+            });
+          }
+        }
+      });
+    }
+
+    if (violations.length > 0) {
+      const msg =
+        `Bridge code MUST NOT call pi session-replacement APIs.\n` +
+        `pi 0.69.0+ invalidates captured pre-replacement pi/ctx after these calls;\n` +
+        `the bridge relies on pi being the sole originator of replacement so it can\n` +
+        `re-capture state inside the resulting session_start handler.\n\n` +
+        `Offenders (${violations.length}):\n` +
+        violations
+          .map((v) => `  ${v.file}:${v.line}  [${v.pattern}]  ${v.text}`)
+          .join("\n");
+      expect(violations, msg).toEqual([]);
+    }
+  });
+});