@blackbelt-technology/pi-agent-dashboard 0.2.9 → 0.4.0

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

@@ -0,0 +1,100 @@
+/**
+ * Tests for fork entryId timing fix.
+ *
+ * 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).
+ *
+ * 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.
+ */
+import { describe, it, expect, vi } 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
+    const sessionManager = {
+      getLeafId: () => leafId,
+    };
+
+    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();
+    };
+
+    // 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;
+
+    expect(capturedEntryId).toBe("assistant-entry-101");
+  });
+
+  it("immediate getLeafId() would capture the stale entry ID (demonstrates the bug)", async () => {
+    let leafId = "user-entry-100";
+    const sessionManager = {
+      getLeafId: () => leafId,
+    };
+
+    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();
+    };
+
+    // Simulate pi core's _processAgentEvent:
+    const handlerPromise = buggyBridgeHandler();
+    leafId = "assistant-entry-101"; // too late — handler already read it
+
+    await handlerPromise;
+
+    // Bug: captures the stale leaf, not the assistant's entry
+    expect(capturedEntryId).toBe("user-entry-100");
+  });
+
+  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;
+
+    // message_start should capture the leaf BEFORE the user entry is written
+    expect(capturedEntryId).toBe("previous-assistant-entry-99");
+  });
+});

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__/openspec-poller.test.ts

@@ -1,119 +1,124 @@
+/**
+ * Tests for openspec-poller.ts — the higher-level aggregator that combines
+ * `openspec list` + per-change `openspec status` into the dashboard's
+ * `OpenSpecData` shape.
+ *
+ * The file now delegates to `platform/openspec.ts` for the subprocess work.
+ * We mock that module so the tests focus on the aggregation logic
+ * (empty results, artifact mapping, per-change status failures) without
+ * spawning openspec.
+ *
+ * See change: platform-command-executor.
+ */
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { SpawnSyncReturns } from "node:child_process";
-
-// We need to mock spawnSync before importing the module under test
-const mockSpawnSync = vi.fn<(...args: any[]) => any>();
-const mockExecFile = vi.fn<(...args: any[]) => any>();
-vi.mock("node:child_process", () => ({
-  spawnSync: mockSpawnSync,
-  execFile: mockExecFile,
-  // re-export defaults that node:child_process has
-  default: { spawnSync: mockSpawnSync, execFile: mockExecFile },
+
+const { listOr, statusOr } = vi.hoisted(() => ({
+  listOr: vi.fn(),
+  statusOr: vi.fn(),
 }));
 
-// Import after mock is set up
-const { pollOpenSpec } = await import("@blackbelt-technology/pi-dashboard-shared/openspec-poller.js");
-
-function ok(data: unknown): Partial<SpawnSyncReturns<string>> {
-  return { status: 0, stdout: JSON.stringify(data), stderr: "" };
-}
-
-function fail(): Partial<SpawnSyncReturns<string>> {
-  return { status: 1, stdout: "", stderr: "error" };
-}
-
-function mockCli(responses: Map<string, unknown>) {
-  mockSpawnSync.mockImplementation((_cmd: any, args: any) => {
-    const a = args as string[];
-    if (a.includes("list")) {
-      const d = responses.get("list");
-      return d ? ok(d) : fail();
-    }
-    if (a.includes("status")) {
-      const idx = a.indexOf("--change");
-      const name = idx >= 0 ? a[idx + 1] : "";
-      const d = responses.get(`status:${name}`);
-      return d ? ok(d) : fail();
-    }
-    return fail();
-  });
-}
+vi.mock("@blackbelt-technology/pi-dashboard-shared/platform/openspec.js", () => ({
+  listOr,
+  statusOr,
+}));
 
-beforeEach(() => {
-  mockSpawnSync.mockReset();
-});
+import { pollOpenSpec } from "@blackbelt-technology/pi-dashboard-shared/openspec-poller.js";
 
 describe("pollOpenSpec", () => {
-  it("returns initialized=false when CLI throws", () => {
-    mockSpawnSync.mockImplementation(() => { throw new Error("ENOENT"); });
-    const result = pollOpenSpec("/project");
-    expect(result).toEqual({ initialized: false, changes: [] });
+  beforeEach(() => {
+    listOr.mockReset();
+    statusOr.mockReset();
   });
 
-  it("returns initialized=false when list returns non-zero exit", () => {
-    mockSpawnSync.mockReturnValue(fail());
-    const result = pollOpenSpec("/project");
-    expect(result).toEqual({ initialized: false, changes: [] });
+  it("returns initialized=false when list fails", () => {
+    listOr.mockReturnValue(null);
+    expect(pollOpenSpec("/test")).toEqual({ initialized: false, changes: [] });
+  });
+
+  it("returns initialized=false when list returns non-array changes", () => {
+    listOr.mockReturnValue({ changes: "not an array" });
+    expect(pollOpenSpec("/test")).toEqual({ initialized: false, changes: [] });
   });
 
   it("returns initialized=true with changes on success", () => {
-    mockCli(new Map([
-      ["list", {
-        changes: [
-          { name: "feat-a", status: "in-progress", completedTasks: 3, totalTasks: 5 },
-          { name: "feat-b", status: "complete", completedTasks: 4, totalTasks: 4 },
-        ],
-      }],
-      ["status:feat-a", {
-        artifacts: [
-          { id: "proposal", status: "done" },
-          { id: "design", status: "ready" },
-          { id: "tasks", status: "blocked" },
-        ],
-      }],
-      ["status:feat-b", {
-        artifacts: [
-          { id: "proposal", status: "done" },
-          { id: "tasks", status: "done" },
-        ],
-      }],
-    ]));
-
-    const result = pollOpenSpec("/project");
-    expect(result.initialized).toBe(true);
-    expect(result.changes).toHaveLength(2);
-    expect(result.changes[0]).toEqual({
-      name: "feat-a",
-      status: "in-progress",
-      completedTasks: 3,
-      totalTasks: 5,
+    listOr.mockReturnValue({
+      changes: [
+        { name: "add-auth", status: "in-progress", completedTasks: 3, totalTasks: 10 },
+      ],
+    });
+    statusOr.mockReturnValue({
       artifacts: [
         { id: "proposal", status: "done" },
-        { id: "design", status: "ready" },
-        { id: "tasks", status: "blocked" },
+        { id: "tasks", status: "ready" },
       ],
     });
-    expect(result.changes[1].status).toBe("complete");
-  });
 
-  it("handles invalid JSON gracefully", () => {
-    mockSpawnSync.mockReturnValue({ status: 0, stdout: "not json {{{", stderr: "" });
-    const result = pollOpenSpec("/project");
-    expect(result).toEqual({ initialized: false, changes: [] });
+    const result = pollOpenSpec("/test");
+    expect(result.initialized).toBe(true);
+    expect(result.changes).toHaveLength(1);
+    expect(result.changes[0]).toMatchObject({
+      name: "add-auth",
+      status: "in-progress",
+      completedTasks: 3,
+      totalTasks: 10,
+    });
+    expect(result.changes[0].artifacts).toEqual([
+      { id: "proposal", status: "done" },
+      { id: "tasks", status: "ready" },
+    ]);
   });
 
   it("handles status call failure gracefully (empty artifacts)", () => {
-    mockCli(new Map([
-      ["list", {
-        changes: [
-          { name: "feat-a", status: "no-tasks", completedTasks: 0, totalTasks: 0 },
-        ],
-      }],
-      // No status:feat-a — status call fails
-    ]));
-
-    const result = pollOpenSpec("/project");
+    listOr.mockReturnValue({
+      changes: [
+        { name: "x", status: "complete", completedTasks: 5, totalTasks: 5 },
+      ],
+    });
+    statusOr.mockReturnValue(null); // status failed
+
+    const result = pollOpenSpec("/test");
     expect(result.initialized).toBe(true);
     expect(result.changes[0].artifacts).toEqual([]);
   });
+
+  it("normalizes unknown status values to 'no-tasks'", () => {
+    listOr.mockReturnValue({
+      changes: [
+        { name: "x", status: "weird-future-status", completedTasks: 0, totalTasks: 0 },
+      ],
+    });
+    statusOr.mockReturnValue(null);
+
+    const result = pollOpenSpec("/test");
+    expect(result.changes[0].status).toBe("no-tasks");
+  });
+
+  it("normalizes unknown artifact statuses to 'blocked'", () => {
+    listOr.mockReturnValue({
+      changes: [
+        { name: "x", status: "in-progress", completedTasks: 0, totalTasks: 1 },
+      ],
+    });
+    statusOr.mockReturnValue({
+      artifacts: [{ id: "proposal", status: "some-new-state" }],
+    });
+
+    const result = pollOpenSpec("/test");
+    expect(result.changes[0].artifacts[0].status).toBe("blocked");
+  });
+
+  it("calls statusOr once per change, with the change name", () => {
+    listOr.mockReturnValue({
+      changes: [
+        { name: "a", status: "in-progress", completedTasks: 0, totalTasks: 1 },
+        { name: "b", status: "complete", completedTasks: 2, totalTasks: 2 },
+      ],
+    });
+    statusOr.mockReturnValue({ artifacts: [] });
+
+    pollOpenSpec("/test");
+    expect(statusOr).toHaveBeenCalledTimes(2);
+    expect(statusOr).toHaveBeenNthCalledWith(1, { cwd: "/test", change: "a" });
+    expect(statusOr).toHaveBeenNthCalledWith(2, { cwd: "/test", change: "b" });
+  });
 });

package/packages/extension/src/__tests__/process-scanner-kill.test.ts

@@ -0,0 +1,61 @@
+/**
+ * Tests that `killProcessByPgid` routes through the platform's
+ * `killPidWithGroup` helper (not raw `process.kill`).
+ *
+ * See change: route-kill-paths-through-platform.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const killPidWithGroupSpy = vi.fn((_pid: number, _sig: any, _opts?: any) => undefined);
+
+vi.mock("@blackbelt-technology/pi-dashboard-shared/platform/process.js", async () => {
+  const actual = await vi.importActual<typeof import("@blackbelt-technology/pi-dashboard-shared/platform/process.js")>(
+    "@blackbelt-technology/pi-dashboard-shared/platform/process.js",
+  );
+  return {
+    ...actual,
+    killPidWithGroup: (pid: number, sig: any, opts?: any) => killPidWithGroupSpy(pid, sig, opts),
+  };
+});
+
+const { killProcessByPgid } = await import("../process-scanner.js");
+
+describe("killProcessByPgid platform routing", () => {
+  beforeEach(() => {
+    killPidWithGroupSpy.mockClear();
+  });
+
+  it("invokes killPidWithGroup with the resolved platform on Unix", () => {
+    const ok = killProcessByPgid(4242, { _platform: "linux" } as any);
+    expect(ok).toBe(true);
+    expect(killPidWithGroupSpy).toHaveBeenCalledTimes(1);
+    const [pid, sig, opts] = killPidWithGroupSpy.mock.calls[0];
+    expect(pid).toBe(4242);
+    expect(sig).toBe("SIGTERM");
+    expect(opts?.platform).toBe("linux");
+  });
+
+  it("invokes killPidWithGroup with platform=darwin for macOS pgids", () => {
+    killProcessByPgid(9999, { _platform: "darwin" } as any);
+    const [pid, , opts] = killPidWithGroupSpy.mock.calls[0];
+    expect(pid).toBe(9999);
+    expect(opts?.platform).toBe("darwin");
+  });
+
+  it("does NOT call process.kill directly on Unix", () => {
+    const processKillSpy = vi.spyOn(process, "kill");
+    try {
+      killProcessByPgid(1234, { _platform: "linux" } as any);
+    } catch { /* ignore */ }
+    expect(processKillSpy).not.toHaveBeenCalled();
+    processKillSpy.mockRestore();
+  });
+
+  it("reports failure if killPidWithGroup throws", () => {
+    killPidWithGroupSpy.mockImplementationOnce(() => {
+      throw new Error("ESRCH");
+    });
+    const ok = killProcessByPgid(4242, { _platform: "linux" } as any);
+    expect(ok).toBe(false);
+  });
+});