@cueloop/daemon 0.1.0-alpha.43 → 0.1.0-alpha.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.43",
+  "version": "0.1.0-alpha.44",
   "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -21,6 +21,7 @@
     ".": "./src/index.ts",
     "./client": "./src/client.ts",
     "./review": "./src/review.ts",
+    "./working-tree": "./src/working-tree.ts",
     "./herdr-pane": "./src/herdr-pane.ts",
     "./herdr-split": "./src/herdr-split.ts",
     "./share-blob": "./src/share-blob.ts"
@@ -29,7 +30,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/schema": "0.1.0-alpha.43",
+    "@cueloop/schema": "0.1.0-alpha.44",
     "valibot": "^1.4.2"
   },
   "engines": {

package/src/api.ts

@@ -24,6 +24,8 @@ import {
 } from "@cueloop/schema";
 import { SessionStore } from "./store";
 import { HerdrTabStore, type HerdrTabHandle } from "./herdr-tab-store";
+import { DiffWatcher } from "./diff-watcher";
+import { workingTreeDiff } from "./working-tree";
 import { DaemonError } from "./errors";
 
 export type EventName =
@@ -46,11 +48,27 @@ export class DaemonCore {
   private waiters = new Map<string, ((session: ReviewSession) => void)[]>();
   private listeners = new Set<EventListener>();
   private seq = 0;
+  /** Drives diff hot-reload: watches each live diff session's repo for working-tree changes. */
+  private readonly diffWatcher: DiffWatcher;
+  /**
+   * Per-diff-session capture generation. Bumped when a refresh begins; a
+   * capture whose generation is stale by the time it finishes discards its
+   * result, so overlapping captures never write an older patch over a newer one.
+   */
+  private readonly diffRefreshGenerations = new Map<string, number>();
 
   constructor(home: string) {
     this.store = new SessionStore(home);
     this.store.recover();
     this.herdrTabs = new HerdrTabStore(home);
+    this.diffWatcher = new DiffWatcher((repoRoot) => void this.refreshDiffsForRepo(repoRoot));
+    // resume hot-reload for diff sessions that survived a daemon restart
+    for (const session of this.store.list()) this.watchIfDiffSession(session);
+  }
+
+  /** Release the fs watchers behind diff hot-reload; call on daemon shutdown. */
+  dispose(): void {
+    this.diffWatcher.close();
   }
 
   /** The herdr tab opened for a review, if any (adapter scratch, not on the session). */
@@ -90,6 +108,7 @@ export class DaemonCore {
       createdAt: now,
     };
     this.store.upsert(session);
+    this.watchIfDiffSession(session);
     this.emit("session.created", session.id);
     this.emit("inbox.changed", session.id);
     return session;
@@ -216,7 +235,10 @@ export class DaemonCore {
 
   /** Remove a session for good (inbox delete); resolved or pending, both go. */
   sessionDelete(id: string): void {
+    const session = this.store.get(id);
     if (!this.store.delete(id)) throw new DaemonError("not_found", `no session ${id}`);
+    if (session) this.unwatchIfDiffSession(session);
+    this.diffRefreshGenerations.delete(id);
     this.herdrTabs.delete(id);
     this.emit("inbox.changed", id);
   }
@@ -259,6 +281,8 @@ export class DaemonCore {
     session.verdict = verdict;
     session.status = "resolved";
     this.store.upsert(session);
+    // a resolved diff review is frozen; stop hot-reloading its working tree
+    this.unwatchIfDiffSession(session);
     const parked = this.waiters.get(id) ?? [];
     this.waiters.delete(id);
     for (const parkedWaiter of parked) parkedWaiter(session);
@@ -313,6 +337,53 @@ export class DaemonCore {
     return session;
   }
 
+  /** Re-capture a diff session's working tree; broadcasts session.updated only when the patch moved. */
+  async sessionRefreshDiff(id: string): Promise<{ changed: boolean }> {
+    const session = this.mutable(id);
+    if (session.artifact.type !== "diff") return { changed: false };
+    const generation = (this.diffRefreshGenerations.get(id) ?? 0) + 1;
+    this.diffRefreshGenerations.set(id, generation);
+    const diff = await workingTreeDiff(session.workspace.repoRoot);
+    // The capture yields the event loop: a newer refresh may have started, or a
+    // concurrent resolve/delete may have closed the session. Discard a stale
+    // capture, and re-read so a resolved review is never mutated and a deleted
+    // one is never revived by this upsert.
+    if (this.diffRefreshGenerations.get(id) !== generation) return { changed: false };
+    const current = this.store.get(id);
+    if (!current || current.status !== "pending" || current.artifact.type !== "diff")
+      return { changed: false };
+    if (diff.patch === current.artifact.content) return { changed: false };
+    current.artifact = { ...current.artifact, content: diff.patch, files: diff.files };
+    this.store.upsert(current);
+    this.emit("session.updated", id);
+    return { changed: true };
+  }
+
+  /** Re-capture every live diff session sharing a repo root (one debounced fs change). */
+  private async refreshDiffsForRepo(repoRoot: string): Promise<void> {
+    const live = this.store
+      .list()
+      .filter((session) => isLiveDiffSession(session) && session.workspace.repoRoot === repoRoot);
+    for (const session of live) {
+      // a session resolved or deleted between the change and this tick just skips
+      try {
+        await this.sessionRefreshDiff(session.id);
+      } catch {
+        // no-op: the session is gone or already resolved
+      }
+    }
+  }
+
+  private watchIfDiffSession(session: ReviewSession): void {
+    if (isLiveDiffSession(session))
+      this.diffWatcher.trackDiffRepo(session.workspace.repoRoot, session.id);
+  }
+
+  private unwatchIfDiffSession(session: ReviewSession): void {
+    if (session.artifact.type === "diff")
+      this.diffWatcher.untrackDiffRepo(session.workspace.repoRoot, session.id);
+  }
+
   private mutable(id: string): ReviewSession {
     const session = this.sessionGet(id);
     if (session.status === "resolved")
@@ -323,6 +394,11 @@ export class DaemonCore {
 
 export { DaemonError };
 
+/** A pending diff session: the state that warrants hot-reload watching of its working tree. */
+function isLiveDiffSession(session: ReviewSession): boolean {
+  return session.status === "pending" && session.artifact.type === "diff";
+}
+
 /** Convenience for adapters: map a resolved session to the agent contract. */
 export function verdictResponse(session: ReviewSession): { allow: boolean; feedback: string } {
   if (!session.verdict) throw new DaemonError("pending", "session has no verdict");

package/src/capabilities.test.ts

@@ -19,6 +19,7 @@ describe("roleAllowsMethod", () => {
       "session.setWorkingCopy",
       "session.delete",
       "session.setShareId",
+      "session.refreshDiff",
     ])
       expect(roleAllowsMethod("agent", method)).toBe(false);
     expect(roleAllowsMethod("collaborator", "session.resolve")).toBe(false);

package/src/client.ts

@@ -215,6 +215,10 @@ export class DaemonClient implements SessionClient {
   sessionSetViewed(id: string, viewedPaths: string[]): Promise<ReviewSession> {
     return this.request("session.setViewed", { id, viewedPaths });
   }
+  /** Re-capture a diff session's working tree; changed=true when the patch moved and an event fired. */
+  sessionRefreshDiff(id: string): Promise<{ changed: boolean }> {
+    return this.request("session.refreshDiff", { id });
+  }
   sessionSetShareId(id: string, shareId: string): Promise<ReviewSession> {
     return this.request("session.setShareId", { id, shareId });
   }

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

@@ -0,0 +1,159 @@
+/**
+ * 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("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,99 @@
+/**
+ * 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 as FSWatcher & { on(event: "error", listener: (error: Error) => void): void }).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();
+  }
+}

package/src/server.ts

@@ -172,6 +172,7 @@ export class DaemonServer {
   }
 
   stop(): void {
+    this.core.dispose();
     this.server?.stop(true);
     this.server = null;
     rmSync(socketPath(this.home), { force: true });
@@ -275,6 +276,10 @@ export class DaemonServer {
         const params = parseParams("session.setViewed", request.params);
         return core.sessionSetViewed(params.id, params.viewedPaths);
       }
+      case "session.refreshDiff": {
+        const params = parseParams("session.refreshDiff", request.params);
+        return core.sessionRefreshDiff(params.id);
+      }
       case "session.setShareId": {
         const params = parseParams("session.setShareId", request.params);
         return core.sessionSetShareId(params.id, params.shareId);

package/src/validate.ts

@@ -133,6 +133,7 @@ export const Params = {
   "session.removeAnnotation": v.object({ id: SessionId, annotationId: NonEmpty }),
   "session.setWorkingCopy": v.object({ id: SessionId, workingCopy: v.optional(v.string()) }),
   "session.setViewed": v.object({ id: SessionId, viewedPaths: v.array(v.string()) }),
+  "session.refreshDiff": v.object({ id: SessionId }),
   "session.setShareId": v.object({ id: SessionId, shareId: NonEmpty }),
   "session.delete": v.object({ id: SessionId }),
   "session.mergeShared": v.object({

package/src/working-tree.ts

@@ -0,0 +1,100 @@
+/** Working-tree diff capture for `cueloop diff`, untracked files included. */
+
+import { join } from "node:path";
+import type { DiffFileContents } from "@cueloop/schema";
+
+async function git(args: string[], cwd: string): Promise<string | null> {
+  const gitProcess = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
+  const stdout = await new Response(gitProcess.stdout).text();
+  if ((await gitProcess.exited) !== 0) return null;
+  return stdout.trim();
+}
+
+/** The blob at HEAD for a path, or "" when the path is not in HEAD (new file). */
+async function headContents(path: string, cwd: string): Promise<string> {
+  const gitProcess = Bun.spawn(["git", "show", `HEAD:${path}`], {
+    cwd,
+    stdout: "pipe",
+    stderr: "ignore",
+  });
+  const stdout = await new Response(gitProcess.stdout).text();
+  return (await gitProcess.exited) === 0 ? stdout : "";
+}
+
+/** The working-tree file, or "" when it is gone (deleted). */
+async function workingContents(path: string, cwd: string): Promise<string> {
+  try {
+    return await Bun.file(join(cwd, path)).text();
+  } catch {
+    return "";
+  }
+}
+
+/** A NUL byte marks content git would treat as binary - not text-curatable. */
+function looksBinary(text: string): boolean {
+  for (let index = 0; index < text.length; index++) {
+    if (text.charCodeAt(index) === 0) return true;
+  }
+  return false;
+}
+
+/**
+ * Full old/new contents for every tracked change against HEAD, classified by
+ * git's own status letter. Renames/copies and binary files are omitted: a
+ * path+text pair cannot express a rename header or a binary blob, so curation
+ * would emit a patch that drops the old path or corrupts the file - leaving them
+ * out keeps those changes in the patch but simply not curatable. The
+ * NUL-delimited stream survives paths with spaces or unicode.
+ */
+async function trackedFileContents(cwd: string): Promise<DiffFileContents[]> {
+  const nameStatus = (await git(["diff", "HEAD", "--name-status", "-z"], cwd)) ?? "";
+  const tokens = nameStatus.split("\0").filter((token) => token.length > 0);
+  const files: DiffFileContents[] = [];
+  let cursor = 0;
+  while (cursor < tokens.length) {
+    const code = tokens[cursor++]![0];
+    if (code === "R" || code === "C") {
+      cursor += 2;
+      continue;
+    }
+    const path = tokens[cursor++]!;
+    const oldContents = code === "A" ? "" : await headContents(path, cwd);
+    const newContents = code === "D" ? "" : await workingContents(path, cwd);
+    if (looksBinary(oldContents) || looksBinary(newContents)) continue;
+    const status = code === "A" ? "added" : code === "D" ? "deleted" : "modified";
+    files.push({ path, oldContents, newContents, status });
+  }
+  return files;
+}
+
+export interface WorkingTreeDiff {
+  patch: string;
+  /** Full file contents per curatable changed file, keeping curation applyable. */
+  files: DiffFileContents[];
+}
+
+export async function workingTreeDiff(cwd = process.cwd()): Promise<WorkingTreeDiff> {
+  const tracked = (await git(["diff", "HEAD"], cwd)) ?? "";
+  const files = await trackedFileContents(cwd);
+  // untracked files included by default
+  const untrackedList = (await git(["ls-files", "--others", "--exclude-standard"], cwd)) ?? "";
+  let untracked = "";
+  for (const file of untrackedList.split("\n").filter(Boolean)) {
+    // `git diff --no-index` exits 1 when the files differ - that is success here
+    const gitProcess = Bun.spawn(["git", "diff", "--no-index", "--", "/dev/null", file], {
+      cwd,
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    const stdout = await new Response(gitProcess.stdout).text();
+    const code = await gitProcess.exited;
+    if ((code === 0 || code === 1) && stdout.trim()) {
+      untracked += stdout.trim() + "\n";
+      const newContents = await workingContents(file, cwd);
+      if (!looksBinary(newContents)) {
+        files.push({ path: file, oldContents: "", newContents, status: "added" });
+      }
+    }
+  }
+  return { patch: [tracked, untracked].filter(Boolean).join("\n"), files };
+}