@cueloop/daemon 0.1.0-alpha.7 → 0.1.0-alpha.71

package/src/curate.ts

@@ -0,0 +1,109 @@
+/**
+ * The curated patch of a diff review: the submitted changes minus the hunks and
+ * change blocks the reviewer rejected. The daemon computes it from the
+ * session's reject decisions so the working copy every client sees is one and
+ * the same; the client only maps rows to decisions.
+ */
+
+import { diffAcceptRejectHunk, parseDiffFromFile, type FileDiffMetadata } from "@pierre/diffs";
+import {
+  unifiedDiffText,
+  type DiffFileContents,
+  type DiffFileStatus,
+  type HunkRejection,
+} from "@cueloop/schema";
+
+/**
+ * Context lines around each change. Matching git's default (3) makes the model
+ * split hunks like the rendered working-tree patch does; a row is mapped by
+ * absolute line number, never by counting hunks, so a whole-hunk reject can
+ * only ever span the model hunk it lands in.
+ */
+export const DIFF_CONTEXT = 3;
+
+/** Parse one file's full contents into a non-partial diff model. */
+export function parseFileDiff(file: DiffFileContents): FileDiffMetadata {
+  return parseDiffFromFile(
+    { name: file.path, contents: file.oldContents },
+    { name: file.path, contents: file.newContents },
+    { context: DIFF_CONTEXT },
+  );
+}
+
+/**
+ * Apply one file's rejections and return its curated patch, or null when the
+ * curated content equals the old content (every change rejected - no patch).
+ * Whole-hunk rejections supersede change-level ones for the same hunk. Because
+ * `diffAcceptRejectHunk` returns a model with the same hunk/content shape, the
+ * indices stay valid across calls; they are applied high-to-low regardless, so
+ * the order is deterministic.
+ */
+function curateFilePatch(file: DiffFileContents, rejections: HunkRejection[]): string | null {
+  let model = parseFileDiff(file);
+  const wholeHunks = new Set(
+    rejections
+      .filter((rejection) => rejection.changeIndex === undefined)
+      .map((rejection) => rejection.hunkIndex),
+  );
+
+  for (const hunkIndex of [...wholeHunks].sort((a, b) => b - a)) {
+    model = diffAcceptRejectHunk(model, hunkIndex, "reject");
+  }
+  const changeRejections = rejections
+    .filter(
+      (rejection) => rejection.changeIndex !== undefined && !wholeHunks.has(rejection.hunkIndex),
+    )
+    .sort((a, b) => b.hunkIndex - a.hunkIndex || b.changeIndex! - a.changeIndex!);
+
+  for (const rejection of changeRejections) {
+    model = diffAcceptRejectHunk(model, rejection.hunkIndex, {
+      type: "reject",
+      changeIndex: rejection.changeIndex!,
+    });
+  }
+  const curatedNew = model.additionLines.join("");
+
+  if (curatedNew === file.oldContents) return null;
+  const patch = unifiedDiffText(file.oldContents, curatedNew, file.path);
+
+  if (patch === null) return null;
+
+  return withFileStateHeaders(patch, file.path, file.status, curatedNew);
+}
+
+/**
+ * Point the diff headers at /dev/null for a created or fully-deleted file so the
+ * curated patch applies. git's status - not empty contents - decides existence,
+ * so editing an existing empty file stays a modify; a deletion whose removals
+ * were partly restored also falls back to a modify.
+ */
+function withFileStateHeaders(
+  patch: string,
+  path: string,
+  status: DiffFileStatus,
+  curatedNew: string,
+): string {
+  if (status === "added") return patch.replace(`--- a/${path}`, "--- /dev/null");
+  if (status === "deleted" && curatedNew === "") {
+    return patch.replace(`+++ b/${path}`, "+++ /dev/null");
+  }
+
+  return patch;
+}
+
+/**
+ * The curated unified-diff patch of the accepted changes across every file.
+ * Files with no net change (unchanged, or with all changes rejected) drop out.
+ */
+export function curateDiff(files: DiffFileContents[], rejections: HunkRejection[]): string {
+  const parts: string[] = [];
+
+  for (const file of files) {
+    const fileRejections = rejections.filter((rejection) => rejection.path === file.path);
+    const patch = curateFilePatch(file, fileRejections);
+
+    if (patch) parts.push(patch);
+  }
+
+  return parts.join("\n");
+}

package/src/daemon-version.test.ts

@@ -0,0 +1,93 @@
+/**
+ * Version handshake: a client must never keep talking to a daemon from an
+ * earlier build (the stale-daemon-after-upgrade bug). The ping carries the
+ * daemon's version; a mismatch without autostart is a clear error, and a
+ * matching version connects normally.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DaemonServer } from "./server";
+import { DaemonClient, DaemonClientError, daemonSpawnCommand } from "./client";
+import { DAEMON_VERSION } from "./version";
+import type { Artifact, WorkspaceKey } from "@cueloop/schema";
+
+const WS: WorkspaceKey = { repoRoot: "/repo", branch: "main" };
+const PLAN: Artifact = { type: "plan", content: "# P\n\nBody.\n", meta: {} };
+
+let home: string;
+const servers: DaemonServer[] = [];
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-version-"));
+});
+afterEach(() => {
+  for (const runningServer of servers.splice(0)) runningServer.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+function server(version?: string): DaemonServer {
+  const daemonServer = new DaemonServer({ home, idleExitMs: 0, version });
+
+  servers.push(daemonServer);
+
+  return daemonServer;
+}
+
+describe("daemon version handshake", () => {
+  test("a stale daemon is rejected when there is nothing to replace it", async () => {
+    // Arrange - a daemon posing as an earlier build
+    server("0.0.0-stale").start();
+
+    // Act + Assert - without autostart the client cannot restart it, so it says why
+    await expect(DaemonClient.connect({ home, autostart: false })).rejects.toMatchObject({
+      code: "version_mismatch",
+    });
+    await expect(DaemonClient.connect({ home, autostart: false })).rejects.toBeInstanceOf(
+      DaemonClientError,
+    );
+  });
+
+  test("a current daemon connects and serves normally", async () => {
+    // Arrange - a daemon on this build
+    server(DAEMON_VERSION).start();
+    const client = await DaemonClient.connect({ home, autostart: false });
+
+    // Act - a round-trip proves the connection is live, not replaced
+    const created = await client.sessionCreate(WS, PLAN);
+    const listed = await client.sessionList();
+
+    // Assert
+    expect(listed.map((session) => session.id)).toContain(created.id);
+    client.close();
+  });
+});
+
+describe("daemon spawn command", () => {
+  const SOURCE_URL = "file:///repo/packages/daemon/src/client.ts";
+
+  test("from source it bun-runs main.ts", () => {
+    expect(daemonSpawnCommand("/bin/bun", SOURCE_URL, false)).toEqual([
+      "/bin/bun",
+      "run",
+      "/repo/packages/daemon/src/main.ts",
+    ]);
+  });
+
+  test("dev-watch reloads the daemon on source edits", () => {
+    expect(daemonSpawnCommand("/bin/bun", SOURCE_URL, true)).toEqual([
+      "/bin/bun",
+      "--watch",
+      "run",
+      "/repo/packages/daemon/src/main.ts",
+    ]);
+  });
+
+  test("a compiled binary re-execs its own daemon command, never --watch", () => {
+    expect(
+      daemonSpawnCommand("/usr/local/bin/cueloop", "file:///$bunfs/root/cueloop", true),
+    ).toEqual(["/usr/local/bin/cueloop", "daemon", "--autostart"]);
+  });
+});

package/src/diff-hot-reload.test.ts

@@ -0,0 +1,186 @@
+/**
+ * Diff hot-reload: session.refreshDiff re-captures a diff session's working
+ * tree, and the fs watcher drives it on a real change. Exercised against a
+ * real temp git repo so the capture path is the production one.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DaemonCore } from "./api";
+import { workingTreeDiff } from "./working-tree";
+import { resolveWorkspace } from "./review";
+import type { Artifact } from "@cueloop/schema";
+
+function git(args: string[], cwd: string): void {
+  const result = Bun.spawnSync(["git", ...args], { cwd, stdout: "ignore", stderr: "ignore" });
+
+  if (result.exitCode !== 0) throw new Error(`git ${args.join(" ")} failed in ${cwd}`);
+}
+
+let home: string;
+let repo: string;
+let core: DaemonCore;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-hotreload-home-"));
+  repo = mkdtempSync(join(tmpdir(), "cueloop-hotreload-repo-"));
+  git(["init", "-q", "-b", "main"], repo);
+  git(["config", "user.email", "t@t"], repo);
+  git(["config", "user.name", "t"], repo);
+  writeFileSync(join(repo, "a.ts"), "export const a = 1;\n");
+  git(["add", "."], repo);
+  git(["commit", "-qm", "init"], repo);
+  core = new DaemonCore(home);
+});
+
+afterEach(() => {
+  core.dispose();
+  rmSync(home, { recursive: true, force: true });
+  rmSync(repo, { recursive: true, force: true });
+});
+
+/** Open a diff session over the temp repo's current working tree. */
+async function openDiffSession() {
+  const workspace = await resolveWorkspace(repo);
+  const diff = await workingTreeDiff(repo);
+  const artifact: Artifact = { type: "diff", content: diff.patch, files: diff.files, meta: {} };
+
+  return core.sessionCreate({ workspace, artifact });
+}
+
+describe("session.refreshDiff", () => {
+  test("re-captures the working tree and updates the artifact when the patch changed", async () => {
+    // Given an open diff session whose working tree then gains a new change
+    const session = await openDiffSession();
+
+    writeFileSync(join(repo, "a.ts"), "export const a = 2;\n");
+
+    // When the diff is refreshed
+    const result = await core.sessionRefreshDiff(session.id);
+
+    // Then the change is reported and the stored artifact carries the fresh patch and files
+    expect(result.changed).toBe(true);
+    const refreshed = core.sessionGet(session.id);
+
+    expect(refreshed.artifact.content).toContain("+export const a = 2;");
+    const modified = refreshed.artifact.files!.find((file) => file.path === "a.ts")!;
+
+    expect(modified.newContents).toBe("export const a = 2;\n");
+  });
+
+  test("reports no change and emits nothing when the working tree is unchanged", async () => {
+    // Given an open diff session and a listener for session events
+    const session = await openDiffSession();
+    const events: string[] = [];
+
+    core.onEvent((event) => events.push(event.event));
+
+    // When the diff is refreshed without any working-tree change
+    const result = await core.sessionRefreshDiff(session.id);
+
+    // Then nothing changed and no session.updated event fired
+    expect(result.changed).toBe(false);
+    expect(events).not.toContain("session.updated");
+  });
+
+  test("a changed refresh emits session.updated so attached clients re-fetch", async () => {
+    // Given an open diff session, a listener, and a fresh working-tree change
+    const session = await openDiffSession();
+    const events: string[] = [];
+
+    core.onEvent((event) => events.push(event.event));
+    writeFileSync(join(repo, "a.ts"), "export const a = 3;\n");
+
+    // When the diff is refreshed
+    await core.sessionRefreshDiff(session.id);
+
+    // Then a session.updated event fired for this session
+    expect(events).toContain("session.updated");
+  });
+
+  test("a tree move after a refresh keeps the fresh patch", async () => {
+    // Given a refreshed diff session
+    const session = await openDiffSession();
+
+    writeFileSync(join(repo, "a.ts"), "export const a = 4;\n");
+    await core.sessionRefreshDiff(session.id);
+
+    // When the owner branches off and switches back
+    core.sessionBranch(session.id, "alt");
+    const shown = core.sessionSwitch(session.id, "main");
+
+    // Then the artifact still shows the re-captured working tree, and the history has one revision
+    expect(shown.artifact.content).toContain("+export const a = 4;");
+    expect(shown.history!.entries.filter((entry) => entry.type === "revision")).toHaveLength(1);
+  });
+
+  test("is a no-op for a non-diff (plan) session", async () => {
+    // Given a plan session in the same workspace
+    const workspace = await resolveWorkspace(repo);
+    const plan: Artifact = { type: "plan", content: "# Plan\n\nBody.\n", meta: {} };
+    const session = core.sessionCreate({ workspace, artifact: plan });
+
+    // When a refresh is attempted
+    const result = await core.sessionRefreshDiff(session.id);
+
+    // Then it reports no change and leaves the plan content untouched
+    expect(result.changed).toBe(false);
+    expect(core.sessionGet(session.id).artifact.content).toBe("# Plan\n\nBody.\n");
+  });
+
+  test("refusing a resolved diff session never mutates it (no revive of a closed review)", async () => {
+    // Given a diff session that has been resolved
+    const session = await openDiffSession();
+
+    core.sessionResolve(session.id, "approve", "");
+    const resolvedContent = core.sessionGet(session.id).artifact.content;
+
+    writeFileSync(join(repo, "a.ts"), "export const a = 99;\n");
+
+    // When a refresh is attempted on the resolved session
+    // Then it is rejected and the frozen artifact is untouched
+    expect(core.sessionRefreshDiff(session.id)).rejects.toThrow(/resolved/);
+    expect(core.sessionGet(session.id).artifact.content).toBe(resolvedContent);
+  });
+
+  test("overlapping refreshes settle to one coherent artifact without error", async () => {
+    // Given a live diff session with a fresh working-tree change
+    const session = await openDiffSession();
+
+    writeFileSync(join(repo, "a.ts"), "export const a = 7;\n");
+
+    // When two refreshes run concurrently over the same session
+    const [first, second] = await Promise.all([
+      core.sessionRefreshDiff(session.id),
+      core.sessionRefreshDiff(session.id),
+    ]);
+
+    // Then both settle and the stored artifact reflects the current tree exactly
+    // once - the generation guard keeps the older capture from regressing it
+    expect(first.changed || second.changed).toBe(true);
+    expect(core.sessionGet(session.id).artifact.content).toContain("+export const a = 7;");
+  });
+});
+
+describe("the fs watcher drives hot-reload", () => {
+  test("a working-tree change under a live diff session refreshes it in place", async () => {
+    // Given a live diff session whose repo the daemon is watching
+    const session = await openDiffSession();
+
+    // When a tracked file changes on disk
+    writeFileSync(join(repo, "a.ts"), "export const a = 42;\n");
+
+    // Then the watcher debounces and re-captures the diff without any manual call.
+    // Watchers can be slow under CI contention, so poll generously.
+    const deadline = Date.now() + 8_000;
+    let content = core.sessionGet(session.id).artifact.content;
+
+    while (!content.includes("+export const a = 42;") && Date.now() < deadline) {
+      await Bun.sleep(100);
+      content = core.sessionGet(session.id).artifact.content;
+    }
+    expect(content).toContain("+export const a = 42;");
+  }, 12_000);
+});

package/src/diff-watcher.ts

@@ -0,0 +1,102 @@
+/**
+ * Watches a diff session's repository for working-tree changes and drives the
+ * hot-reload: on any change under a repo root that a live diff session tracks,
+ * the daemon re-captures that session's diff so the open review updates in place.
+ * One recursive fs watcher per repo root - many diff sessions can share a repo -
+ * with a debounce so a burst of file writes triggers a single re-capture.
+ */
+
+import { watch, type FSWatcher } from "node:fs";
+import { sep } from "node:path";
+
+/** Debounce window: a save or a checkout writes many files in a burst; collapse them into one re-capture. */
+const DIFF_REFRESH_DEBOUNCE_MS = 300;
+
+/**
+ * Paths whose churn must never trigger a diff refresh. git rewrites `.git`
+ * metadata (the index, lock files) on every read `cueloop diff` itself runs, so
+ * watching it would loop; `node_modules` churns on installs and is never review
+ * content.
+ */
+function isIgnoredWatchPath(relativePath: string): boolean {
+  const segments = relativePath.split(sep);
+
+  return segments.includes(".git") || segments.includes("node_modules");
+}
+
+interface RepoWatch {
+  handle: FSWatcher;
+  /** Live diff session ids sharing this repo root; the watch closes when the last one leaves. */
+  sessionIds: Set<string>;
+  debounce: ReturnType<typeof setTimeout> | null;
+}
+
+/**
+ * Owns the fs watchers behind diff hot-reload. `onRepoChange` fires once per
+ * debounced burst with the repo root that changed; the caller re-captures every
+ * live diff session on that root. A watcher error or an unwatchable root is
+ * swallowed - hot-reload is best-effort and must never crash the daemon.
+ */
+export class DiffWatcher {
+  private readonly repoWatches = new Map<string, RepoWatch>();
+
+  constructor(private readonly onRepoChange: (repoRoot: string) => void) {}
+
+  /** Start (or join) watching a repo root for one diff session. Idempotent per (root, session). */
+  trackDiffRepo(repoRoot: string, sessionId: string): void {
+    const existing = this.repoWatches.get(repoRoot);
+
+    if (existing) {
+      existing.sessionIds.add(sessionId);
+
+      return;
+    }
+    let handle: FSWatcher;
+
+    try {
+      handle = watch(repoRoot, { recursive: true }, (_event, filename) => {
+        if (filename !== null && isIgnoredWatchPath(filename.toString())) return;
+        this.scheduleRepoRefresh(repoRoot);
+      });
+    } catch {
+      // repo root gone or not watchable on this platform: skip, no hot-reload here
+      return;
+    }
+    // a watcher error (the root is deleted mid-review) must not take down the
+    // daemon; the inherited EventEmitter `on` is absent from Bun's FSWatcher type
+    handle.on("error", () => {});
+    this.repoWatches.set(repoRoot, { handle, sessionIds: new Set([sessionId]), debounce: null });
+  }
+
+  /** Drop one diff session; close the repo watch once no diff session tracks it. */
+  untrackDiffRepo(repoRoot: string, sessionId: string): void {
+    const repoWatch = this.repoWatches.get(repoRoot);
+
+    if (!repoWatch) return;
+    repoWatch.sessionIds.delete(sessionId);
+    if (repoWatch.sessionIds.size > 0) return;
+    if (repoWatch.debounce !== null) clearTimeout(repoWatch.debounce);
+    repoWatch.handle.close();
+    this.repoWatches.delete(repoRoot);
+  }
+
+  private scheduleRepoRefresh(repoRoot: string): void {
+    const repoWatch = this.repoWatches.get(repoRoot);
+
+    if (!repoWatch) return;
+    if (repoWatch.debounce !== null) clearTimeout(repoWatch.debounce);
+    repoWatch.debounce = setTimeout(() => {
+      repoWatch.debounce = null;
+      this.onRepoChange(repoRoot);
+    }, DIFF_REFRESH_DEBOUNCE_MS);
+  }
+
+  /** Close every watcher and cancel pending debounces (daemon shutdown). */
+  close(): void {
+    for (const repoWatch of this.repoWatches.values()) {
+      if (repoWatch.debounce !== null) clearTimeout(repoWatch.debounce);
+      repoWatch.handle.close();
+    }
+    this.repoWatches.clear();
+  }
+}