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

package/packages/server/src/__tests__/openspec-tasks-parser.test.ts

@@ -0,0 +1,178 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import {
+  parseTasksMarkdown,
+  readTasks,
+  toggleTask,
+  NotFoundError,
+  LineMismatchError,
+  NotACheckboxError,
+} from "../openspec-tasks.js";
+
+describe("parseTasksMarkdown", () => {
+  it("parses ticked + unticked mix and tracks groups", () => {
+    const md = [
+      "## 1. Setup",
+      "",
+      "- [ ] 1.1 Create module",
+      "- [x] 1.2 Add dep",
+      "",
+      "## 2. Tests",
+      "- [x] 2.1 Write vitest",
+      "- [ ] 2.2 Write e2e",
+    ].join("\n");
+    const tasks = parseTasksMarkdown(md);
+    expect(tasks).toEqual([
+      { id: "1.1", text: "Create module", done: false, line: 3, group: "1. Setup" },
+      { id: "1.2", text: "Add dep", done: true, line: 4, group: "1. Setup" },
+      { id: "2.1", text: "Write vitest", done: true, line: 7, group: "2. Tests" },
+      { id: "2.2", text: "Write e2e", done: false, line: 8, group: "2. Tests" },
+    ]);
+  });
+
+  it("ignores unparseable lines without failing", () => {
+    const md = [
+      "## Misc",
+      "- foo bar",
+      "- [ ] 1.1 Valid task",
+      "random text",
+      "  - [ ] 1.2 Indented, not top-level",
+      "- [x] 1.3 Another valid",
+    ].join("\n");
+    const tasks = parseTasksMarkdown(md);
+    expect(tasks.map((t) => t.id)).toEqual(["1.1", "1.3"]);
+    expect(tasks.map((t) => t.done)).toEqual([false, true]);
+  });
+
+  it("handles capital X as done", () => {
+    const tasks = parseTasksMarkdown("## G\n- [X] 1.1 Done-uppercase");
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].done).toBe(true);
+  });
+
+  it("handles CRLF line endings", () => {
+    const md = "## 1. G\r\n- [ ] 1.1 Test\r\n- [x] 1.2 Done\r\n";
+    const tasks = parseTasksMarkdown(md);
+    expect(tasks).toHaveLength(2);
+    expect(tasks[0].group).toBe("1. G");
+    expect(tasks[0].line).toBe(2);
+    expect(tasks[1].done).toBe(true);
+  });
+
+  it("returns empty list for no tasks", () => {
+    expect(parseTasksMarkdown("# Title\n\nJust prose.\n")).toEqual([]);
+  });
+
+  it("handles tasks without a preceding heading (empty group)", () => {
+    const tasks = parseTasksMarkdown("- [ ] 1.1 Loose task");
+    expect(tasks[0].group).toBe("");
+  });
+});
+
+describe("readTasks + toggleTask (writer)", () => {
+  let tmpDir: string;
+  let changeDir: string;
+  let tasksFile: string;
+  const CWD_CHANGE = ["my-cwd-placeholder", "demo-change"] as const;
+
+  const initialMd = [
+    "## 1. Setup",
+    "",
+    "- [ ] 1.1 First task",
+    "- [x] 1.2 Second task",
+    "",
+    "## 2. Docs",
+    "- [ ] 2.1 Third task",
+    "",
+  ].join("\n");
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "openspec-tasks-test-"));
+    changeDir = path.join(tmpDir, "openspec", "changes", CWD_CHANGE[1]);
+    fs.mkdirSync(changeDir, { recursive: true });
+    tasksFile = path.join(changeDir, "tasks.md");
+    fs.writeFileSync(tasksFile, initialMd, "utf-8");
+  });
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("readTasks returns parsed entries", async () => {
+    const tasks = await readTasks(tmpDir, CWD_CHANGE[1]);
+    expect(tasks.map((t) => t.id)).toEqual(["1.1", "1.2", "2.1"]);
+  });
+
+  it("readTasks throws NotFoundError when file is missing", async () => {
+    await expect(readTasks(tmpDir, "does-not-exist")).rejects.toBeInstanceOf(NotFoundError);
+  });
+
+  it("toggle ticks an unticked task and preserves other lines", async () => {
+    const result = await toggleTask(tmpDir, CWD_CHANGE[1], "1.1", true, 3);
+    expect(result.done).toBe(true);
+    expect(result.id).toBe("1.1");
+    expect(result.line).toBe(3);
+    expect(result.group).toBe("1. Setup");
+
+    const after = fs.readFileSync(tasksFile, "utf-8");
+    const expected = initialMd.replace("- [ ] 1.1 First task", "- [x] 1.1 First task");
+    expect(after).toBe(expected);
+  });
+
+  it("toggle unticks a ticked task", async () => {
+    const result = await toggleTask(tmpDir, CWD_CHANGE[1], "1.2", false, 4);
+    expect(result.done).toBe(false);
+    const after = fs.readFileSync(tasksFile, "utf-8");
+    expect(after).toBe(initialMd.replace("- [x] 1.2 Second task", "- [ ] 1.2 Second task"));
+  });
+
+  it("toggle raises LineMismatchError when line is already in the target state", async () => {
+    // Line 4 is already done=true; requesting done=true again → mismatch
+    await expect(toggleTask(tmpDir, CWD_CHANGE[1], "1.2", true, 4)).rejects.toBeInstanceOf(
+      LineMismatchError,
+    );
+    // File untouched
+    expect(fs.readFileSync(tasksFile, "utf-8")).toBe(initialMd);
+  });
+
+  it("toggle raises LineMismatchError when id does not match target line", async () => {
+    await expect(toggleTask(tmpDir, CWD_CHANGE[1], "9.9", true, 3)).rejects.toBeInstanceOf(
+      LineMismatchError,
+    );
+  });
+
+  it("toggle raises LineMismatchError for out-of-range line", async () => {
+    await expect(toggleTask(tmpDir, CWD_CHANGE[1], "1.1", true, 9999)).rejects.toBeInstanceOf(
+      LineMismatchError,
+    );
+  });
+
+  it("toggle raises NotACheckboxError when target line is a heading", async () => {
+    // Line 1 is "## 1. Setup"
+    await expect(toggleTask(tmpDir, CWD_CHANGE[1], "1.1", true, 1)).rejects.toBeInstanceOf(
+      NotACheckboxError,
+    );
+  });
+
+  it("toggle raises NotFoundError when file is absent", async () => {
+    await expect(toggleTask(tmpDir, "missing", "1.1", true, 3)).rejects.toBeInstanceOf(
+      NotFoundError,
+    );
+  });
+
+  it("toggle writes atomically (no .tmp left behind)", async () => {
+    await toggleTask(tmpDir, CWD_CHANGE[1], "1.1", true, 3);
+    const files = fs.readdirSync(changeDir);
+    expect(files.some((f) => f.endsWith(".tmp"))).toBe(false);
+  });
+
+  it("toggle preserves byte-for-byte all other lines", async () => {
+    const weirdMd =
+      "# Title line\n\n## 1. Group\n- [ ] 1.1 Task one\n> quote line\n\n    indented code\n- [x] 1.2 Task two\n";
+    fs.writeFileSync(tasksFile, weirdMd, "utf-8");
+    await toggleTask(tmpDir, CWD_CHANGE[1], "1.1", true, 4);
+    const after = fs.readFileSync(tasksFile, "utf-8");
+    expect(after).toBe(weirdMd.replace("- [ ] 1.1 Task one", "- [x] 1.1 Task one"));
+  });
+});

package/packages/server/src/__tests__/openspec-tasks-routes.test.ts

@@ -0,0 +1,180 @@
+/**
+ * HTTP-level tests for the openspec task list / toggle endpoints.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import Fastify, { type FastifyInstance } from "fastify";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { registerOpenSpecRoutes } from "../routes/openspec-routes.js";
+
+const PASSTHRU_GUARD = async () => {};
+
+// Simulates a non-loopback guard that 403s every request.
+const DENY_GUARD = async (_req: any, reply: any) => {
+  reply.code(403).send({ success: false, error: "forbidden" });
+};
+
+function makeDirectoryService(): any {
+  return {
+    refreshOpenSpec: vi.fn(async () => ({ initialized: true, changes: [] })),
+    getOpenSpecData: vi.fn(),
+  };
+}
+
+describe("openspec tasks REST routes", () => {
+  let tmpDir: string;
+  let changeName: string;
+  let tasksFile: string;
+  let fastify: FastifyInstance;
+
+  const initialMd = [
+    "## 1. Setup",
+    "",
+    "- [ ] 1.1 First task",
+    "- [x] 1.2 Second task",
+    "",
+    "## 2. Docs",
+    "- [ ] 2.1 Third task",
+    "",
+  ].join("\n");
+
+  beforeEach(async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "openspec-routes-test-"));
+    changeName = "demo-change";
+    const dir = path.join(tmpDir, "openspec", "changes", changeName);
+    fs.mkdirSync(dir, { recursive: true });
+    tasksFile = path.join(dir, "tasks.md");
+    fs.writeFileSync(tasksFile, initialMd, "utf-8");
+  });
+
+  afterEach(async () => {
+    if (fastify) await fastify.close();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  async function setup(opts: {
+    networkGuard?: any;
+    onOpenSpecChanged?: (cwd: string) => void;
+  } = {}) {
+    fastify = Fastify();
+    const directoryService = makeDirectoryService();
+    registerOpenSpecRoutes(fastify, {
+      sessionManager: { listAll: () => [] } as any,
+      preferencesStore: { getPinnedDirectories: () => [] } as any,
+      directoryService,
+      networkGuard: opts.networkGuard ?? PASSTHRU_GUARD,
+      onOpenSpecChanged: opts.onOpenSpecChanged,
+    });
+    await fastify.ready();
+    return { directoryService };
+  }
+
+  it("GET /api/openspec/tasks → 200 with parsed tasks + groups", async () => {
+    await setup();
+    const res = await fastify.inject({
+      method: "GET",
+      url: `/api/openspec/tasks?cwd=${encodeURIComponent(tmpDir)}&change=${changeName}`,
+    });
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.payload);
+    expect(body.success).toBe(true);
+    expect(body.data.tasks.map((t: any) => t.id)).toEqual(["1.1", "1.2", "2.1"]);
+    expect(body.data.groups).toEqual(["1. Setup", "2. Docs"]);
+  });
+
+  it("GET /api/openspec/tasks → 400 when required query missing", async () => {
+    await setup();
+    const res = await fastify.inject({ method: "GET", url: "/api/openspec/tasks" });
+    expect(res.statusCode).toBe(400);
+  });
+
+  it("GET /api/openspec/tasks → 404 when tasks.md missing", async () => {
+    await setup();
+    const res = await fastify.inject({
+      method: "GET",
+      url: `/api/openspec/tasks?cwd=${encodeURIComponent(tmpDir)}&change=does-not-exist`,
+    });
+    expect(res.statusCode).toBe(404);
+  });
+
+  it("GET /api/openspec/tasks → 403 when network guard denies", async () => {
+    await setup({ networkGuard: DENY_GUARD });
+    const res = await fastify.inject({
+      method: "GET",
+      url: `/api/openspec/tasks?cwd=${encodeURIComponent(tmpDir)}&change=${changeName}`,
+    });
+    expect(res.statusCode).toBe(403);
+  });
+
+  it("POST toggle → 200 ticks task, rewrites file, and triggers broadcast", async () => {
+    const onOpenSpecChanged = vi.fn();
+    const { directoryService } = await setup({ onOpenSpecChanged });
+    const res = await fastify.inject({
+      method: "POST",
+      url: "/api/openspec/tasks/toggle",
+      payload: { cwd: tmpDir, change: changeName, id: "1.1", done: true, line: 3 },
+    });
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.payload);
+    expect(body.data.task.done).toBe(true);
+    const after = fs.readFileSync(tasksFile, "utf-8");
+    expect(after).toContain("- [x] 1.1 First task");
+    // Allow the fire-and-forget refresh promise to resolve
+    await new Promise((r) => setTimeout(r, 10));
+    expect(directoryService.refreshOpenSpec).toHaveBeenCalledWith(tmpDir);
+    expect(onOpenSpecChanged).toHaveBeenCalledWith(tmpDir);
+  });
+
+  it("POST toggle → 409 on line mismatch (line already in target state)", async () => {
+    await setup();
+    const res = await fastify.inject({
+      method: "POST",
+      url: "/api/openspec/tasks/toggle",
+      payload: { cwd: tmpDir, change: changeName, id: "1.2", done: true, line: 4 },
+    });
+    expect(res.statusCode).toBe(409);
+    // File untouched
+    expect(fs.readFileSync(tasksFile, "utf-8")).toBe(initialMd);
+  });
+
+  it("POST toggle → 400 when target line is not a checkbox", async () => {
+    await setup();
+    const res = await fastify.inject({
+      method: "POST",
+      url: "/api/openspec/tasks/toggle",
+      payload: { cwd: tmpDir, change: changeName, id: "1.1", done: true, line: 1 },
+    });
+    expect(res.statusCode).toBe(400);
+  });
+
+  it("POST toggle → 400 on malformed body", async () => {
+    await setup();
+    const res = await fastify.inject({
+      method: "POST",
+      url: "/api/openspec/tasks/toggle",
+      payload: { cwd: tmpDir },
+    });
+    expect(res.statusCode).toBe(400);
+  });
+
+  it("POST toggle → 404 when tasks.md missing", async () => {
+    await setup();
+    const res = await fastify.inject({
+      method: "POST",
+      url: "/api/openspec/tasks/toggle",
+      payload: { cwd: tmpDir, change: "missing", id: "1.1", done: true, line: 3 },
+    });
+    expect(res.statusCode).toBe(404);
+  });
+
+  it("POST toggle → 403 when network guard denies", async () => {
+    await setup({ networkGuard: DENY_GUARD });
+    const res = await fastify.inject({
+      method: "POST",
+      url: "/api/openspec/tasks/toggle",
+      payload: { cwd: tmpDir, change: changeName, id: "1.1", done: true, line: 3 },
+    });
+    expect(res.statusCode).toBe(403);
+  });
+});

package/packages/server/src/__tests__/package-manager-wrapper-resolve.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Tests for loadPiPackageManager() resolution chain in package-manager-wrapper.ts.
+ *
+ * Separate from package-manager-wrapper.test.ts because that file mocks
+ * "@mariozechner/pi-coding-agent" so direct-import succeeds and the
+ * fallback paths never execute.
+ *
+ * These tests exercise the managed-install and global-npm fallbacks.
+ */
+import { describe, it, expect, vi, afterEach } from "vitest";
+import * as os from "node:os";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// Force the direct import to fail so resolution falls through to the
+// managed-install / global-npm paths. vi.mock is hoisted; the factory
+// throws at import time which mimics pi not being an installed dependency.
+vi.mock("@mariozechner/pi-coding-agent", () => {
+  throw new Error("not installed as direct dependency");
+});
+vi.mock("@oh-my-pi/pi-coding-agent", () => {
+  throw new Error("not installed as direct dependency");
+});
+
+/** Override os.homedir() by setting the env vars libuv reads. */
+function withHome(tmpHome: string): () => void {
+  const prev = {
+    HOME: process.env.HOME,
+    USERPROFILE: process.env.USERPROFILE,
+  };
+  process.env.HOME = tmpHome;
+  process.env.USERPROFILE = tmpHome;
+  return () => {
+    if (prev.HOME === undefined) delete process.env.HOME; else process.env.HOME = prev.HOME;
+    if (prev.USERPROFILE === undefined) delete process.env.USERPROFILE; else process.env.USERPROFILE = prev.USERPROFILE;
+  };
+}
+
+describe("loadPiPackageManager resolution chain", () => {
+  const cleanupPaths: string[] = [];
+  const restoreFns: Array<() => void> = [];
+
+  afterEach(() => {
+    for (const r of restoreFns) r();
+    restoreFns.length = 0;
+    vi.restoreAllMocks();
+    vi.resetModules();
+    for (const p of cleanupPaths) {
+      try { fs.rmSync(p, { recursive: true, force: true }); } catch { /* ignore */ }
+    }
+    cleanupPaths.length = 0;
+  });
+
+  it("resolves pi from managed install at ~/.pi-dashboard/node_modules/ when direct import fails", async () => {
+    const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-dash-home-managed-"));
+    cleanupPaths.push(tmpHome);
+
+    // Create a fake managed pi install with a real ESM entry file
+    const fakeDistDir = path.join(
+      tmpHome,
+      ".pi-dashboard",
+      "node_modules",
+      "@mariozechner",
+      "pi-coding-agent",
+      "dist",
+    );
+    fs.mkdirSync(fakeDistDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(fakeDistDir, "index.js"),
+      [
+        "export function DefaultPackageManager() {",
+        "  return {",
+        "    listConfiguredPackages: () => [{ source: 'npm:from-managed', scope: 'user', filtered: false }],",
+        "  };",
+        "}",
+        "export const SettingsManager = { create: () => ({}) };",
+      ].join("\n"),
+    );
+
+    restoreFns.push(withHome(tmpHome));
+    expect(os.homedir()).toBe(tmpHome);
+    vi.resetModules();
+
+    const { PackageManagerWrapper } = await import("../package-manager-wrapper.js");
+    const wrapper = new PackageManagerWrapper();
+    const result = await wrapper.listInstalled("global");
+
+    expect(result).toEqual([
+      { source: "npm:from-managed", scope: "user", filtered: false },
+    ]);
+  });
+
+  it.skip("falls through to global npm without crashing when managed install is absent", async () => {
+    // SKIPPED: post ToolRegistry refactor, bareImportStrategy resolves pi-coding-agent
+    // from the dev node_modules regardless of HOME override. Needs a more invasive
+    // test-registry injection to genuinely simulate 'all paths empty'. Tracked as
+    // part of the Phase 4 platform/ consolidation work.
+    // tmp home with NO ~/.pi-dashboard directory -> managed resolution must
+    // silently fail and continue to the global-npm path.
+    const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-dash-home-empty-"));
+    cleanupPaths.push(tmpHome);
+
+    restoreFns.push(withHome(tmpHome));
+    expect(os.homedir()).toBe(tmpHome);
+
+    // Stub execSync so `npm root -g` returns a directory where pi is also
+    // absent. With direct-import + managed + global all missing, the
+    // function must surface the final "pi-coding-agent is not installed"
+    // error — proving the managed block didn't throw early.
+    vi.doMock("node:child_process", async (importOriginal) => {
+      const actual = await importOriginal<typeof import("node:child_process")>();
+      return {
+        ...actual,
+        execSync: vi.fn(() => tmpHome), // no pi inside tmpHome
+      };
+    });
+
+    vi.resetModules();
+    const { PackageManagerWrapper } = await import("../package-manager-wrapper.js");
+    const wrapper = new PackageManagerWrapper();
+
+    await expect(wrapper.listInstalled("global")).rejects.toThrow(
+      /pi-coding-agent is not installed/,
+    );
+  });
+});

package/packages/server/src/__tests__/package-manager-wrapper.test.ts

@@ -1,5 +1,10 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { PackageManagerWrapper, PackageOperationBusyError } from "../package-manager-wrapper.js";
+import { ToolRegistry, OverridesStore } from "@blackbelt-technology/pi-dashboard-shared/tool-registry/index.js";
+import { registerDefaultTools } from "@blackbelt-technology/pi-dashboard-shared/tool-registry/definitions.js";
+import os from "node:os";
+import path from "node:path";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
 
 // Track mock functions
 const installAndPersist = vi.fn().mockResolvedValue(undefined);
@@ -14,8 +19,9 @@ const checkForAvailableUpdates = vi.fn().mockResolvedValue([
 ]);
 const setProgressCallback = vi.fn();
 
-vi.mock("@mariozechner/pi-coding-agent", () => {
-  const MockPM = function() {
+// The PiModule returned by registry.resolveModule (bypasses vi.mock).
+const fakePiModule = {
+  DefaultPackageManager: function() {
     return {
       installAndPersist,
       removeAndPersist,
@@ -24,13 +30,42 @@ vi.mock("@mariozechner/pi-coding-agent", () => {
       checkForAvailableUpdates,
       setProgressCallback,
     };
-  };
-  return {
-    DefaultPackageManager: MockPM,
-    SettingsManager: { create: () => ({}) },
-    default: undefined,
-  };
-});
+  },
+  SettingsManager: { create: () => ({}) },
+};
+
+/**
+ * Build a ToolRegistry whose pi-coding-agent resolution is a no-op lookup
+ * (any path) and whose importModule() returns the in-memory fake module.
+ * This sidesteps the whole resolution chain so tests run without a
+ * pi-coding-agent install.
+ */
+function makeTestRegistry(): ToolRegistry {
+  // Per-test ephemeral overrides file so each test gets a fresh registry.
+  const tmpDir = mkdtempSync(path.join(os.tmpdir(), "pmw-test-"));
+  const overrides = new OverridesStore({
+    filePath: path.join(tmpDir, "tool-overrides.json"),
+  });
+  // overrideStrategy checks file existence — create a real stub under tmpDir
+  // rather than a phantom /stub path so CI (no pi-coding-agent installed)
+  // doesn't fall through every strategy and throw ModuleResolutionError.
+  const stubDir = path.join(tmpDir, "pi-coding-agent", "dist");
+  mkdirSync(stubDir, { recursive: true });
+  const stubPath = path.join(stubDir, "index.js");
+  writeFileSync(stubPath, "// test stub\n");
+  overrides.set("pi-coding-agent", stubPath);
+
+  // Inject importModule that always returns the fake pi module, bypassing
+  // any real dynamic import. The override above ensures the strategy chain's
+  // first step (overrideStrategy) returns the synthetic path, which
+  // importModule then maps to our fakePiModule.
+  const registry = new ToolRegistry({
+    overrides,
+    importModule: async () => fakePiModule,
+  });
+  registerDefaultTools(registry);
+  return registry;
+}
 
 describe("PackageManagerWrapper", () => {
   let wrapper: PackageManagerWrapper;
@@ -47,7 +82,7 @@ describe("PackageManagerWrapper", () => {
       { source: "npm:pi-doom", displayName: "pi-doom", type: "npm" },
     ]);
     setProgressCallback.mockReset();
-    wrapper = new PackageManagerWrapper();
+    wrapper = new PackageManagerWrapper(makeTestRegistry());
   });
 
   it("returns operationId on run", async () => {