claude-code-swarm 0.3.3 → 0.3.5

package/src/__tests__/paths.test.mjs

@@ -1,70 +1,214 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import path from "path";
-import {
-  SWARM_DIR, SOCKET_PATH, INBOX_PATH, PID_PATH, ROLES_PATH,
-  CONFIG_PATH, TMP_DIR, TEAMS_DIR, MAP_DIR,
-  teamDir, pluginDir,
-} from "../paths.mjs";
+import os from "os";
+
+// We need to test path resolution with different CWD states.
+// Since paths.mjs computes values at module load time, we test the
+// exported values AND mock fs.existsSync to test resolution logic.
+
+describe("paths (current environment)", () => {
+  // These tests verify the exports work correctly in the test environment.
+  // The actual resolution depends on whether .swarm/claude-swarm/ exists in CWD.
+
+  let paths;
+
+  beforeEach(async () => {
+    // Fresh import each time (vitest module cache may apply)
+    paths = await import("../paths.mjs");
+  });
 
-describe("paths", () => {
   it("exports all expected path constants", () => {
-    expect(typeof SWARM_DIR).toBe("string");
-    expect(typeof CONFIG_PATH).toBe("string");
-    expect(typeof TMP_DIR).toBe("string");
-    expect(typeof TEAMS_DIR).toBe("string");
-    expect(typeof MAP_DIR).toBe("string");
-    expect(typeof SOCKET_PATH).toBe("string");
-    expect(typeof INBOX_PATH).toBe("string");
-    expect(typeof PID_PATH).toBe("string");
-    expect(typeof ROLES_PATH).toBe("string");
+    expect(typeof paths.SWARM_DIR).toBe("string");
+    expect(typeof paths.CONFIG_PATH).toBe("string");
+    expect(typeof paths.TMP_DIR).toBe("string");
+    expect(typeof paths.TEAMS_DIR).toBe("string");
+    expect(typeof paths.MAP_DIR).toBe("string");
+    expect(typeof paths.SOCKET_PATH).toBe("string");
+    expect(typeof paths.PID_PATH).toBe("string");
+    expect(typeof paths.ROLES_PATH).toBe("string");
+    expect(typeof paths.IS_GLOBAL_PATHS).toBe("boolean");
   });
 
-  it("all paths are under .swarm/claude-swarm/", () => {
-    expect(CONFIG_PATH).toMatch(/^\.swarm\/claude-swarm\//);
-    expect(TMP_DIR).toMatch(/^\.swarm\/claude-swarm\//);
-    expect(TEAMS_DIR).toMatch(/^\.swarm\/claude-swarm\//);
-    expect(MAP_DIR).toMatch(/^\.swarm\/claude-swarm\//);
-    expect(SOCKET_PATH).toMatch(/^\.swarm\/claude-swarm\//);
-    expect(INBOX_PATH).toMatch(/^\.swarm\/claude-swarm\//);
-    expect(PID_PATH).toMatch(/^\.swarm\/claude-swarm\//);
-    expect(ROLES_PATH).toMatch(/^\.swarm\/claude-swarm\//);
+  it("CONFIG_PATH is always project-relative", () => {
+    expect(paths.CONFIG_PATH).toBe(".swarm/claude-swarm/config.json");
   });
 
-  it("CONFIG_PATH is .swarm/claude-swarm/config.json", () => {
-    expect(CONFIG_PATH).toBe(".swarm/claude-swarm/config.json");
+  it("SWARM_DIR is always project-relative", () => {
+    expect(paths.SWARM_DIR).toBe(".swarm/claude-swarm");
   });
 
-  it("TMP_DIR is .swarm/claude-swarm/tmp", () => {
-    expect(TMP_DIR).toBe(".swarm/claude-swarm/tmp");
+  it("GLOBAL_CONFIG_DIR is under ~/.claude-swarm/", () => {
+    expect(paths.GLOBAL_CONFIG_DIR).toBe(path.join(os.homedir(), ".claude-swarm"));
   });
 
-  it("TEAMS_DIR is under tmp/", () => {
-    expect(TEAMS_DIR).toBe(".swarm/claude-swarm/tmp/teams");
+  it("GLOBAL_CONFIG_PATH is config.json under GLOBAL_CONFIG_DIR", () => {
+    expect(paths.GLOBAL_CONFIG_PATH).toBe(path.join(os.homedir(), ".claude-swarm", "config.json"));
   });
 
-  it("MAP_DIR is under tmp/", () => {
-    expect(MAP_DIR).toBe(".swarm/claude-swarm/tmp/map");
+  it("TEAMS_DIR is under TMP_DIR", () => {
+    expect(paths.TEAMS_DIR).toBe(path.join(paths.TMP_DIR, "teams"));
   });
 
-  it("MAP runtime files are under tmp/map/", () => {
-    expect(SOCKET_PATH).toContain(".swarm/claude-swarm/tmp/map/");
-    expect(INBOX_PATH).toContain(".swarm/claude-swarm/tmp/map/");
-    expect(PID_PATH).toContain(".swarm/claude-swarm/tmp/map/");
-    expect(ROLES_PATH).toContain(".swarm/claude-swarm/tmp/map/");
+  it("MAP runtime files are under MAP_DIR", () => {
+    expect(paths.SOCKET_PATH).toBe(path.join(paths.MAP_DIR, "sidecar.sock"));
+    expect(paths.PID_PATH).toBe(path.join(paths.MAP_DIR, "sidecar.pid"));
+    expect(paths.ROLES_PATH).toBe(path.join(paths.MAP_DIR, "roles.json"));
+    expect(paths.SESSIONLOG_STATE_PATH).toBe(path.join(paths.MAP_DIR, "sessionlog-state.json"));
+    expect(paths.SIDECAR_LOG_PATH).toBe(path.join(paths.MAP_DIR, "sidecar.log"));
   });
 
   describe("teamDir", () => {
     it("returns per-template path under TEAMS_DIR", () => {
-      expect(teamDir("gsd")).toBe(".swarm/claude-swarm/tmp/teams/gsd");
-      expect(teamDir("bmad-method")).toBe(".swarm/claude-swarm/tmp/teams/bmad-method");
+      expect(paths.teamDir("gsd")).toBe(path.join(paths.TEAMS_DIR, "gsd"));
+      expect(paths.teamDir("bmad-method")).toBe(path.join(paths.TEAMS_DIR, "bmad-method"));
     });
   });
 
   describe("pluginDir", () => {
     it("resolves to the repository root (parent of src/)", () => {
-      const dir = pluginDir();
+      const dir = paths.pluginDir();
       expect(dir).toContain("claude-code-swarm");
       expect(dir).not.toContain("src");
     });
   });
 });
+
+describe("path resolution logic", () => {
+  // These tests verify the resolution rules by checking the relationship
+  // between IS_GLOBAL_PATHS and the computed paths.
+
+  let paths;
+
+  beforeEach(async () => {
+    paths = await import("../paths.mjs");
+  });
+
+  const globalBase = path.join(os.homedir(), ".claude", "claude-swarm");
+
+  it("when global: TMP_DIR is under ~/.claude/claude-swarm/tmp/", () => {
+    if (!paths.IS_GLOBAL_PATHS) return; // skip if project-level
+    expect(paths.TMP_DIR).toBe(path.join(globalBase, "tmp"));
+  });
+
+  it("when global: MAP_DIR includes CWD hash for isolation", () => {
+    if (!paths.IS_GLOBAL_PATHS) return;
+    // MAP_DIR should be: ~/.claude/claude-swarm/tmp/map/<12-char-hash>
+    const mapRelative = path.relative(path.join(globalBase, "tmp", "map"), paths.MAP_DIR);
+    expect(mapRelative).toMatch(/^[a-f0-9]{12}$/);
+  });
+
+  it("when global: TEAMS_DIR is shared (no CWD hash)", () => {
+    if (!paths.IS_GLOBAL_PATHS) return;
+    expect(paths.TEAMS_DIR).toBe(path.join(globalBase, "tmp", "teams"));
+  });
+
+  it("when project-level: TMP_DIR is under .swarm/claude-swarm/tmp", () => {
+    if (paths.IS_GLOBAL_PATHS) return; // skip if global
+    expect(paths.TMP_DIR).toBe(".swarm/claude-swarm/tmp");
+  });
+
+  it("when project-level: MAP_DIR has no CWD hash", () => {
+    if (paths.IS_GLOBAL_PATHS) return;
+    expect(paths.MAP_DIR).toBe(".swarm/claude-swarm/tmp/map");
+  });
+
+  it("when project-level: TEAMS_DIR is under project tmp", () => {
+    if (paths.IS_GLOBAL_PATHS) return;
+    expect(paths.TEAMS_DIR).toBe(".swarm/claude-swarm/tmp/teams");
+  });
+});
+
+describe("sessionPaths", () => {
+  let paths;
+
+  beforeEach(async () => {
+    paths = await import("../paths.mjs");
+  });
+
+  it("returns legacy paths when sessionId is null", () => {
+    const sp = paths.sessionPaths(null);
+    expect(sp.socketPath).toBe(paths.SOCKET_PATH);
+    expect(sp.pidPath).toBe(paths.PID_PATH);
+    expect(sp.sidecarLogPath).toBe(paths.SIDECAR_LOG_PATH);
+    expect(sp.sessionDir).toBeNull();
+  });
+
+  it("returns legacy paths when sessionId is undefined", () => {
+    const sp = paths.sessionPaths(undefined);
+    expect(sp.socketPath).toBe(paths.SOCKET_PATH);
+    expect(sp.sessionDir).toBeNull();
+  });
+
+  it("returns legacy paths when sessionId is empty string", () => {
+    const sp = paths.sessionPaths("");
+    expect(sp.socketPath).toBe(paths.SOCKET_PATH);
+    expect(sp.sessionDir).toBeNull();
+  });
+
+  it("returns session-scoped paths when sessionId is provided", () => {
+    const sp = paths.sessionPaths("abc123");
+    expect(sp.sessionDir).toBe(path.join(paths.MAP_DIR, "sessions", "abc123"));
+    expect(sp.socketPath).toBe(path.join(paths.MAP_DIR, "sessions", "abc123", "sidecar.sock"));
+    expect(sp.pidPath).toBe(path.join(paths.MAP_DIR, "sessions", "abc123", "sidecar.pid"));
+    expect(sp.sidecarLogPath).toBe(path.join(paths.MAP_DIR, "sessions", "abc123", "sidecar.log"));
+  });
+
+  it("hashes long session IDs (>12 chars) to 12 hex chars", () => {
+    const longId = "this-is-a-very-long-session-id-that-exceeds-12-chars";
+    const sp = paths.sessionPaths(longId);
+    const sessionDirName = path.basename(sp.sessionDir);
+    expect(sessionDirName).toMatch(/^[a-f0-9]{12}$/);
+    expect(sessionDirName.length).toBe(12);
+  });
+
+  it("uses short session IDs directly (<=12 chars)", () => {
+    const sp = paths.sessionPaths("short-id");
+    const sessionDirName = path.basename(sp.sessionDir);
+    expect(sessionDirName).toBe("short-id");
+  });
+
+  it("produces consistent hashes for the same long ID", () => {
+    const longId = "a-very-long-session-identifier-here";
+    const sp1 = paths.sessionPaths(longId);
+    const sp2 = paths.sessionPaths(longId);
+    expect(sp1.sessionDir).toBe(sp2.sessionDir);
+  });
+});
+
+describe("ensureSessionDir", () => {
+  let paths;
+  let fs;
+  let tmpDir;
+
+  beforeEach(async () => {
+    paths = await import("../paths.mjs");
+    fs = await import("fs");
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "session-dir-test-"));
+  });
+
+  afterEach(async () => {
+    const fs = await import("fs");
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it("is exported as a function", () => {
+    expect(typeof paths.ensureSessionDir).toBe("function");
+  });
+});
+
+describe("listSessionDirs", () => {
+  let paths;
+
+  beforeEach(async () => {
+    paths = await import("../paths.mjs");
+  });
+
+  it("returns empty array when no sessions directory exists", () => {
+    const result = paths.listSessionDirs();
+    expect(Array.isArray(result)).toBe(true);
+  });
+
+  it("is exported as a function", () => {
+    expect(typeof paths.listSessionDirs).toBe("function");
+  });
+});

package/src/__tests__/sidecar-client.test.mjs

@@ -65,9 +65,44 @@ describe("sidecar-client", () => {
     });
   });
 
+  describe("isSidecarAlive with custom pidPath", () => {
+    let tmpDir;
+
+    beforeEach(() => {
+      tmpDir = makeTmpDir();
+    });
+    afterEach(() => {
+      cleanupTmpDir(tmpDir);
+    });
+
+    it("returns true when PID file contains current process PID", () => {
+      const pidPath = path.join(tmpDir, "test.pid");
+      fs.writeFileSync(pidPath, String(process.pid));
+      expect(isSidecarAlive(pidPath)).toBe(true);
+    });
+
+    it("returns false when PID file contains non-existent PID", () => {
+      const pidPath = path.join(tmpDir, "test.pid");
+      fs.writeFileSync(pidPath, "999999999");
+      expect(isSidecarAlive(pidPath)).toBe(false);
+    });
+
+    it("returns false when custom pidPath does not exist", () => {
+      expect(isSidecarAlive(path.join(tmpDir, "nope.pid"))).toBe(false);
+    });
+  });
+
   describe("killSidecar", () => {
     it("does not throw when PID file is missing", () => {
       expect(() => killSidecar()).not.toThrow();
     });
+
+    it("does not throw when sessionId is null (legacy paths)", () => {
+      expect(() => killSidecar(null)).not.toThrow();
+    });
+
+    it("does not throw when sessionId is provided but no PID file exists", () => {
+      expect(() => killSidecar("nonexistent-session")).not.toThrow();
+    });
   });
 });

package/src/__tests__/sidecar-server.test.mjs

@@ -247,6 +247,130 @@ describe("sidecar-server", () => {
       });
     });
 
+    // ── Task event bridge (opentasks → MAP) ─────────────────────────────
+
+    describe("bridge-task-created", () => {
+      it("sends task.created event via conn.send with broadcast", async () => {
+        await handler({
+          action: "bridge-task-created",
+          task: { id: "task-1", title: "Fix bug", status: "open", assignee: "worker-1" },
+          agentId: "worker-1",
+        }, mockClient);
+        expect(mockConnection.send).toHaveBeenCalledWith(
+          { scope: "swarm:test" },
+          { type: "task.created", task: { id: "task-1", title: "Fix bug", status: "open", assignee: "worker-1" }, _origin: "worker-1" },
+          { relationship: "broadcast" }
+        );
+      });
+
+      it("responds {ok: true} even without connection", async () => {
+        const nullHandler = createCommandHandler(null, "swarm:test", registeredAgents);
+        await nullHandler({
+          action: "bridge-task-created",
+          task: { id: "t-1" },
+        }, mockClient);
+        const written = JSON.parse(mockClient.write.mock.calls[0][0]);
+        expect(written.ok).toBe(true);
+      });
+
+      it("defaults _origin to 'opentasks' when agentId missing", async () => {
+        await handler({
+          action: "bridge-task-created",
+          task: { id: "t-1" },
+        }, mockClient);
+        const [, payload] = mockConnection.send.mock.calls[0];
+        expect(payload._origin).toBe("opentasks");
+      });
+    });
+
+    describe("bridge-task-status", () => {
+      it("sends task.status event via conn.send", async () => {
+        await handler({
+          action: "bridge-task-status",
+          taskId: "task-1",
+          previous: "open",
+          current: "in_progress",
+          agentId: "worker-1",
+        }, mockClient);
+        expect(mockConnection.send).toHaveBeenCalledWith(
+          { scope: "swarm:test" },
+          { type: "task.status", taskId: "task-1", previous: "open", current: "in_progress", _origin: "worker-1" },
+          { relationship: "broadcast" }
+        );
+      });
+
+      it("also sends task.completed for terminal state 'completed'", async () => {
+        await handler({
+          action: "bridge-task-status",
+          taskId: "task-1",
+          previous: "open",
+          current: "completed",
+          agentId: "worker-1",
+        }, mockClient);
+        expect(mockConnection.send).toHaveBeenCalledTimes(2);
+        const [, secondPayload] = mockConnection.send.mock.calls[1];
+        expect(secondPayload.type).toBe("task.completed");
+        expect(secondPayload.taskId).toBe("task-1");
+      });
+
+      it("also sends task.completed for terminal state 'closed'", async () => {
+        await handler({
+          action: "bridge-task-status",
+          taskId: "task-1",
+          current: "closed",
+        }, mockClient);
+        expect(mockConnection.send).toHaveBeenCalledTimes(2);
+        const [, secondPayload] = mockConnection.send.mock.calls[1];
+        expect(secondPayload.type).toBe("task.completed");
+      });
+
+      it("does not send task.completed for non-terminal states", async () => {
+        await handler({
+          action: "bridge-task-status",
+          taskId: "task-1",
+          current: "in_progress",
+        }, mockClient);
+        expect(mockConnection.send).toHaveBeenCalledTimes(1);
+      });
+
+      it("responds {ok: true}", async () => {
+        await handler({
+          action: "bridge-task-status",
+          taskId: "task-1",
+          current: "completed",
+        }, mockClient);
+        const written = JSON.parse(mockClient.write.mock.calls[0][0]);
+        expect(written.ok).toBe(true);
+      });
+    });
+
+    describe("bridge-task-assigned", () => {
+      it("sends task.assigned event via conn.send", async () => {
+        await handler({
+          action: "bridge-task-assigned",
+          taskId: "task-1",
+          assignee: "gsd-executor",
+          agentId: "gsd-executor",
+        }, mockClient);
+        expect(mockConnection.send).toHaveBeenCalledWith(
+          { scope: "swarm:test" },
+          { type: "task.assigned", taskId: "task-1", agentId: "gsd-executor", _origin: "gsd-executor" },
+          { relationship: "broadcast" }
+        );
+      });
+
+      it("responds {ok: true} without connection", async () => {
+        const nullHandler = createCommandHandler(null, "swarm:test", registeredAgents);
+        await nullHandler({
+          action: "bridge-task-assigned",
+          taskId: "t-1",
+          assignee: "worker",
+        }, mockClient);
+        const written = JSON.parse(mockClient.write.mock.calls[0][0]);
+        expect(written.ok).toBe(true);
+      });
+    });
+
     // ── State ─────────────────────────────────────────────────────────────
 
     describe("state", () => {

package/src/__tests__/skilltree-client.test.mjs

@@ -0,0 +1,80 @@
+import { describe, it, expect } from "vitest";
+import { parseSkillTreeExtension } from "../skilltree-client.mjs";
+
+describe("skilltree-client", () => {
+  describe("parseSkillTreeExtension", () => {
+    it("returns empty defaults and roles for manifest without skilltree", () => {
+      const result = parseSkillTreeExtension({ name: "test", roles: ["a"] });
+      expect(result).toEqual({ defaults: {}, roles: {} });
+    });
+
+    it("returns empty defaults and roles for null manifest", () => {
+      const result = parseSkillTreeExtension(null);
+      expect(result).toEqual({ defaults: {}, roles: {} });
+    });
+
+    it("returns empty defaults and roles for undefined manifest", () => {
+      const result = parseSkillTreeExtension(undefined);
+      expect(result).toEqual({ defaults: {}, roles: {} });
+    });
+
+    it("extracts defaults from skilltree extension", () => {
+      const manifest = {
+        name: "test",
+        roles: ["a", "b"],
+        skilltree: {
+          defaults: { profile: "implementation", maxSkills: 6 },
+        },
+      };
+      const result = parseSkillTreeExtension(manifest);
+      expect(result.defaults).toEqual({ profile: "implementation", maxSkills: 6 });
+      expect(result.roles).toEqual({});
+    });
+
+    it("extracts per-role overrides from skilltree extension", () => {
+      const manifest = {
+        name: "test",
+        roles: ["orchestrator", "executor", "verifier"],
+        skilltree: {
+          defaults: { profile: "implementation" },
+          roles: {
+            orchestrator: { profile: "code-review" },
+            executor: { profile: "implementation", tags: ["development"] },
+            verifier: { profile: "testing" },
+          },
+        },
+      };
+      const result = parseSkillTreeExtension(manifest);
+      expect(result.defaults).toEqual({ profile: "implementation" });
+      expect(result.roles.orchestrator).toEqual({ profile: "code-review" });
+      expect(result.roles.executor).toEqual({ profile: "implementation", tags: ["development"] });
+      expect(result.roles.verifier).toEqual({ profile: "testing" });
+    });
+
+    it("handles skilltree extension with only roles, no defaults", () => {
+      const manifest = {
+        name: "test",
+        roles: ["a"],
+        skilltree: {
+          roles: { a: { profile: "debugging" } },
+        },
+      };
+      const result = parseSkillTreeExtension(manifest);
+      expect(result.defaults).toEqual({});
+      expect(result.roles.a).toEqual({ profile: "debugging" });
+    });
+
+    it("handles skilltree extension with only defaults, no roles", () => {
+      const manifest = {
+        name: "test",
+        roles: ["a"],
+        skilltree: {
+          defaults: { tags: ["typescript"] },
+        },
+      };
+      const result = parseSkillTreeExtension(manifest);
+      expect(result.defaults).toEqual({ tags: ["typescript"] });
+      expect(result.roles).toEqual({});
+    });
+  });
+});