@cueloop/daemon 0.1.0-alpha.93 → 0.1.0-alpha.95

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/daemon",
-  "version": "0.1.0-alpha.93",
+  "version": "0.1.0-alpha.95",
   "description": "The cueloop session daemon and its client: socket protocol, atomic store, resumable waits",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -39,8 +39,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/extension-api": "0.1.0-alpha.93",
-    "@cueloop/schema": "0.1.0-alpha.93",
+    "@cueloop/extension-api": "0.1.0-alpha.95",
+    "@cueloop/schema": "0.1.0-alpha.95",
     "@pierre/diffs": "^1.4.1",
     "effect": "^4.0.0-rc.116",
     "smol-toml": "^1.8.0",

package/src/api.ts

@@ -142,7 +142,10 @@ export class DaemonCore {
    */
   private readonly diffRefreshGenerations = new Map<string, number>();
   /** In-flight workbench creations keyed by project, so concurrent bare launches share one thread. */
-  private readonly workbenchCreation = new Map<string, Promise<Thread>>();
+  private readonly workbenchCreation = new Map<
+    string,
+    Promise<{ session: Thread; diff: VcsDiffSnapshot & { vcs: string } }>
+  >();
 
   constructor(home: string) {
     this.store = new ThreadStore(home);
@@ -618,8 +621,35 @@ export class DaemonCore {
    * first comment without an agent submission. Owner-only.
    */
   async workbenchSession(cwd: string): Promise<Thread> {
-    const selected = await this.vcsSources.select(cwd);
-    const workspace = await resolveWorkspace(cwd);
+    const opened = await this.openWorkbench(cwd);
+
+    return opened.session;
+  }
+
+  /** Return the workbench and its current diff from one capture. */
+  async workbenchReview(
+    cwd: string,
+  ): Promise<{ session: Thread; diff: VcsDiffSnapshot & { vcs: string } }> {
+    const opened = await this.openWorkbench(cwd);
+
+    if (opened.diff) return { session: opened.session, diff: opened.diff };
+
+    return {
+      session: opened.session,
+      diff: await this.vcsSources.capture(
+        opened.session.workspace.repoRoot,
+        opened.session.artifact.meta.vcs,
+      ),
+    };
+  }
+
+  private async openWorkbench(
+    cwd: string,
+  ): Promise<{ session: Thread; diff?: VcsDiffSnapshot & { vcs: string } }> {
+    const [selected, workspace] = await Promise.all([
+      this.vcsSources.select(cwd),
+      resolveWorkspace(cwd),
+    ]);
     workspace.repoRoot = selected.repoRoot;
     const key = `${workspace.rootCommit ?? selected.repoRoot}:${selected.adapter.id}`;
     // an open workbench is reused; a resolved one is immutable and would reject the note, so a fresh
@@ -635,13 +665,13 @@ export class DaemonCore {
           (session.artifact.meta.vcs ?? "git") === selected.adapter.id,
       );
 
-    if (open) return open;
+    if (open) return { session: open };
     // serialize concurrent bare launches for the same repo onto one creation, so they share a thread
     const inFlight = this.workbenchCreation.get(key);
 
     if (inFlight) return inFlight;
-    const creation = this.vcsSources.capture(cwd, selected.adapter.id).then((diff) =>
-      this.sessionCreate({
+    const creation = this.vcsSources.capture(cwd, selected.adapter.id).then((diff) => ({
+      session: this.sessionCreate({
         workspace,
         artifact: {
           type: "diff",
@@ -657,7 +687,8 @@ export class DaemonCore {
           },
         },
       }),
-    );
+      diff,
+    }));
 
     this.workbenchCreation.set(key, creation);
     try {

package/src/capabilities.ts

@@ -47,6 +47,7 @@ const PRIMITIVE_ROLES = {
   "repo.changes": "owner",
   "repo.diff": "owner",
   "session.workbench": "owner",
+  "session.workbenchReview": "owner",
   // the tree is the owner's: collaborators comment on the branch a share follows
   "session.navigate": "owner",
   "session.branch": "owner",

package/src/client.ts

@@ -595,6 +595,24 @@ export class DaemonClient implements ThreadClient {
   sessionWorkbench(cwd: string): Promise<Thread> {
     return this.request("session.workbench", { cwd }, ThreadRecordSchema);
   }
+  /** Open a workbench with the diff snapshot used for its first frame. */
+  workbenchReview(cwd: string): Promise<{ session: Thread; diff: WorkingTreeDiff }> {
+    return this.request(
+      "session.workbenchReview",
+      { cwd },
+      v.object({
+        session: ThreadRecordSchema,
+        diff: v.object({
+          patch: v.string(),
+          files: v.array(DiffFileContentsSchema),
+          vcs: v.string(),
+          source: v.optional(
+            v.object({ changeId: v.optional(v.string()), revisionId: v.string() }),
+          ),
+        }),
+      }),
+    );
+  }
   /** 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 }, RefreshDiffResultSchema);

package/src/server.ts

@@ -457,6 +457,8 @@ export class DaemonServer {
     },
     "session.workbench": (_connection, request) =>
       this.core.workbenchSession(parseParams("session.workbench", request.params).cwd),
+    "session.workbenchReview": (_connection, request) =>
+      this.core.workbenchReview(parseParams("session.workbenchReview", request.params).cwd),
     "session.refreshDiff": (_connection, request) => {
       const params = parseParams("session.refreshDiff", request.params);
 

package/src/thread-review.ts

@@ -51,22 +51,27 @@ 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 gitRepoRoot = await git(["rev-parse", "--show-toplevel"], cwd);
-  const jjRepoRoot = await jjRoot(cwd);
+  const [gitRepoRoot, jjRepoRoot] = await Promise.all([
+    git(["rev-parse", "--show-toplevel"], cwd),
+    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");
+  const [gitBranch, isShallow, rootList, gitRemote] = nativeJjRoot
+    ? [null, null, null, null]
+    : await Promise.all([
+        git(["rev-parse", "--abbrev-ref", "HEAD"], cwd),
+        git(["rev-parse", "--is-shallow-repository"], cwd),
+        git(["rev-list", "--max-parents=0", "--date-order", "HEAD"], cwd),
+        git(["remote", "get-url", "origin"], cwd),
+      ]);
+  const branch = nativeJjRoot ? "jj" : (gitBranch ?? "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 =
-    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 = nativeJjRoot ? null : await git(["remote", "get-url", "origin"], cwd);
+  const shallow = nativeJjRoot !== null || isShallow === "true";
+  const rootCommit = shallow ? undefined : earliestRootCommit(rootList);
+  const remote = nativeJjRoot ? null : gitRemote;
 
   const workspace: WorkspaceKey = { repoRoot, branch };
   // a repo with no commits (or a shallow clone) has no reliable root, so the thread stays standalone

package/src/validate.ts

@@ -275,6 +275,7 @@ export const Params = {
   "repo.changes": v.object({ cwd: NonEmpty }),
   "repo.diff": v.object({ cwd: NonEmpty, vcs: v.optional(NonEmpty) }),
   "session.workbench": v.object({ cwd: NonEmpty }),
+  "session.workbenchReview": v.object({ cwd: NonEmpty }),
   "session.navigate": v.object({
     id: SessionId,
     entryId: NonEmpty,