@cueloop/daemon 0.1.0-alpha.89 → 0.1.0-alpha.90

package/src/jj-working-tree.ts

@@ -0,0 +1,131 @@
+/** Native Jujutsu capture pinned to one commit after its working-copy snapshot. */
+
+import type { DiffFileContents, DiffFileStatus } from "@cueloop/schema";
+import type { VcsAdapter, VcsDiffSnapshot } from "@cueloop/extension-api";
+
+async function jj(args: string[], cwd: string): Promise<string | null> {
+  try {
+    const child = Bun.spawn(["jj", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
+    const output = await new Response(child.stdout).text();
+
+    return (await child.exited) === 0 ? output : null;
+  } catch {
+    return null;
+  }
+}
+
+const JJ_DIFF_FILES_TEMPLATE = 'status_char ++ "\\x00" ++ path.display() ++ "\\x00"';
+const JJ_FILE_LIST_TEMPLATE = 'path.display() ++ "\\x00"';
+
+function jjSummary(text: string): { path: string; status: DiffFileStatus; curatable: boolean }[] {
+  const tokens = text.split("\0");
+  const changes: { path: string; status: DiffFileStatus; curatable: boolean }[] = [];
+
+  for (let index = 0; index + 1 < tokens.length; index += 2) {
+    const code = tokens[index];
+    const path = tokens[index + 1];
+
+    if (!code || !path) continue;
+    changes.push({
+      path,
+      status: code === "A" ? "added" : code === "D" ? "deleted" : "modified",
+      curatable: code === "A" || code === "M" || code === "D",
+    });
+  }
+
+  return changes;
+}
+
+function isBinary(contents: string): boolean {
+  return contents.includes("\0");
+}
+
+async function jjFileContents(
+  root: string,
+  revision: string,
+  path: string,
+): Promise<string | null> {
+  return jj(["--ignore-working-copy", "file", "show", "-r", revision, "--", path], root);
+}
+
+async function captureJjRevision(repoRoot: string, revset: string): Promise<VcsDiffSnapshot> {
+  const identity = await jj(
+    [
+      "log",
+      "-r",
+      revset,
+      "-T",
+      'change_id ++ "\\n" ++ commit_id ++ "\\n" ++ parents.map(|c| c.commit_id()).join(",") ++ "\\n"',
+      "--no-graph",
+    ],
+    repoRoot,
+  );
+
+  if (!identity) throw new Error(`Jujutsu diff capture failed: could not resolve ${revset}`);
+  const lines = identity.trim().split("\n");
+
+  if (lines.length !== 3) throw new Error(`Jujutsu change is ambiguous: ${revset}`);
+  const [changeId, revisionId, parents] = lines;
+
+  if (!changeId || !revisionId) throw new Error("Jujutsu diff capture failed: invalid identity");
+  const [patch, summary] = await Promise.all([
+    jj(["--ignore-working-copy", "diff", "--git", "-r", revisionId], repoRoot),
+    jj(["--ignore-working-copy", "diff", "-T", JJ_DIFF_FILES_TEMPLATE, "-r", revisionId], repoRoot),
+  ]);
+
+  if (patch === null || summary === null)
+    throw new Error("Jujutsu diff capture failed: could not read pinned revision");
+  const files: DiffFileContents[] = [];
+  const parent = parents?.split(",")[0];
+
+  if (parent && !parents?.includes(",")) {
+    for (const change of jjSummary(summary)) {
+      if (!change.curatable) continue;
+      const oldContents =
+        change.status === "added" ? "" : await jjFileContents(repoRoot, parent, change.path);
+      const newContents =
+        change.status === "deleted" ? "" : await jjFileContents(repoRoot, revisionId, change.path);
+
+      if (oldContents === null || newContents === null) continue;
+      if (isBinary(oldContents) || isBinary(newContents)) continue;
+      files.push({ path: change.path, oldContents, newContents, status: change.status });
+    }
+  }
+
+  return { patch: patch.replace(/\n+$/, ""), files, source: { changeId, revisionId } };
+}
+
+/** Built-in jj adapter uses native change and commit IDs in a colocated checkout. */
+export const jjVcsAdapter: VcsAdapter = {
+  apiVersion: 1,
+  id: "jj",
+  async detect(cwd) {
+    const root = await jj(["--ignore-working-copy", "root"], cwd);
+
+    return root?.trim() ?? null;
+  },
+  captureWorkingDiff(repoRoot) {
+    return captureJjRevision(repoRoot, "@");
+  },
+  async captureChange(repoRoot, changeId) {
+    if (!/^[a-z]{32}$/.test(changeId)) throw new Error(`Jujutsu change ID is invalid: ${changeId}`);
+    if ((await jj(["status"], repoRoot)) === null)
+      throw new Error("Jujutsu diff capture failed: could not snapshot the working copy");
+
+    return captureJjRevision(repoRoot, changeId);
+  },
+  async listChanges(repoRoot) {
+    const summary = await jj(["diff", "-T", JJ_DIFF_FILES_TEMPLATE, "-r", "@"], repoRoot);
+
+    if (summary === null) throw new Error("Jujutsu changes list failed");
+
+    return jjSummary(summary).map(({ path, status }) => ({ path, status }));
+  },
+  async listFiles(repoRoot) {
+    const files = await jj(["file", "list", "-T", JJ_FILE_LIST_TEMPLATE, "-r", "@"], repoRoot);
+
+    if (files === null) throw new Error("Jujutsu project files failed");
+
+    return files.split("\0").filter(Boolean).toSorted().slice(0, 5000);
+  },
+};

package/src/server.ts

@@ -450,8 +450,11 @@ export class DaemonServer {
     },
     "repo.changes": (_connection, request) =>
       this.core.repoChanges(parseParams("repo.changes", request.params).cwd),
-    "repo.diff": (_connection, request) =>
-      this.core.repoDiff(parseParams("repo.diff", request.params).cwd),
+    "repo.diff": (_connection, request) => {
+      const params = parseParams("repo.diff", request.params);
+
+      return this.core.repoDiff(params.cwd, params.vcs);
+    },
     "session.workbench": (_connection, request) =>
       this.core.workbenchSession(parseParams("session.workbench", request.params).cwd),
     "session.refreshDiff": (_connection, request) => {
@@ -535,6 +538,7 @@ export class DaemonServer {
         params.content,
         params.addressedAnnotationIds,
         params.files,
+        params.source,
       );
     },
     "herdr.getThreadSurface": (_connection, request) =>

package/src/thread-review.test.ts

@@ -1,13 +1,14 @@
 /** The shared review core against a real DaemonServer in a temp home: workspace resolution, title derivation, open-or-revise by agentSessionId, and both awaitMessage shapes (one long-poll and the chunked loop with progress and abort). */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { Thread } from "@cueloop/schema";
 import { DaemonServer } from "./server";
 import { DaemonClient } from "./client";
 import { awaitResolve, openReview, resolveWorkspace } from "./thread-review";
+import { VcsSourceManager } from "./vcs-source";
 
 const PLAN = "# Rollout Plan\n\nShip it in two stages.\n";
 
@@ -66,6 +67,94 @@ describe("resolveWorkspace", () => {
 });
 
 describe("openReview", () => {
+  test("a submitted JJ diff follows the same change through a rewrite", async () => {
+    const repo = mkdtempSync(join(tmpdir(), "cueloop-review-jj-"));
+
+    try {
+      sh(["git", "init", "-q", "-b", "main"], repo);
+      sh(["git", "config", "user.email", "t@t"], repo);
+      sh(["git", "config", "user.name", "t"], repo);
+      writeFileSync(join(repo, "a.txt"), "before\n");
+      sh(["git", "add", "a.txt"], repo);
+      sh(["git", "commit", "-qm", "initial"], repo);
+      sh(["jj", "git", "init", "--colocate", repo], repo);
+      writeFileSync(join(repo, "a.txt"), "first\n");
+      const sources = new VcsSourceManager(join(home, "vcs-config.toml"));
+      const firstDiff = await sources.capture(repo, "jj");
+      const first = await openReview(client, {
+        type: "diff",
+        content: firstDiff.patch,
+        cwd: repo,
+        vcs: "jj",
+        agent: "codex",
+        agentSessionId: "one-agent-session",
+      });
+
+      writeFileSync(join(repo, "a.txt"), "second\n");
+      const secondDiff = await sources.capture(repo, "jj");
+      const second = await openReview(client, {
+        type: "diff",
+        content: secondDiff.patch,
+        cwd: repo,
+        vcs: "jj",
+        agent: "codex",
+        agentSessionId: "one-agent-session",
+      });
+
+      expect(first.session.artifact.meta.vcs).toBe("jj");
+      expect(first.session.artifact.files?.[0]?.newContents).toBe("first\n");
+      expect(first.session.artifact.meta.vcsChangeId).toBe(
+        second.session.artifact.meta.vcsChangeId,
+      );
+      expect(second.id).toBe(first.id);
+      expect(second.session.revisions.map((revision) => revision.content)).toEqual([
+        firstDiff.patch,
+        secondDiff.patch,
+      ]);
+      const unmatched = await openReview(client, {
+        type: "diff",
+        content: "diff --git a/elsewhere b/elsewhere\n",
+        cwd: repo,
+        vcs: "jj",
+        agent: "codex",
+        agentSessionId: "one-agent-session",
+      });
+
+      expect(unmatched.id).toBe(first.id);
+      expect(unmatched.session.artifact.files).toEqual([]);
+      expect(unmatched.session.artifact.meta.vcsRevisionId).toBeUndefined();
+      sh(["jj", "new", "-m", "next change"], repo);
+      writeFileSync(join(repo, "b.txt"), "third\n");
+      const thirdDiff = await sources.capture(repo, "jj");
+      const third = await openReview(client, {
+        type: "diff",
+        content: thirdDiff.patch,
+        cwd: repo,
+        vcs: "jj",
+        agent: "codex",
+        agentSessionId: "one-agent-session",
+      });
+
+      expect(third.id).not.toBe(first.id);
+      const unmatchedAfterTwoChanges = await openReview(client, {
+        type: "diff",
+        content: "diff --git a/unmatched b/unmatched\n",
+        cwd: repo,
+        vcs: "jj",
+        agent: "codex",
+        agentSessionId: "one-agent-session",
+      });
+
+      expect(unmatchedAfterTwoChanges.id).not.toBe(first.id);
+      expect(unmatchedAfterTwoChanges.id).not.toBe(third.id);
+      expect((await client.sessionGet(third.id)).artifact.meta.vcsChangeId).toBe(
+        third.session.artifact.meta.vcsChangeId,
+      );
+    } finally {
+      rmSync(repo, { recursive: true, force: true });
+    }
+  });
+
   test("shapes the artifact: agent, derived title, cwd", async () => {
     // Act
     const review = await openReview(client, {

package/src/thread-review.ts

@@ -5,6 +5,7 @@ import {
   type Artifact,
   type ArtifactType,
   type DiffFileContents,
+  type DiffSource,
   type Thread,
   type WorkspaceKey,
   type WorkflowKind,
@@ -13,6 +14,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { messageResponse } from "./api";
 import { ABORTED, pollUntilResolved, raceAbort } from "./interruptible-wait";
+import { VcsSourceManager } from "./vcs-source";
 
 // Adapters and CLI primitives reach the message mapping through this module too,
 // so a session obtained outside a ReviewHandle maps the same way.
@@ -28,6 +30,16 @@ async function git(args: string[], cwd: string): Promise<string | null> {
   }
 }
 
+async function jjRoot(cwd: string): Promise<string | null> {
+  try {
+    const { stdout } = await promisify(execFile)("jj", ["--ignore-working-copy", "root"], { cwd });
+
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+
 /** The oldest root commit reachable from HEAD; the project key that survives moving or re-cloning the repo. */
 function earliestRootCommit(revList: string | null): string | undefined {
   if (!revList) return undefined;
@@ -39,15 +51,22 @@ function earliestRootCommit(revList: string | null): string | undefined {
 
 /** Workspace key resolution: repo root, branch, and the project identity (root commit + remote) from the cwd. */
 export async function resolveWorkspace(cwd = process.cwd()): Promise<WorkspaceKey> {
-  const repoRoot = (await git(["rev-parse", "--show-toplevel"], cwd)) ?? cwd;
-  const branch = (await git(["rev-parse", "--abbrev-ref", "HEAD"], cwd)) ?? "detached";
+  const gitRepoRoot = await git(["rev-parse", "--show-toplevel"], cwd);
+  const jjRepoRoot = await jjRoot(cwd);
+  const nativeJjRoot =
+    jjRepoRoot && (!gitRepoRoot || jjRepoRoot.length > gitRepoRoot.length) ? jjRepoRoot : null;
+  const repoRoot = nativeJjRoot ?? gitRepoRoot ?? cwd;
+  const branch = nativeJjRoot
+    ? "jj"
+    : ((await git(["rev-parse", "--abbrev-ref", "HEAD"], cwd)) ?? "detached");
   // a shallow clone's oldest commit is the graft boundary, not the true root, so
   // it would key a different project than a full clone - leave it unset instead
-  const shallow = (await git(["rev-parse", "--is-shallow-repository"], cwd)) === "true";
+  const shallow =
+    nativeJjRoot !== null || (await git(["rev-parse", "--is-shallow-repository"], cwd)) === "true";
   const rootCommit = shallow
     ? undefined
     : earliestRootCommit(await git(["rev-list", "--max-parents=0", "--date-order", "HEAD"], cwd));
-  const remote = await git(["remote", "get-url", "origin"], cwd);
+  const remote = nativeJjRoot ? null : await git(["remote", "get-url", "origin"], cwd);
 
   const workspace: WorkspaceKey = { repoRoot, branch };
   // a repo with no commits (or a shallow clone) has no reliable root, so the thread stays standalone
@@ -70,6 +89,10 @@ export interface OpenReviewOptions {
   content: string;
   /** Workspace resolution root and meta.cwd; defaults to process.cwd(). */
   cwd?: string;
+  /** Optional explicit VCS selection for a diff that matches the checkout capture. */
+  vcs?: string;
+  /** The native logical change, set after a captured JJ diff is verified. */
+  vcsChangeId?: string;
   /** Pre-resolved workspace key; skips git resolution when the caller already has it. */
   workspace?: WorkspaceKey;
   agent?: string;
@@ -114,6 +137,7 @@ export interface ThreadSessionClient {
     content: string,
     addressedAnnotationIds?: string[],
     files?: DiffFileContents[],
+    source?: DiffSource,
   ): Promise<Thread>;
   sessionAnnotate(
     id: string,
@@ -249,7 +273,11 @@ export async function findExistingReview(
 
   if (options.agentSessionId === undefined) return undefined;
 
-  return (await client.sessionList()).find(
+  const isJjDiff = options.type === "diff" && options.vcs === "jj";
+  const hasJjProvenance = (candidate: Thread): boolean =>
+    candidate.artifact.meta.vcs === "jj" ||
+    candidate.revisions.some((revision) => revision.source?.vcs === "jj");
+  const candidates = (await client.sessionList()).filter(
     (candidate) =>
       candidate.artifact.meta.agentSessionId === options.agentSessionId &&
       candidate.artifact.meta.agent === options.agent &&
@@ -259,8 +287,47 @@ export async function findExistingReview(
         (options.workflow ?? (options.pr ? "review" : options.type)) &&
       candidate.artifact.meta.pr === options.pr &&
       candidate.workspace.repoRoot === workspace.repoRoot &&
-      candidate.workspace.branch === workspace.branch,
+      (candidate.workspace.branch === workspace.branch || (isJjDiff && hasJjProvenance(candidate))),
   );
+
+  if (options.vcsChangeId !== undefined)
+    return candidates.find(
+      (candidate) => candidate.artifact.meta.vcsChangeId === options.vcsChangeId,
+    );
+  if (isJjDiff) {
+    const jjCandidates = candidates.filter(hasJjProvenance);
+
+    // An unmatched patch has no verified change ID. Reuse the Thread only when
+    // there is exactly one possible JJ change in this agent session.
+    return jjCandidates.length === 1 ? jjCandidates[0] : undefined;
+  }
+
+  return candidates.find((candidate) => candidate.artifact.meta.vcsChangeId === undefined);
+}
+
+/** Attach VCS provenance only when the submitted patch matches a native capture. */
+async function matchingDiffCapture(
+  options: OpenReviewOptions,
+  cwd: string,
+): Promise<{ source?: DiffSource; files?: DiffFileContents[] }> {
+  if (options.type !== "diff" || options.pr || !options.content.trim()) return {};
+  try {
+    const captured = await new VcsSourceManager().capture(cwd, options.vcs);
+
+    if (captured.patch.replace(/\n+$/, "") !== options.content.replace(/\n+$/, "")) return {};
+
+    return {
+      source: {
+        vcs: captured.vcs,
+        changeId: captured.source?.changeId,
+        revisionId: captured.source?.revisionId,
+      },
+      files: captured.files,
+    };
+  } catch {
+    // A supplied patch stays reviewable even when the local source is unavailable.
+    return {};
+  }
 }
 
 /** Open a thread (or revise the agent session's existing one) and hand back the wait surface. */
@@ -270,17 +337,23 @@ export async function openReview(
 ): Promise<ReviewHandle> {
   const cwd = options.cwd ?? process.cwd();
   const workspace = options.workspace ?? (await resolveWorkspace(cwd));
-  const existing = await findExistingReview(client, options);
+  const { source, files: capturedFiles } = await matchingDiffCapture(options, cwd);
+  const existing = await findExistingReview(client, {
+    ...options,
+    vcsChangeId: source?.changeId,
+  });
 
   if (existing !== undefined) {
     // PR diffs have no full file contents. An absent local-diff capture clears
     // old curatable files, while a PR revision must keep curation disabled.
-    const revisionFiles = options.type !== "diff" || options.pr ? undefined : (options.files ?? []);
+    const revisionFiles =
+      options.type !== "diff" || options.pr ? undefined : (options.files ?? capturedFiles ?? []);
     let revised = await client.sessionSubmitRevision(
       existing.id,
       options.content,
       [],
       revisionFiles,
+      source,
     );
 
     if (options.notes?.length) {
@@ -293,7 +366,7 @@ export async function openReview(
   let session = await client.sessionCreate(workspace, {
     type: options.type,
     content: options.content,
-    files: options.files,
+    files: options.files ?? capturedFiles,
     meta: {
       workflow: options.workflow,
       agent: options.agent,
@@ -310,6 +383,9 @@ export async function openReview(
         options.title ??
         (isMarkdownArtifact(options.type) ? firstHeading(options.content) : undefined),
       cwd,
+      vcs: source?.vcs,
+      vcsChangeId: source?.changeId,
+      vcsRevisionId: source?.revisionId,
     },
   });
 

package/src/validate.test.ts

@@ -205,6 +205,9 @@ describe("wire pins", () => {
   const fullMeta: Required<ArtifactMeta> = {
     workflow: "plan",
     cwd: "/repo",
+    vcs: "jj",
+    vcsChangeId: "change",
+    vcsRevisionId: "revision",
     agent: "claude-code",
     agentSessionId: "sess-1",
     planPath: "/repo/plan.md",
@@ -268,7 +271,13 @@ describe("wire pins", () => {
     annotations: [fullAnnotation],
     sentAt: "now",
   };
-  const fullRevision: Required<Revision> = { revision: 1, content: "# P", submittedAt: "now" };
+  const fullRevision: Required<Revision> = {
+    revision: 1,
+    content: "# P",
+    submittedAt: "now",
+    source: { vcs: "jj", changeId: "change", revisionId: "revision" },
+    files: [{ path: "a.ts", oldContents: "a", newContents: "b", status: "modified" }],
+  };
   const fullWorkspace: Required<WorkspaceKey> = {
     repoRoot: "/repo",
     branch: "main",

package/src/validate.ts

@@ -82,6 +82,9 @@ export const WorkspaceSchema = v.object({
 export const ArtifactMetaSchema = v.object({
   workflow: v.optional(v.picklist(WORKFLOW_KINDS)),
   cwd: v.optional(v.string()),
+  vcs: v.optional(NonEmpty),
+  vcsChangeId: v.optional(NonEmpty),
+  vcsRevisionId: v.optional(NonEmpty),
   agent: v.optional(v.string()),
   agentSessionId: v.optional(v.string()),
   planPath: v.optional(v.string()),
@@ -270,7 +273,7 @@ export const Params = {
   "repo.files": v.object({ cwd: NonEmpty }),
   "repo.fileContents": v.object({ cwd: NonEmpty, path: NonEmpty }),
   "repo.changes": v.object({ cwd: NonEmpty }),
-  "repo.diff": v.object({ cwd: NonEmpty }),
+  "repo.diff": v.object({ cwd: NonEmpty, vcs: v.optional(NonEmpty) }),
   "session.workbench": v.object({ cwd: NonEmpty }),
   "session.navigate": v.object({
     id: SessionId,
@@ -321,6 +324,14 @@ export const Params = {
     id: SessionId,
     content: v.string(),
     files: v.optional(v.array(DiffFileContentsSchema)),
+    source: v.optional(
+      v.object({
+        vcs: NonEmpty,
+        changeId: v.optional(NonEmpty),
+        revisionId: v.optional(NonEmpty),
+        baseRevisionId: v.optional(NonEmpty),
+      }),
+    ),
     /** Annotation ids the agent acted on; each is marked addressed. */
     addressedAnnotationIds: v.optional(v.array(NonEmpty), []),
   }),
@@ -379,6 +390,15 @@ export const RevisionSchema = v.object({
   revision: v.number(),
   content: v.string(),
   submittedAt: v.string(),
+  files: v.optional(v.array(DiffFileContentsSchema)),
+  source: v.optional(
+    v.object({
+      vcs: NonEmpty,
+      changeId: v.optional(NonEmpty),
+      revisionId: v.optional(NonEmpty),
+      baseRevisionId: v.optional(NonEmpty),
+    }),
+  ),
 } satisfies EntriesOf<Revision>);
 
 export const MessageSchema = v.object({