@cueloop/client 0.1.0-alpha.97 → 0.1.0-alpha.99

package/src/thread/thread-controller.ts

@@ -324,6 +324,8 @@ export interface ReviewController {
   refreshDiff(): Promise<void>;
   /** Open a session from the inbox. */
   open(id: string): void;
+  /** Create and open an empty local Thread for a new conversation. */
+  createEmptyThread(): Promise<void>;
   /** Delete a session for good (inbox delete); the inbox refreshes on the event. */
   deleteSession(id: string): void;
   /** Rename a session's title; the inbox refreshes on the event. */
@@ -386,6 +388,7 @@ export interface ReviewController {
   annotatePrototype(selector: string, quote: string, body: string): string | undefined;
   /** Rewrite a stored annotation's body in place (the rail-card edit). */
   updateAnnotation(id: string, body: string): void;
+  flushMutations?(): Promise<void>;
   removeAnnotation(id: string): void;
   setWorkingCopy(content: string | undefined): void;
   /** Enter the guided walk at the first unviewed file (diff sessions). */
@@ -472,6 +475,7 @@ const DERIVED_CACHE_LIMIT = 8;
 class Controller implements ReviewController {
   readonly readOnly: boolean;
   private client: ThreadClient | null = null;
+  private pendingMutations = new Set<Promise<Thread>>();
   private closed = false;
   /** The controller's state lives in a zustand store; internal reads go through the snapshot getter. */
   private readonly store: StoreApi<ControllerSnapshot> = createStore<ControllerSnapshot>(() => ({
@@ -825,6 +829,7 @@ class Controller implements ReviewController {
 
   async projectFiles(): Promise<string[]> {
     const session = this.snapshot.session;
+
     if (this.client?.projectFiles === undefined || !session) return [];
 
     return this.client.projectFiles(session.id);
@@ -832,6 +837,7 @@ class Controller implements ReviewController {
 
   async readFile(path: string): Promise<string | null> {
     const session = this.snapshot.session;
+
     if (this.client?.fileContents === undefined || !session) return null;
 
     return this.client.fileContents(session.id, path);
@@ -857,6 +863,7 @@ class Controller implements ReviewController {
   async repoChanges(): Promise<readonly DiffFileContents[]> {
     // a plain diff review pins its captured snapshot; a workbench thread and every other thread reflect the live working tree
     const session = this.snapshot.session;
+
     if (readsFrozenDiff(session)) return session!.artifact.files ?? [];
     const initialFiles = this.consumeInitialDiffFiles(session);
 
@@ -867,6 +874,7 @@ class Controller implements ReviewController {
         this.sidebarRepoRoot(),
         session?.artifact.meta.workbench ? (session.artifact.meta.vcs ?? "git") : undefined,
       );
+
       // a thread switch during the request would let this response overwrite the new thread's diff,
       // showing changes from the wrong repo; compare the thread id, not the object, so an unrelated
       // re-render that replaced the snapshot for the SAME thread does not drop its diff to "No changes"
@@ -881,6 +889,7 @@ class Controller implements ReviewController {
             file.oldContents !== diff.files[index]?.oldContents ||
             file.newContents !== diff.files[index]?.newContents,
         );
+
       if (changed) {
         this.liveDiff = diff;
         // rows() derive from the fresh patch; re-render so an open diff tab repaints
@@ -956,7 +965,14 @@ class Controller implements ReviewController {
    * builds on the first instead of on the stale snapshot. Answers arrive in
    * request order over the socket and replace the guess with the daemon's copy.
    */
+  /** Agent invocation waits until the preceding comments reach the daemon. */
+  async flushMutations(): Promise<void> {
+    await Promise.all(this.pendingMutations);
+  }
+
   private applyOptimistic(expected: Thread, mutation: Promise<Thread>): void {
+    this.pendingMutations.add(mutation);
+    void mutation.finally(() => this.pendingMutations.delete(mutation)).catch(() => {});
     this.update({ session: expected });
     mutation
       .then((session) => this.update({ session }))
@@ -980,6 +996,30 @@ class Controller implements ReviewController {
     void this.refreshSession(id);
   }
 
+  async createEmptyThread(): Promise<void> {
+    if (this.readOnly || !this.client?.sessionCreate) return;
+    const workspace = this.snapshot.session?.workspace ?? {
+      repoRoot: this.options.cwd ?? process.cwd(),
+      branch: "detached",
+    };
+
+    try {
+      const thread = await this.client.sessionCreate(workspace, {
+        type: "plan",
+        content: "",
+        meta: { title: "New Thread" },
+      });
+
+      this.locallyViewed.clear();
+      this.viewingId = thread.id;
+      this.update({ session: thread });
+    } catch (cause) {
+      this.setStatus(
+        `New Thread failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+      );
+    }
+  }
+
   deleteSession(id: string): void {
     if (this.readOnly) return this.setStatus("observer - read-only");
     // a deleted thread's links must not outlive it; revoke every one first, best-effort, so an
@@ -1703,6 +1743,7 @@ class Controller implements ReviewController {
     const actionBodies = Object.fromEntries(
       slashItemsFrom(this.quickActions).map((item) => [item.name, item.body]),
     );
+
     this.client!.sessionSendMessage(session.id, message, summary, actionBodies)
       .then((resolved) => {
         // The completion overlay heading already states the message, so the
@@ -1801,6 +1842,7 @@ class Controller implements ReviewController {
 
     if (!links.some((link) => link.id === id)) return;
     const allowlist = input.requireAuth ? input.allowlist : [];
+
     // re-push the link's access to its blob: an allowlist for private, "public" clears it
     void this.shareTransport
       .push(id, [], input.requireAuth ? { githubLogins: allowlist } : "public")

package/src/thread/use-thread-agent.test.tsx

@@ -0,0 +1,208 @@
+import React, { useEffect } from "react";
+import { expect, test } from "bun:test";
+import { testRender } from "@opentui/react/test-utils";
+import type { ThreadAgentState } from "@cueloop/schema";
+import { useThreadAgent, type ThreadAgentClient } from "./use-thread-agent";
+import { waitForText, settle } from "../testing/test-support";
+
+const initial: ThreadAgentState = {
+  threadId: "test",
+  phase: { kind: "idle" },
+  messages: [],
+  tools: [],
+  comments: [],
+};
+
+test("late configuration and action responses cannot replace a newer accepted state", async () => {
+  let state = initial;
+  let configure: ((value: ThreadAgentState) => void) | undefined;
+  let first: ((value: ThreadAgentState) => void) | undefined;
+  let request = async () => false;
+  let calls = 0;
+  const client: ThreadAgentClient = {
+    agentGet: async () => state,
+    agentConfigure: async () =>
+      new Promise((resolve) => {
+        configure = resolve;
+      }),
+    agentPrompt: async () => {
+      if (++calls === 1)
+        return new Promise((resolve) => {
+          first = resolve;
+        });
+      state = { ...initial, phase: { kind: "running" } };
+
+      return state;
+    },
+    agentCancel: async () => state,
+    agentComment: async () => state,
+    agentPermission: async () => state,
+  };
+
+  function TestAgent(): React.ReactNode {
+    const agent = useThreadAgent("test", undefined, client);
+
+    useEffect(() => {
+      request = () => agent.act((api) => api.agentPrompt({ id: "test", text: "Prompt" }));
+    }, [agent]);
+
+    return <text>{agent.state.phase.kind}</text>;
+  }
+  const setup = await testRender(<TestAgent />, { width: 40, height: 4 });
+
+  try {
+    await waitForText(setup, "idle");
+    const pending = request();
+
+    await request();
+    await waitForText(setup, "running");
+    first!(initial);
+    await pending;
+    configure!(initial);
+    await settle(setup);
+    expect(setup.captureCharFrame()).toContain("running");
+    expect(setup.captureCharFrame()).not.toContain("idle");
+  } finally {
+    setup.renderer.destroy();
+  }
+});
+
+test("production subscription shows daemon updates and reconnects without an injected client", async () => {
+  const { mkdtempSync, rmSync } = await import("node:fs");
+  const { tmpdir } = await import("node:os");
+  const { join } = await import("node:path");
+  const { DaemonServer } = await import("@cueloop/daemon");
+  const { DaemonClient } = await import("@cueloop/daemon/client");
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-ui-subscription-"));
+  const adapter = {
+    id: "ui-subscription",
+    label: "UI subscription",
+    connect({ onEvent }: Parameters<import("@cueloop/schema").AgentHarnessAdapter["connect"]>[0]) {
+      return {
+        start: async () => "ui-session",
+        prompt: async () => {
+          onEvent({ kind: "message" as const, id: "answer", text: "Updated answer" });
+
+          return { outcome: "completed" as const };
+        },
+        cancel() {},
+        permission() {},
+        close() {},
+      };
+    },
+  };
+  const options = { home, idleExitMs: 0, threadAgent: { enabled: true, adapter } };
+  let server = new DaemonServer(options);
+
+  server.start();
+  const client = await DaemonClient.connect({ home });
+  const thread = await client.sessionCreate(
+    { repoRoot: home, branch: "main" },
+    { type: "plan", content: "Watch this", meta: {} },
+  );
+
+  function TestAgentSubscription(): React.ReactNode {
+    const agent = useThreadAgent(thread.id, home);
+
+    return (
+      <text>
+        {agent.client ? "Connected " : "Connecting "}
+        {agent.state.messages.map((message) => message.text).join(" ")}
+        {agent.error}
+      </text>
+    );
+  }
+  const setup = await testRender(<TestAgentSubscription />, { width: 80, height: 4 });
+
+  try {
+    await waitForText(setup, "Connected");
+    await client.agentPrompt({ id: thread.id, text: "Question" });
+    await waitForText(setup, "Updated answer");
+    server.stop();
+    server = new DaemonServer(options);
+    server.start();
+    const resumed = await DaemonClient.connect({ home });
+
+    try {
+      await resumed.agentPrompt({ id: thread.id, text: "Continuation" });
+    } finally {
+      resumed.close();
+    }
+    await waitForText(setup, "Continuation");
+    expect(setup.captureCharFrame()).toContain("Updated answer");
+  } finally {
+    setup.renderer.destroy();
+    client.close();
+    server.stop();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("reconnecting during a running turn preserves state without a configuration error", async () => {
+  const { mkdtempSync, rmSync } = await import("node:fs");
+  const { tmpdir } = await import("node:os");
+  const { join } = await import("node:path");
+  const { DaemonServer } = await import("@cueloop/daemon");
+  const { DaemonClient } = await import("@cueloop/daemon/client");
+  const { createTestSdkHarness } = await import("../../../../test/helpers/sdk-harness");
+  const home = mkdtempSync(join(tmpdir(), "cueloop-agent-ui-running-"));
+  const harness = createTestSdkHarness();
+  const server = new DaemonServer({
+    home,
+    idleExitMs: 0,
+    threadAgent: { enabled: true, adapter: harness.adapter },
+  });
+
+  server.start();
+  const client = await DaemonClient.connect({ home });
+  const thread = await client.sessionCreate(
+    { repoRoot: home, branch: "main" },
+    { type: "plan", content: "Watch this", meta: {} },
+  );
+  let connection: InstanceType<typeof DaemonClient> | undefined;
+  let connections = 0;
+
+  function TestRunningSubscription(): React.ReactNode {
+    const agent = useThreadAgent(thread.id, home);
+
+    useEffect(() => {
+      if (agent.client instanceof DaemonClient && agent.client !== connection) {
+        connection = agent.client;
+        connections++;
+      }
+    }, [agent.client]);
+
+    return (
+      <text>
+        {connections} {agent.state.phase.kind} {agent.error || "No error"}
+      </text>
+    );
+  }
+  const setup = await testRender(<TestRunningSubscription />, { width: 100, height: 4 });
+
+  try {
+    await waitForText(setup, "idle");
+    await client.agentPrompt({ id: thread.id, text: "Question" });
+    await waitForText(setup, "running");
+    expect((await client.agentConfigure({ id: thread.id })).phase.kind).toBe("running");
+    const rejected = await client
+      .agentConfigure({ id: thread.id, configId: "model", value: "other" })
+      .catch((error: Error) => error);
+
+    expect(rejected).toMatchObject({
+      code: "internal",
+      message: "Thread agent configuration waits for the current turn",
+    });
+    connection!.close();
+    await waitForText(setup, "2 running");
+    harness.complete();
+    await waitForText(setup, "2 idle");
+    expect(setup.captureCharFrame()).toContain("No error");
+    expect(setup.captureCharFrame()).not.toContain("configuration waits");
+  } finally {
+    setup.renderer.destroy();
+    client.close();
+    server.stop();
+    rmSync(home, { recursive: true, force: true });
+  }
+});

package/src/thread/use-thread-agent.ts

@@ -0,0 +1,111 @@
+import { useEffect, useRef, useState } from "react";
+import { subscribeThreadState, connectThreadObserver } from "@cueloop/daemon/thread-subscription";
+import { DaemonClient } from "@cueloop/daemon/client";
+import type { ThreadAgentState } from "@cueloop/schema";
+
+/** Agent transport is injectable for frame tests; production uses the daemon socket. */
+export type ThreadAgentClient = Pick<
+  DaemonClient,
+  "agentGet" | "agentPrompt" | "agentCancel" | "agentComment" | "agentPermission"
+> &
+  Partial<Pick<DaemonClient, "agentConfigure">>;
+
+/** Subscribe to durable agent state; unmount closes only this client connection. */
+export function useThreadAgent(id: string, home?: string, injected?: ThreadAgentClient) {
+  const [client, setClient] = useState<ThreadAgentClient | null>(injected ?? null);
+  const [state, setState] = useState<ThreadAgentState>({
+    threadId: id,
+    phase: { kind: "idle" },
+    messages: [],
+    tools: [],
+    comments: [],
+  });
+  const revision = useRef(0);
+  const [error, setError] = useState("");
+
+  useEffect(() => {
+    let cancelled = false;
+    let connection: DaemonClient | undefined;
+    let unsubscribe: (() => void) | undefined;
+
+    revision.current++;
+    const refresh = async (api: ThreadAgentClient) => {
+      const requested = ++revision.current;
+      const result = await api.agentGet(id);
+
+      if (!cancelled && requested === revision.current) setState(result);
+    };
+
+    const configure = async (api: ThreadAgentClient): Promise<void> => {
+      if (!api.agentConfigure) return;
+      const requested = ++revision.current;
+      const configured = await api.agentConfigure({ id });
+
+      if (!cancelled && requested === revision.current) setState(configured);
+      await refresh(api);
+    };
+
+    void (async () => {
+      try {
+        if (injected) {
+          await refresh(injected);
+          await configure(injected);
+
+          return;
+        }
+        unsubscribe = subscribeThreadState({
+          connect: connectThreadObserver({ home, autostart: true }),
+          matches: (event) => event.event === "agent.updated" && event.sessionId === id,
+          read: async (api, signal) => {
+            const requested = ++revision.current;
+            const state = await api.agentGet(id, { signal });
+
+            return { state, requested };
+          },
+          onConnect: (api) => {
+            connection = api;
+            setClient(api);
+            void configure(api).catch((error) => {
+              if (!cancelled) setError(String(error));
+            });
+          },
+          onValue: ({ state, requested }) => {
+            if (!cancelled && requested === revision.current) setState(state);
+          },
+          onError: (error) => {
+            if (!cancelled) setError(String(error));
+          },
+        });
+      } catch (error) {
+        if (!cancelled) setError(error instanceof Error ? error.message : String(error));
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+      unsubscribe?.();
+      connection?.close();
+    };
+  }, [id, home, injected]);
+
+  const act = async (
+    request: (client: ThreadAgentClient) => Promise<ThreadAgentState>,
+  ): Promise<boolean> => {
+    if (!client) return false;
+    try {
+      const requested = ++revision.current;
+      const result = await request(client);
+
+      if (requested === revision.current) setState(result);
+      setError("");
+
+      return true;
+    } catch (error) {
+      setError(error instanceof Error ? error.message : String(error));
+
+      return false;
+    }
+  };
+
+  return { state, client, error, setError, act };
+}

package/src/ui/components/PromptDialog.test.tsx

@@ -21,6 +21,7 @@ test("the input is focused on open, so typing lands in the dialog", async () =>
     />,
     { width: 60, height: 12 },
   );
+
   await settle(setup);
 
   await typeText(setup, "!");
@@ -45,14 +46,17 @@ test("clicking save fires onSave and clicking cancel fires onCancel", async () =
     />,
     { width: 60, height: 12 },
   );
+
   await settle(setup);
 
   const save = locateText(setup, "save");
+
   await setup.mockMouse.click(save.column, save.row);
   expect(saved).toBe(1);
   expect(cancelled).toBe(0);
 
   const cancel = locateText(setup, "cancel");
+
   await setup.mockMouse.click(cancel.column, cancel.row);
   expect(cancelled).toBe(1);
   expect(saved).toBe(1);

package/src/ui/components/RootOverlay.tsx

@@ -29,6 +29,7 @@ export function RootOverlayProvider({ children }: { children: React.ReactNode })
         setOverlays((current) => {
           if (!current.has(key)) return current;
           const next = new Map(current);
+
           next.delete(key);
 
           return next;

package/src/ui/components/primitives/Dialog.test.tsx

@@ -23,6 +23,7 @@ test("clicking the backdrop dismisses; clicking inside the panel does not", asyn
     </Dialog>,
     { width: 60, height: 20 },
   );
+
   await settle(setup);
 
   // the top-left corner is backdrop, outside the centered panel

package/src/workbench/components/ChangesColumn.tsx

@@ -140,6 +140,7 @@ export function ChangesFileTree({
       return setCursor(Math.min(cursorIndex + 1, rows.length - 1));
     if (key.name === "k" || key.name === "up") return setCursor(Math.max(cursorIndex - 1, 0));
     const row = rows[cursorIndex];
+
     if (!row) return;
     if (key.name === "return" || key.name === "enter")
       return row.isFolder ? toggle(row.id) : onSelectFile(row.id, true);

package/src/workbench/components/ChangesFileTree.test.tsx

@@ -41,6 +41,7 @@ test("j moves onto a file and Enter opens it", async () => {
     />,
     { width: 40, height: 12 },
   );
+
   await settle(setup);
   await waitForText(setup, "a.ts");
 
@@ -117,6 +118,7 @@ test("without focus the keyboard opens nothing", async () => {
     <ChangesFileTree files={files} onSelectFile={(path) => opened.push(path)} theme={DARK} />,
     { width: 40, height: 12 },
   );
+
   await settle(setup);
   await waitForText(setup, "a.ts");
 

package/src/workbench/components/FileContentsView.tsx

@@ -34,12 +34,14 @@ export function FileContentsView({
   // instance; a state-backed ref rebinds the target once the code renderable exists.
   const [codeTarget, setCodeTarget] = useState<CodeRenderable | null>(null);
   const loadRef = useRef(loadContents);
+
   useEffect(() => {
     loadRef.current = loadContents;
   });
 
   useEffect(() => {
     let alive = true;
+
     void loadRef.current(path).then(
       (contents) => {
         if (alive) setLoaded({ path, lines: contents === null ? null : contents.split("\n") });

package/src/workbench/components/GridTabContent.tsx

@@ -34,6 +34,9 @@ export type DiffSurfaceProps = Pick<
   | "onAnnotate"
   | "onReply"
   | "onUpdateAnnotation"
+  | "isAnnotationReadOnly"
+  | "annotationAction"
+  | "onInvoke"
   | "resolveAuthorLabel"
   | "onNavCommand"
   | "onExit"
@@ -108,6 +111,7 @@ export function GridTabContent(props: {
   theme: Theme;
 }): React.ReactNode {
   const { tab } = props;
+
   if (tab.kind === "file" && tab.fileView === "contents" && tab.path !== undefined) {
     const filePath = tab.path;
 
@@ -128,6 +132,9 @@ export function GridTabContent(props: {
         onAddComment={(anchor, body) => props.onAddFileComment(filePath, anchor, body)}
         onReply={props.surface.onReply}
         onUpdateAnnotation={props.surface.onUpdateAnnotation}
+        isAnnotationReadOnly={props.surface.isAnnotationReadOnly}
+        annotationAction={props.surface.annotationAction}
+        onInvoke={props.surface.onInvoke}
         resolveAuthorLabel={props.surface.resolveAuthorLabel}
         onExit={props.surface.onExit}
         theme={props.theme}

package/src/workbench/components/ProjectTreeView.test.tsx

@@ -31,6 +31,7 @@ test("Enter expands a folder, then j moves down and Enter opens the file", async
     />,
     { width: 40, height: 12 },
   );
+
   await settle(setup);
   await waitForText(setup, "src");
 
@@ -144,6 +145,7 @@ test("without focus the keyboard does nothing", async () => {
     />,
     { width: 40, height: 12 },
   );
+
   await settle(setup);
   await waitForText(setup, "src");
 
@@ -223,6 +225,7 @@ test("a double-click requests a persistent file tab", async () => {
 
   await waitForText(setup, "README.md");
   const file = locateText(setup, "README.md");
+
   await setup.mockMouse.doubleClick(file.column, file.row);
   expect(opened).toEqual([
     { path: "README.md", persistent: false },

package/src/workbench/components/ProjectTreeView.tsx

@@ -56,6 +56,7 @@ export function ProjectTreeView({
     if (key.name === "k" || key.name === "up")
       return setCursorId(rows[Math.max(cursorIndex - 1, 0)]!.id);
     const row = rows[cursorIndex];
+
     if (!row) return;
     if (key.name === "return" || key.name === "enter")
       return row.isFolder ? toggle(row.id) : onSelectFile(row.id, true);

package/src/workbench/components/editor-grid.test.ts

@@ -19,10 +19,12 @@ import {
 
 function asBranch(node: EditorNode | null): EditorBranch {
   if (node === null || node.type !== "branch") throw new Error("expected a branch node");
+
   return node;
 }
 function asGroup(node: EditorNode | null): EditorGroup {
   if (node === null || node.type !== "group") throw new Error("expected a group node");
+
   return node;
 }
 
@@ -30,6 +32,7 @@ describe("editor grid", () => {
   test("a fresh group holds its tabs with the first active", () => {
     const tab = changesTab();
     const group = makeGroup([tab]);
+
     expect(group.type).toBe("group");
     expect(group.activeTabId).toBe(tab.id);
   });
@@ -38,6 +41,7 @@ describe("editor grid", () => {
     const group = makeGroup([changesTab()]);
     const file = fileTab("App.tsx", "src/App.tsx", "diff");
     const next = asGroup(addTab(group, group.id, file));
+
     expect(next.tabs).toHaveLength(2);
     expect(next.activeTabId).toBe(file.id);
   });
@@ -81,8 +85,10 @@ describe("editor grid", () => {
   test("splitting right makes a horizontal branch and focuses the new group", () => {
     const group = makeGroup([fileTab("App.tsx", "src/App.tsx", "diff")]);
     const { tree, focusGroupId } = splitGroup(group, group.id, "right");
+
     expect(tree.type).toBe("branch");
     const branch = asBranch(tree);
+
     expect(branch.orientation).toBe("horizontal");
     expect(branch.children).toHaveLength(2);
     // the new group is the second child (right edge) and takes focus
@@ -95,6 +101,7 @@ describe("editor grid", () => {
     const group = makeGroup([fileTab("a.ts", "a.ts", "contents")]);
     const { tree, focusGroupId } = splitGroup(group, group.id, "up");
     const branch = asBranch(tree);
+
     expect(branch.orientation).toBe("vertical");
     expect(branch.children[0]!.id).toBe(focusGroupId);
   });
@@ -131,6 +138,7 @@ describe("editor grid", () => {
     const branch = asBranch(tree);
     const rightGroup = asGroup(branch.children[1]!);
     const collapsed = closeTab(tree, rightGroup.id, rightGroup.tabs[0]!.id);
+
     expect(collapsed?.type).toBe("group");
     expect(asGroup(collapsed).id).toBe(group.id);
   });
@@ -138,6 +146,7 @@ describe("editor grid", () => {
   test("closing the only tab of the whole grid returns null", () => {
     const tab = changesTab();
     const group = makeGroup([tab]);
+
     expect(closeTab(group, group.id, tab.id)).toBeNull();
   });
 
@@ -146,8 +155,10 @@ describe("editor grid", () => {
     const { tree } = splitGroup(group, group.id, "right");
     const branch = asBranch(tree);
     const rightGroup = asGroup(branch.children[1]!);
+
     expect(containsGroup(tree, group.id)).toBe(true);
     const collapsed = closeTab(tree, rightGroup.id, rightGroup.tabs[0]!.id);
+
     expect(containsGroup(asGroup(collapsed), rightGroup.id)).toBe(false);
   });