@blackbelt-technology/pi-agent-dashboard 0.2.0

package/packages/extension/src/__tests__/git-link-builder.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect } from "vitest";
+import { parseRemoteUrl, detectPlatform, buildGitLinks } from "../git-link-builder.js";
+
+describe("parseRemoteUrl", () => {
+  it("parses SSH URL", () => {
+    expect(parseRemoteUrl("git@github.com:user/repo.git")).toEqual({
+      host: "github.com", user: "user", repo: "repo",
+    });
+  });
+
+  it("parses SSH URL without .git suffix", () => {
+    expect(parseRemoteUrl("git@github.com:user/repo")).toEqual({
+      host: "github.com", user: "user", repo: "repo",
+    });
+  });
+
+  it("parses HTTPS URL", () => {
+    expect(parseRemoteUrl("https://github.com/user/repo.git")).toEqual({
+      host: "github.com", user: "user", repo: "repo",
+    });
+  });
+
+  it("parses HTTPS URL without .git suffix", () => {
+    expect(parseRemoteUrl("https://gitlab.com/user/repo")).toEqual({
+      host: "gitlab.com", user: "user", repo: "repo",
+    });
+  });
+
+  it("parses nested group paths", () => {
+    expect(parseRemoteUrl("git@gitlab.com:group/subgroup/repo.git")).toEqual({
+      host: "gitlab.com", user: "group/subgroup", repo: "repo",
+    });
+  });
+
+  it("returns undefined for invalid URL", () => {
+    expect(parseRemoteUrl("not-a-url")).toBeUndefined();
+  });
+});
+
+describe("detectPlatform", () => {
+  it("detects GitHub", () => expect(detectPlatform("github.com")).toBe("github"));
+  it("detects GitLab", () => expect(detectPlatform("gitlab.com")).toBe("gitlab"));
+  it("detects Bitbucket", () => expect(detectPlatform("bitbucket.org")).toBe("bitbucket"));
+  it("detects Gitea", () => expect(detectPlatform("gitea.com")).toBe("gitea"));
+  it("detects Codeberg", () => expect(detectPlatform("codeberg.org")).toBe("codeberg"));
+  it("detects SourceHut", () => expect(detectPlatform("sr.ht")).toBe("sourcehut"));
+  it("returns undefined for unknown host", () => expect(detectPlatform("self-hosted.example.com")).toBeUndefined());
+});
+
+describe("buildGitLinks", () => {
+  it("builds GitHub branch and PR links", () => {
+    const links = buildGitLinks("git@github.com:user/repo.git", "main", 42);
+    expect(links.branchUrl).toBe("https://github.com/user/repo/tree/main");
+    expect(links.prUrl).toBe("https://github.com/user/repo/pull/42");
+  });
+
+  it("builds GitLab branch and MR links", () => {
+    const links = buildGitLinks("https://gitlab.com/user/repo.git", "main", 10);
+    expect(links.branchUrl).toBe("https://gitlab.com/user/repo/-/tree/main");
+    expect(links.prUrl).toBe("https://gitlab.com/user/repo/-/merge_requests/10");
+  });
+
+  it("builds Bitbucket links", () => {
+    const links = buildGitLinks("git@bitbucket.org:user/repo.git", "develop", 5);
+    expect(links.branchUrl).toBe("https://bitbucket.org/user/repo/src/develop");
+    expect(links.prUrl).toBe("https://bitbucket.org/user/repo/pull-requests/5");
+  });
+
+  it("builds Codeberg links", () => {
+    const links = buildGitLinks("https://codeberg.org/user/repo.git", "main", 3);
+    expect(links.branchUrl).toBe("https://codeberg.org/user/repo/src/branch/main");
+    expect(links.prUrl).toBe("https://codeberg.org/user/repo/pulls/3");
+  });
+
+  it("builds SourceHut links", () => {
+    const links = buildGitLinks("git@sr.ht:user/repo.git", "main", 1);
+    expect(links.branchUrl).toBe("https://sr.ht/user/repo/tree/main");
+    expect(links.prUrl).toBe("https://sr.ht/user/repo/patches/1");
+  });
+
+  it("URL-encodes branch names with slashes", () => {
+    const links = buildGitLinks("git@github.com:user/repo.git", "feat/my-feature");
+    expect(links.branchUrl).toBe("https://github.com/user/repo/tree/feat%2Fmy-feature");
+  });
+
+  it("returns empty for unknown host", () => {
+    const links = buildGitLinks("git@self-hosted.example.com:user/repo.git", "main");
+    expect(links.branchUrl).toBeUndefined();
+    expect(links.prUrl).toBeUndefined();
+  });
+
+  it("does not generate branch URL for detached HEAD", () => {
+    const links = buildGitLinks("git@github.com:user/repo.git", "HEAD");
+    expect(links.branchUrl).toBeUndefined();
+  });
+
+  it("builds branch URL without PR", () => {
+    const links = buildGitLinks("git@github.com:user/repo.git", "main");
+    expect(links.branchUrl).toBe("https://github.com/user/repo/tree/main");
+    expect(links.prUrl).toBeUndefined();
+  });
+});

package/packages/extension/src/__tests__/openspec-activity-detector.test.ts

@@ -0,0 +1,232 @@
+import { describe, it, expect } from "vitest";
+import { detectOpenSpecActivity } from "@blackbelt-technology/pi-dashboard-shared/openspec-activity-detector.js";
+
+describe("detectOpenSpecActivity", () => {
+  describe("phase detection from skill file reads", () => {
+    it("detects apply phase from SKILL.md read", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: ".pi/skills/openspec-apply-change/SKILL.md",
+      });
+      expect(result).toEqual({ phase: "apply" });
+    });
+
+    it("detects explore phase", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: ".pi/skills/openspec-explore/SKILL.md",
+      });
+      expect(result).toEqual({ phase: "explore" });
+    });
+
+    it("detects new phase", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: ".pi/skills/openspec-new-change/SKILL.md",
+      });
+      expect(result).toEqual({ phase: "new" });
+    });
+
+    it("detects continue phase", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: ".pi/skills/openspec-continue-change/SKILL.md",
+      });
+      expect(result).toEqual({ phase: "continue" });
+    });
+
+    it("detects ff phase", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: ".pi/skills/openspec-ff-change/SKILL.md",
+      });
+      expect(result).toEqual({ phase: "ff" });
+    });
+
+    it("detects verify phase", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: ".pi/skills/openspec-verify-change/SKILL.md",
+      });
+      expect(result).toEqual({ phase: "verify" });
+    });
+
+    it("detects archive phase", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: ".pi/skills/openspec-archive-change/SKILL.md",
+      });
+      expect(result).toEqual({ phase: "archive" });
+    });
+
+    it("detects sync-specs phase", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: ".pi/skills/openspec-sync-specs/SKILL.md",
+      });
+      expect(result).toEqual({ phase: "sync-specs" });
+    });
+
+    it("detects onboard phase", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: ".pi/skills/openspec-onboard/SKILL.md",
+      });
+      expect(result).toEqual({ phase: "onboard" });
+    });
+
+    it("handles absolute paths", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: "/Users/dev/project/.pi/skills/openspec-apply-change/SKILL.md",
+      });
+      expect(result).toEqual({ phase: "apply" });
+    });
+
+    it("returns null for non-openspec skill reads", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: ".pi/skills/some-other-skill/SKILL.md",
+      });
+      expect(result).toBeNull();
+    });
+
+    it("returns null for non-SKILL.md reads in openspec dirs", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: ".pi/skills/openspec-apply-change/README.md",
+      });
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("change name detection from CLI calls", () => {
+    it("detects change name from openspec status command", () => {
+      const result = detectOpenSpecActivity("bash", {
+        command: 'openspec status --change "session-sync" --json',
+      });
+      expect(result).toEqual({ changeName: "session-sync" });
+    });
+
+    it("detects change name from openspec instructions command", () => {
+      const result = detectOpenSpecActivity("bash", {
+        command: 'openspec instructions apply --change "my-feature" --json',
+      });
+      expect(result).toEqual({ changeName: "my-feature" });
+    });
+
+    it("detects change name without quotes", () => {
+      const result = detectOpenSpecActivity("bash", {
+        command: "openspec status --change session-sync --json",
+      });
+      expect(result).toEqual({ changeName: "session-sync" });
+    });
+
+    it("detects change name from openspec archive command", () => {
+      const result = detectOpenSpecActivity("bash", {
+        command: "openspec archive session-sync",
+      });
+      expect(result).toEqual({ changeName: "session-sync" });
+    });
+
+    it("returns null for non-openspec bash commands", () => {
+      const result = detectOpenSpecActivity("bash", {
+        command: "npm test",
+      });
+      expect(result).toBeNull();
+    });
+
+    it("detects change name from openspec new change with quoted name", () => {
+      const result = detectOpenSpecActivity("bash", {
+        command: 'openspec new change "add-auth"',
+      });
+      expect(result).toEqual({ changeName: "add-auth" });
+    });
+
+    it("detects change name from openspec new change with unquoted name", () => {
+      const result = detectOpenSpecActivity("bash", {
+        command: "openspec new change add-auth",
+      });
+      expect(result).toEqual({ changeName: "add-auth" });
+    });
+
+    it("detects change name from openspec new change with cd prefix", () => {
+      const result = detectOpenSpecActivity("bash", {
+        command: 'cd /Users/dev/project && openspec new change "my-feature"',
+      });
+      expect(result).toEqual({ changeName: "my-feature" });
+    });
+
+    it("returns null for openspec list (no change name)", () => {
+      const result = detectOpenSpecActivity("bash", {
+        command: "openspec list --json",
+      });
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("change name detection from file reads", () => {
+    it("detects change name from openspec change file read", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: "openspec/changes/session-sync/tasks.md",
+      });
+      expect(result).toEqual({ changeName: "session-sync" });
+    });
+
+    it("detects change name from absolute path", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: "/Users/dev/project/openspec/changes/my-feature/proposal.md",
+      });
+      expect(result).toEqual({ changeName: "my-feature" });
+    });
+
+    it("returns null for non-openspec file reads", () => {
+      const result = detectOpenSpecActivity("read", {
+        path: "src/server/server.ts",
+      });
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("change name detection from file writes", () => {
+    it("detects change name from openspec change file write", () => {
+      const result = detectOpenSpecActivity("write", {
+        path: "openspec/changes/session-sync/proposal.md",
+      });
+      expect(result).toEqual({ changeName: "session-sync" });
+    });
+
+    it("detects change name from absolute path write", () => {
+      const result = detectOpenSpecActivity("write", {
+        path: "/Users/dev/project/openspec/changes/my-feature/spec.md",
+      });
+      expect(result).toEqual({ changeName: "my-feature" });
+    });
+
+    it("returns null for non-openspec file writes", () => {
+      const result = detectOpenSpecActivity("write", {
+        path: "src/server/server.ts",
+      });
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("edge cases", () => {
+    it("handles capitalized tool names (backward compatibility)", () => {
+      expect(detectOpenSpecActivity("Read", {
+        path: "openspec/changes/my-feature/proposal.md",
+      })).toEqual({ changeName: "my-feature" });
+
+      expect(detectOpenSpecActivity("Bash", {
+        command: 'openspec status --change "add-auth" --json',
+      })).toEqual({ changeName: "add-auth" });
+
+      expect(detectOpenSpecActivity("Write", {
+        path: "openspec/changes/my-feature/design.md",
+      })).toEqual({ changeName: "my-feature" });
+    });
+
+    it("returns null for unknown tool names", () => {
+      const result = detectOpenSpecActivity("unknown", { path: "foo.ts" });
+      expect(result).toBeNull();
+    });
+
+    it("returns null when args are missing", () => {
+      const result = detectOpenSpecActivity("read", undefined);
+      expect(result).toBeNull();
+    });
+
+    it("returns null when args are empty", () => {
+      const result = detectOpenSpecActivity("read", {});
+      expect(result).toBeNull();
+    });
+  });
+});

package/packages/extension/src/__tests__/openspec-poller.test.ts

@@ -0,0 +1,119 @@
+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 },
+}));
+
+// 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();
+  });
+}
+
+beforeEach(() => {
+  mockSpawnSync.mockReset();
+});
+
+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: [] });
+  });
+
+  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=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,
+      artifacts: [
+        { id: "proposal", status: "done" },
+        { id: "design", status: "ready" },
+        { id: "tasks", status: "blocked" },
+      ],
+    });
+    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: [] });
+  });
+
+  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");
+    expect(result.initialized).toBe(true);
+    expect(result.changes[0].artifacts).toEqual([]);
+  });
+});

package/packages/extension/src/__tests__/process-metrics.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { startMetricsMonitor, stopMetricsMonitor, collectMetrics } from "../process-metrics.js";
+
+describe("process-metrics", () => {
+  afterEach(() => {
+    stopMetricsMonitor();
+  });
+
+  it("collectMetrics returns valid shape without monitor", () => {
+    const m = collectMetrics();
+    expect(m.rss).toBeGreaterThan(0);
+    expect(m.heapUsed).toBeGreaterThan(0);
+    expect(m.heapTotal).toBeGreaterThan(0);
+    expect(typeof m.cpuPercent).toBe("number");
+    expect(typeof m.loadAvg1m).toBe("number");
+    // eventLoopMaxMs is undefined without monitor
+    expect(m.eventLoopMaxMs).toBeUndefined();
+  });
+
+  it("collectMetrics includes eventLoopMaxMs with monitor", async () => {
+    startMetricsMonitor();
+    // Let the event loop tick to capture some delay
+    await new Promise((r) => setTimeout(r, 50));
+    const m = collectMetrics();
+    expect(typeof m.eventLoopMaxMs).toBe("number");
+    expect(m.eventLoopMaxMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it("cpuPercent computes delta on second call", () => {
+    const first = collectMetrics();
+    // Do some CPU work
+    let x = 0;
+    for (let i = 0; i < 1_000_000; i++) x += Math.sqrt(i);
+    const second = collectMetrics();
+    // Both should be numbers, second should show some cpu
+    expect(typeof first.cpuPercent).toBe("number");
+    expect(typeof second.cpuPercent).toBe("number");
+    void x;
+  });
+
+  it("startMetricsMonitor is idempotent", () => {
+    startMetricsMonitor();
+    startMetricsMonitor(); // should not throw
+    const m = collectMetrics();
+    expect(m.rss).toBeGreaterThan(0);
+  });
+});