claude-code-swarm 0.3.26 → 0.4.0

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

@@ -0,0 +1,217 @@
+/**
+ * cascade-client.test.mjs — git-cascade tracker ownership (Phase 1)
+ *
+ * Exercises openCascadeTracker / ensureStream / closeCascadeTracker against a
+ * real temp git repo with a couple of branches. git-cascade is resolved at
+ * runtime via swarmkit-resolver, so these tests require git-cascade to be
+ * importable from the workspace.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import {
+  openCascadeTracker,
+  ensureStream,
+  closeCascadeTracker,
+  findStreamByBranch,
+  recordObservedCommit,
+  recordObservedMerge,
+} from "../cascade-client.mjs";
+import { makeTmpDir, cleanupTmpDir } from "./helpers.mjs";
+
+/**
+ * Create a real git repo with an initial commit and a couple of branches.
+ * Leaves `main` (or the default branch) checked out.
+ */
+function makeGitRepo(dir) {
+  execSync("git init", { cwd: dir, stdio: "pipe" });
+  execSync('git config user.email "test@test.com"', { cwd: dir, stdio: "pipe" });
+  execSync('git config user.name "Test"', { cwd: dir, stdio: "pipe" });
+  execSync("git config commit.gpgsign false", { cwd: dir, stdio: "pipe" });
+  fs.writeFileSync(path.join(dir, "README.md"), "# test\n");
+  execSync("git add .", { cwd: dir, stdio: "pipe" });
+  execSync('git commit -m "initial"', { cwd: dir, stdio: "pipe" });
+  // Create a couple of extra branches.
+  execSync("git branch feature-a", { cwd: dir, stdio: "pipe" });
+  execSync("git branch feature-b", { cwd: dir, stdio: "pipe" });
+}
+
+/** Current branch name of a repo. */
+function currentBranch(dir) {
+  return execSync("git rev-parse --abbrev-ref HEAD", {
+    cwd: dir, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"],
+  }).trim();
+}
+
+/** HEAD commit SHA of a repo (optionally a specific rev). */
+function headSha(dir, rev = "HEAD") {
+  return execSync(`git rev-parse ${rev}`, {
+    cwd: dir, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"],
+  }).trim();
+}
+
+describe("cascade-client", () => {
+  let repoDir;
+  let dbPath;
+  let tracker;
+
+  beforeEach(() => {
+    repoDir = makeTmpDir("cascade-test-");
+    dbPath = path.join(repoDir, "tracker.db");
+    makeGitRepo(repoDir);
+    tracker = null;
+  });
+
+  afterEach(() => {
+    if (tracker) {
+      closeCascadeTracker(tracker);
+      tracker = null;
+    }
+    cleanupTmpDir(repoDir);
+  });
+
+  it("openCascadeTracker returns a tracker for a git repo", async () => {
+    tracker = await openCascadeTracker({ repoPath: repoDir, dbPath });
+    expect(tracker).not.toBeNull();
+    expect(typeof tracker.trackExistingBranch).toBe("function");
+  });
+
+  it("openCascadeTracker returns null for a non-git directory", async () => {
+    const nonGit = makeTmpDir("cascade-nongit-");
+    try {
+      const t = await openCascadeTracker({
+        repoPath: nonGit,
+        dbPath: path.join(nonGit, "tracker.db"),
+      });
+      expect(t).toBeNull();
+    } finally {
+      cleanupTmpDir(nonGit);
+    }
+  });
+
+  it("ensureStream creates a stream for the working branch", async () => {
+    tracker = await openCascadeTracker({ repoPath: repoDir, dbPath });
+    expect(tracker).not.toBeNull();
+
+    const branch = currentBranch(repoDir);
+    const result = ensureStream(tracker, { branch, agentId: "team-sidecar" });
+
+    expect(result).not.toBeNull();
+    expect(result.created).toBe(true);
+    expect(typeof result.streamId).toBe("string");
+    expect(result.streamId.length).toBeGreaterThan(0);
+  });
+
+  it("ensureStream is idempotent on a second call for the same branch", async () => {
+    tracker = await openCascadeTracker({ repoPath: repoDir, dbPath });
+    expect(tracker).not.toBeNull();
+
+    const branch = currentBranch(repoDir);
+    const first = ensureStream(tracker, { branch, agentId: "team-sidecar" });
+    const second = ensureStream(tracker, { branch, agentId: "team-sidecar" });
+
+    expect(first).not.toBeNull();
+    expect(second).not.toBeNull();
+    expect(first.created).toBe(true);
+    expect(second.created).toBe(false);
+    expect(second.streamId).toBe(first.streamId);
+  });
+
+  it("ensureStream tracks distinct branches as separate streams", async () => {
+    tracker = await openCascadeTracker({ repoPath: repoDir, dbPath });
+    expect(tracker).not.toBeNull();
+
+    const a = ensureStream(tracker, { branch: "feature-a", agentId: "team-sidecar" });
+    const b = ensureStream(tracker, { branch: "feature-b", agentId: "team-sidecar" });
+
+    expect(a).not.toBeNull();
+    expect(b).not.toBeNull();
+    expect(a.created).toBe(true);
+    expect(b.created).toBe(true);
+    expect(a.streamId).not.toBe(b.streamId);
+  });
+
+  it("ensureStream returns null when tracker is missing", () => {
+    expect(ensureStream(null, { branch: "main", agentId: "x" })).toBeNull();
+  });
+
+  it("closeCascadeTracker is a safe no-op on null", () => {
+    expect(() => closeCascadeTracker(null)).not.toThrow();
+  });
+
+  it("closeCascadeTracker closes an open tracker", async () => {
+    const t = await openCascadeTracker({ repoPath: repoDir, dbPath });
+    expect(t).not.toBeNull();
+    expect(() => closeCascadeTracker(t)).not.toThrow();
+  });
+
+  it("findStreamByBranch resolves a tracked branch and returns null otherwise", async () => {
+    tracker = await openCascadeTracker({ repoPath: repoDir, dbPath });
+    expect(tracker).not.toBeNull();
+
+    const branch = currentBranch(repoDir);
+    const created = ensureStream(tracker, { branch, agentId: "team-sidecar" });
+    expect(created).not.toBeNull();
+
+    expect(findStreamByBranch(tracker, branch)).toBe(created.streamId);
+    expect(findStreamByBranch(tracker, "no-such-branch")).toBeNull();
+    expect(findStreamByBranch(null, branch)).toBeNull();
+  });
+
+  it("recordObservedCommit persists a change and returns its id", async () => {
+    tracker = await openCascadeTracker({ repoPath: repoDir, dbPath });
+    expect(tracker).not.toBeNull();
+
+    const branch = currentBranch(repoDir);
+    const stream = ensureStream(tracker, { branch, agentId: "team-sidecar" });
+    expect(stream).not.toBeNull();
+
+    const commit = headSha(repoDir);
+    const changeId = await recordObservedCommit(tracker, {
+      streamId: stream.streamId,
+      commit,
+      description: "initial",
+    });
+
+    expect(typeof changeId).toBe("string");
+    expect(changeId.length).toBeGreaterThan(0);
+  });
+
+  it("recordObservedCommit returns null when tracker is missing", async () => {
+    const result = await recordObservedCommit(null, {
+      streamId: "s1", commit: "abc", description: "x",
+    });
+    expect(result).toBeNull();
+  });
+
+  it("recordObservedMerge persists a merge edge and returns its id", async () => {
+    tracker = await openCascadeTracker({ repoPath: repoDir, dbPath });
+    expect(tracker).not.toBeNull();
+
+    const target = ensureStream(tracker, { branch: currentBranch(repoDir), agentId: "team-sidecar" });
+    const source = ensureStream(tracker, { branch: "feature-a", agentId: "team-sidecar" });
+    expect(target).not.toBeNull();
+    expect(source).not.toBeNull();
+
+    const mergeCommit = headSha(repoDir);
+    const mergeId = await recordObservedMerge(tracker, {
+      sourceStreamId: source.streamId,
+      sourceCommit: headSha(repoDir, "feature-a"),
+      targetStreamId: target.streamId,
+      mergeCommit,
+      metadata: { trigger: "test" },
+    });
+
+    expect(typeof mergeId).toBe("string");
+    expect(mergeId.length).toBeGreaterThan(0);
+  });
+
+  it("recordObservedMerge returns null when required fields are missing", async () => {
+    tracker = await openCascadeTracker({ repoPath: repoDir, dbPath });
+    expect(tracker).not.toBeNull();
+    const result = await recordObservedMerge(tracker, { sourceStreamId: "s1" });
+    expect(result).toBeNull();
+  });
+});

package/src/__tests__/cascade-diff-server.test.mjs

@@ -0,0 +1,375 @@
+/**
+ * cascade-diff-server.test.mjs — cascade diff server (Phase 3)
+ *
+ * Exercises setupCascadeDiffServer against a real temp git repo with a mocked
+ * MAP connection that captures sendNotification calls. Covers single-commit
+ * diffs, range diffs, files_only, large-diff chunking (seq/final/sha256), and
+ * the typed error reply for a bad request.
+ *
+ * Also includes the Phase 3 stacking verification: a branch forked from a
+ * tracked branch emits `x-cascade/stream.opened` with `parent_stream` set, and
+ * the tracker DB records the parent edge.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { execSync } from "child_process";
+import { createHash } from "crypto";
+import fs from "fs";
+import path from "path";
+import { setupCascadeDiffServer } from "../cascade-diff-server.mjs";
+import { openCascadeTracker, ensureStream, findStreamByBranch, closeCascadeTracker } from "../cascade-client.mjs";
+import { startCascadeWatcher } from "../cascade-watcher.mjs";
+import { makeTmpDir, cleanupTmpDir } from "./helpers.mjs";
+
+/** Run a git command in `dir`, returning trimmed stdout. */
+function g(dir, args) {
+  return execSync(`git ${args}`, {
+    cwd: dir, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"],
+  }).trim();
+}
+
+/** Create a real git repo with an initial commit on `main`. */
+function makeGitRepo(dir) {
+  g(dir, "init -b main");
+  g(dir, 'config user.email "test@test.com"');
+  g(dir, 'config user.name "Test"');
+  g(dir, "config commit.gpgsign false");
+  fs.writeFileSync(path.join(dir, "README.md"), "# test\n");
+  g(dir, "add .");
+  g(dir, 'commit -m "initial"');
+  return g(dir, "rev-parse HEAD");
+}
+
+/** Write a file and commit it; returns the new HEAD SHA. */
+function commitFile(dir, relPath, content, message) {
+  const full = path.join(dir, relPath);
+  fs.mkdirSync(path.dirname(full), { recursive: true });
+  fs.writeFileSync(full, content);
+  g(dir, "add -A");
+  g(dir, `commit -m "${message}"`);
+  return g(dir, "rev-parse HEAD");
+}
+
+/**
+ * Mock MAP connection — captures every sendNotification(method, params) call
+ * and lets the test fire a registered onNotification handler.
+ */
+function makeMockConnection() {
+  const sent = [];
+  const handlers = new Map();
+  return {
+    sent,
+    handlers,
+    onNotification(method, handler) {
+      handlers.set(method, handler);
+    },
+    offNotification(method) {
+      handlers.delete(method);
+    },
+    sendNotification(method, params) {
+      sent.push({ method, params });
+      return Promise.resolve();
+    },
+    /** Sent notifications for a given cascade method. */
+    sentFor(method) {
+      return sent.filter((s) => s.method === method);
+    },
+    /** Fire the registered handler for `method` and await it. */
+    async fire(method, params) {
+      const handler = handlers.get(method);
+      if (!handler) throw new Error(`no handler for ${method}`);
+      await handler(params);
+    },
+  };
+}
+
+describe("cascade-diff-server", () => {
+  let repoDir;
+  let dbDir;
+  let dbPath;
+  let tracker;
+  let dispose;
+
+  beforeEach(async () => {
+    repoDir = makeTmpDir("cascade-diff-");
+    // Keep the tracker DB outside the repo so `git add -A` never stages it
+    // into a diff under test.
+    dbDir = makeTmpDir("cascade-diff-db-");
+    dbPath = path.join(dbDir, "tracker.db");
+    makeGitRepo(repoDir);
+    tracker = await openCascadeTracker({ repoPath: repoDir, dbPath });
+    ensureStream(tracker, { branch: "main", agentId: "team-sidecar" });
+    dispose = null;
+  });
+
+  afterEach(() => {
+    if (dispose) {
+      try { dispose(); } catch { /* ignore */ }
+      dispose = null;
+    }
+    if (tracker) {
+      closeCascadeTracker(tracker);
+      tracker = null;
+    }
+    cleanupTmpDir(repoDir);
+    cleanupTmpDir(dbDir);
+  });
+
+  it("serves a single-commit diff inline", async () => {
+    const conn = makeMockConnection();
+    dispose = setupCascadeDiffServer(conn, { repoPath: repoDir, tracker });
+
+    const sha = commitFile(repoDir, "feature.txt", "hello world\n", "add feature");
+    const streamId = findStreamByBranch(tracker, "main");
+
+    await conn.fire("cascade/diff.request", {
+      request_id: "req-1",
+      stream_id: streamId,
+      head: sha,
+      format: "unified",
+    });
+
+    const responses = conn.sentFor("cascade/diff.response");
+    expect(responses.length).toBe(1);
+    const p = responses[0].params;
+    expect(p.request_id).toBe("req-1");
+    expect(p.streaming).toBe(false);
+    expect(p.diff).toContain("feature.txt");
+    expect(p.diff).toContain("+hello world");
+    expect(p.files_touched).toContain("feature.txt");
+    expect(p.truncated).toBe(false);
+  });
+
+  it("serves a range diff for base..head", async () => {
+    const conn = makeMockConnection();
+    dispose = setupCascadeDiffServer(conn, { repoPath: repoDir, tracker });
+
+    const base = g(repoDir, "rev-parse HEAD");
+    commitFile(repoDir, "a.txt", "alpha\n", "add a");
+    const head = commitFile(repoDir, "b.txt", "beta\n", "add b");
+    const streamId = findStreamByBranch(tracker, "main");
+
+    await conn.fire("cascade/diff.request", {
+      request_id: "req-range",
+      stream_id: streamId,
+      head,
+      base,
+      format: "unified",
+    });
+
+    const responses = conn.sentFor("cascade/diff.response");
+    expect(responses.length).toBe(1);
+    const p = responses[0].params;
+    expect(p.streaming).toBe(false);
+    // Both commits in the range are present.
+    expect(p.diff).toContain("a.txt");
+    expect(p.diff).toContain("b.txt");
+    expect(p.files_touched.sort()).toEqual(["a.txt", "b.txt"]);
+  });
+
+  it("returns only file names when files_only is set", async () => {
+    const conn = makeMockConnection();
+    dispose = setupCascadeDiffServer(conn, { repoPath: repoDir, tracker });
+
+    const sha = commitFile(repoDir, "src/x.txt", "x\n", "add x");
+    const streamId = findStreamByBranch(tracker, "main");
+
+    await conn.fire("cascade/diff.request", {
+      request_id: "req-files",
+      stream_id: streamId,
+      head: sha,
+      files_only: true,
+      format: "unified",
+    });
+
+    const responses = conn.sentFor("cascade/diff.response");
+    expect(responses.length).toBe(1);
+    const p = responses[0].params;
+    expect(p.streaming).toBe(false);
+    // files_only: no diff body, just the file list.
+    expect(p.diff).toBe("");
+    expect(p.files_touched).toEqual(["src/x.txt"]);
+  });
+
+  it("streams a large diff in seq-ordered chunks with a final sha256", async () => {
+    const conn = makeMockConnection();
+    dispose = setupCascadeDiffServer(conn, { repoPath: repoDir, tracker });
+
+    // A >512 KB file forces the streaming path (inline threshold is 512 KB).
+    const bigContent = "lorem ipsum dolor sit amet\n".repeat(40_000); // ~1.05 MB
+    const sha = commitFile(repoDir, "big.txt", bigContent, "add big file");
+    const streamId = findStreamByBranch(tracker, "main");
+
+    await conn.fire("cascade/diff.request", {
+      request_id: "req-big",
+      stream_id: streamId,
+      head: sha,
+      format: "unified",
+    });
+
+    // Announcement.
+    const responses = conn.sentFor("cascade/diff.response");
+    expect(responses.length).toBe(1);
+    const ann = responses[0].params;
+    expect(ann.streaming).toBe(true);
+    expect(typeof ann.chunk_stream_id).toBe("string");
+    expect(ann.total_size).toBeGreaterThan(512 * 1024);
+    expect(ann.files_touched).toContain("big.txt");
+
+    // Chunks: contiguous seq from 0, exactly one final.
+    const chunks = conn.sentFor("cascade/diff.chunk");
+    expect(chunks.length).toBeGreaterThan(1);
+    chunks.forEach((c, i) => {
+      expect(c.params.chunk_stream_id).toBe(ann.chunk_stream_id);
+      expect(c.params.seq).toBe(i);
+    });
+    const finalChunks = chunks.filter((c) => c.params.final === true);
+    expect(finalChunks.length).toBe(1);
+    expect(finalChunks[0]).toBe(chunks[chunks.length - 1]);
+
+    // Reassemble in seq order and verify sha256 over the full payload.
+    const assembled = Buffer.concat(
+      chunks.map((c) => Buffer.from(c.params.data, "base64")),
+    );
+    expect(assembled.length).toBe(ann.total_size);
+    const got = createHash("sha256").update(assembled).digest("hex");
+    expect(got).toBe(finalChunks[0].params.sha256);
+    expect(assembled.toString("utf-8")).toContain("big.txt");
+  });
+
+  it("replies with the typed error variant for a bad request", async () => {
+    const conn = makeMockConnection();
+    dispose = setupCascadeDiffServer(conn, { repoPath: repoDir, tracker });
+
+    // Missing head — a malformed request.
+    await conn.fire("cascade/diff.request", {
+      request_id: "req-bad",
+      stream_id: "stream-x",
+    });
+
+    const responses = conn.sentFor("cascade/diff.response");
+    expect(responses.length).toBe(1);
+    expect(responses[0].params.request_id).toBe("req-bad");
+    expect(responses[0].params.error).toBeTruthy();
+    expect(responses[0].params.error.code).toBe("bad_request");
+  });
+
+  it("replies with the error variant when git fails on a bad commit", async () => {
+    const conn = makeMockConnection();
+    dispose = setupCascadeDiffServer(conn, { repoPath: repoDir, tracker });
+
+    const streamId = findStreamByBranch(tracker, "main");
+    await conn.fire("cascade/diff.request", {
+      request_id: "req-nogit",
+      stream_id: streamId,
+      head: "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef",
+      format: "unified",
+    });
+
+    const responses = conn.sentFor("cascade/diff.response");
+    expect(responses.length).toBe(1);
+    expect(responses[0].params.request_id).toBe("req-nogit");
+    expect(responses[0].params.error).toBeTruthy();
+    expect(responses[0].params.error.code).toBe("internal");
+  });
+
+  it("never throws — ignores a request with no request_id", async () => {
+    const conn = makeMockConnection();
+    dispose = setupCascadeDiffServer(conn, { repoPath: repoDir, tracker });
+    await expect(conn.fire("cascade/diff.request", {})).resolves.not.toThrow();
+    expect(conn.sentFor("cascade/diff.response").length).toBe(0);
+  });
+
+  it("dispose() unregisters the handler and is idempotent", () => {
+    const conn = makeMockConnection();
+    const d = setupCascadeDiffServer(conn, { repoPath: repoDir, tracker });
+    expect(conn.handlers.has("cascade/diff.request")).toBe(true);
+    d();
+    expect(conn.handlers.has("cascade/diff.request")).toBe(false);
+    expect(() => d()).not.toThrow();
+  });
+
+  it("returns a no-op dispose when the connection cannot register handlers", () => {
+    const d = setupCascadeDiffServer({}, { repoPath: repoDir, tracker });
+    expect(typeof d).toBe("function");
+    expect(() => d()).not.toThrow();
+  });
+});
+
+describe("cascade stacking — forked branch carries parent_stream", () => {
+  let repoDir;
+  let dbDir;
+  let dbPath;
+  let tracker;
+  let watcher;
+
+  /** Mock MAP connection capturing callExtension calls (watcher emit path). */
+  function makeEmitConnection() {
+    const calls = [];
+    return {
+      calls,
+      callExtension(method, params) {
+        calls.push({ method, params });
+        return Promise.resolve({ ok: true });
+      },
+      callsFor(suffix) {
+        return calls.filter((c) => c.method.endsWith(suffix));
+      },
+    };
+  }
+
+  beforeEach(async () => {
+    repoDir = makeTmpDir("cascade-stack-");
+    dbDir = makeTmpDir("cascade-stack-db-");
+    dbPath = path.join(dbDir, "tracker.db");
+    makeGitRepo(repoDir);
+    tracker = await openCascadeTracker({ repoPath: repoDir, dbPath });
+    // Track `main` so the watcher can resolve it as the fork parent.
+    ensureStream(tracker, { branch: "main", agentId: "team-sidecar" });
+    watcher = null;
+  });
+
+  afterEach(() => {
+    if (watcher) {
+      try { watcher.stop(); } catch { /* ignore */ }
+      watcher = null;
+    }
+    if (tracker) {
+      closeCascadeTracker(tracker);
+      tracker = null;
+    }
+    cleanupTmpDir(repoDir);
+    cleanupTmpDir(dbDir);
+  });
+
+  it("emits stream.opened with parent_stream and records the parent edge in the tracker DB", async () => {
+    const conn = makeEmitConnection();
+    watcher = startCascadeWatcher({ tracker, connection: conn, repoPath: repoDir });
+    await watcher._ready;
+
+    const mainStreamId = findStreamByBranch(tracker, "main");
+    expect(mainStreamId).toBeTruthy();
+
+    // Fork a new branch off main's HEAD (a clean fork — main's HEAD is the
+    // fork point), then detect it with a tick.
+    g(repoDir, "branch feature-stack");
+    await watcher._tickNow();
+
+    // The stream.opened event for the forked branch carries parent_stream.
+    const opened = conn.callsFor("stream.opened");
+    const forkEvent = opened.find((c) => c.params.branch_name === "feature-stack");
+    expect(forkEvent).toBeTruthy();
+    expect(forkEvent.params.parent_stream).toBe(mainStreamId);
+
+    // The tracker DB recorded the parent edge — listStreams exposes it so the
+    // hub's PR-stack walker can traverse parent → child.
+    const forkStreamId = findStreamByBranch(tracker, "feature-stack");
+    expect(forkStreamId).toBeTruthy();
+    const streams = tracker.listStreams();
+    const forkRow = streams.find((s) => s.id === forkStreamId);
+    expect(forkRow).toBeTruthy();
+    // git-cascade records the parent edge on the stream row.
+    const recordedParent = forkRow.parent_stream ?? forkRow.parentStream ?? forkRow.parent_stream_id;
+    expect(recordedParent).toBe(mainStreamId);
+  });
+});