cueloop 0.1.0-alpha.90 → 0.1.0-alpha.92

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cueloop",
-  "version": "0.1.0-alpha.90",
+  "version": "0.1.0-alpha.92",
   "description": "Terminal review surface for coding agents: annotate plans and diffs, return a message, send structured feedback back",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -30,11 +30,11 @@
     "build:binary": "bun build --compile --minify --external cpu-features ./src/main.ts --outfile dist/cueloop"
   },
   "dependencies": {
-    "@cueloop/adapters": "0.1.0-alpha.90",
-    "@cueloop/client": "0.1.0-alpha.90",
-    "@cueloop/daemon": "0.1.0-alpha.90",
-    "@cueloop/extension-api": "0.1.0-alpha.90",
-    "@cueloop/schema": "0.1.0-alpha.90",
+    "@cueloop/adapters": "0.1.0-alpha.92",
+    "@cueloop/client": "0.1.0-alpha.92",
+    "@cueloop/daemon": "0.1.0-alpha.92",
+    "@cueloop/extension-api": "0.1.0-alpha.92",
+    "@cueloop/schema": "0.1.0-alpha.92",
     "@modelcontextprotocol/server": "2.0.0",
     "@valibot/to-json-schema": "1.4.0",
     "valibot": "^1.5.0"

package/src/args.ts

@@ -7,7 +7,7 @@ export interface ParsedArgs {
   flags: Record<string, string | boolean>;
 }
 
-export function parseArgs(argv: string[]): ParsedArgs {
+export function parseArgs(argv: string[], booleanFlags: readonly string[] = []): ParsedArgs {
   const positional: string[] = [];
   const flags: Record<string, string | boolean> = {};
 
@@ -26,7 +26,7 @@ export function parseArgs(argv: string[]): ParsedArgs {
       const key = argument.slice(2);
       const next = argv[i + 1];
 
-      if (next !== undefined && !next.startsWith("--")) {
+      if (!booleanFlags.includes(key) && next !== undefined && !next.startsWith("--")) {
         flags[key] = next;
         i++;
       } else {

package/src/main.ts

@@ -23,7 +23,7 @@ import {
 import { sessionCommand } from "./thread-commands";
 import { CLI_VERSION } from "./version";
 import { DaemonClient } from "@cueloop/daemon/client";
-import type { Thread } from "@cueloop/schema";
+import type { Thread, ThreadSurfaceOpenStatus } from "@cueloop/schema";
 import { openReview } from "@cueloop/daemon/thread-review";
 
 const argv = process.argv.slice(2);
@@ -107,6 +107,7 @@ const commandHandlers: CommandHandlers = {
   stop: async () => (await import("./daemon-control")).stopCommand(),
   restart: async () => (await import("./daemon-control")).restartCommand(),
   plan: (rest) => planCommand(rest),
+  pair: (rest) => pairCommand(rest),
   reply: (rest) => replyCommand(rest),
   diff: (rest) => diffCommand(rest),
   prototype: (rest) => prototypeCommand(rest),
@@ -278,6 +279,43 @@ async function diffCommand(argv: string[]): Promise<number> {
   return runTui(workbench.id, "review");
 }
 
+async function pairCommand(argv: string[]): Promise<number> {
+  const startedAt = new Date().toISOString();
+  const parsed = parseArgs(argv, ["open-tab", "no-tui"]);
+  const client = await DaemonClient.connect({ autostart: true });
+  let thread: Thread;
+  let openStatus: ThreadSurfaceOpenStatus | undefined;
+
+  try {
+    const sessionId = parsed.positional[0];
+
+    if (sessionId !== undefined) {
+      thread = await client.sessionGet(sessionId);
+      if (thread.artifact.meta.workbench !== true || thread.status !== "pending") {
+        throw new Error(`Thread ${sessionId} is not an open workbench`);
+      }
+    } else {
+      thread = await client.sessionWorkbench(process.cwd());
+    }
+    if (parsed.flags["open-tab"] === true) {
+      const { openHerdrThreadSurface } = await import("@cueloop/daemon/herdr-thread-surface");
+
+      openStatus = await openHerdrThreadSurface(thread, client, process.env, "tab", "pair");
+    }
+  } finally {
+    client.close();
+  }
+  if (parsed.flags["no-tui"] === true || parsed.flags["open-tab"] === true) {
+    console.log(
+      JSON.stringify({ threadId: thread.id, startedAt, ...(openStatus && { openStatus }) }),
+    );
+
+    return 0;
+  }
+
+  return runTui(thread.id, "pair");
+}
+
 /**
  * `cueloop review` disambiguates create from open by intent:
  *   - bare `cueloop review`, `--open`/`--latest`, or a `ses_*` selector opens a
@@ -310,10 +348,16 @@ async function reviewEntry(argv: string[]): Promise<number> {
  * omitted) restores the remembered one. Resolve the factory here so the heavy client
  * module stays lazily imported for non-TUI commands.
  */
-async function runTui(sessionId?: string, layout?: "review" | "plan"): Promise<number> {
-  const { runClient, reviewLayout, planLayout } = await import("@cueloop/client");
+async function runTui(sessionId?: string, layout?: "review" | "plan" | "pair"): Promise<number> {
+  const { runClient, pairLayout, reviewLayout, planLayout } = await import("@cueloop/client");
   const resolved =
-    layout === "review" ? reviewLayout() : layout === "plan" ? planLayout() : undefined;
+    layout === "review"
+      ? reviewLayout()
+      : layout === "plan"
+        ? planLayout()
+        : layout === "pair"
+          ? pairLayout()
+          : undefined;
 
   return runClient({ sessionId, layout: resolved });
 }
@@ -331,6 +375,7 @@ function printHelp(): void {
       "  cueloop reply [id|title]         open the latest pending reply review (the agent's previous message)",
       "  cueloop diff [id|title]          review your working tree (untracked files included);",
       "                                   with a clean tree, open the latest pending diff review",
+      "  cueloop pair [thread-id]         open a live workbench; --open-tab opens Herdr; --no-tui prints its Thread ID",
       "  cueloop review <pr>              review a pull request (--no-tui prints the session)",
       "  cueloop prototype <file.md>      review a component design doc (or open the latest by id/title)",
       "",

package/src/thread-commands.ts

@@ -12,6 +12,7 @@ import {
   newAnnotationId,
   type Anchor,
   type Annotation,
+  type AnnotationTarget,
 } from "@cueloop/schema";
 import * as v from "valibot";
 import { DaemonClient } from "@cueloop/daemon/client";
@@ -127,7 +128,7 @@ async function annotateAnchor(
   flags: Record<string, string | boolean>,
   client: DaemonClient,
   id: string,
-): Promise<{ anchor: Anchor; replyTo?: string }> {
+): Promise<{ anchor: Anchor; replyTo?: string; target?: AnnotationTarget }> {
   const replyTo = stringFlag(flags, "reply-to");
 
   if (replyTo !== undefined) {
@@ -137,7 +138,9 @@ async function annotateAnchor(
     if (!root) throw new Error(`no comment ${replyTo} to reply to`);
 
     // a reply to a reply still hangs off the discussion's root comment
-    return { anchor: root.anchor, replyTo: root.replyTo ?? root.id };
+    return root.target === undefined
+      ? { anchor: root.anchor, replyTo: root.replyTo ?? root.id }
+      : { anchor: root.anchor, replyTo: root.replyTo ?? root.id, target: root.target };
   }
   const selector = stringFlag(flags, "selector");
   const quote =
@@ -163,8 +166,8 @@ async function sessionAnnotateCommand({
   const id = required(positional[1], "session id");
   const author = stringFlag(flags, "author");
   const body = await annotateBody(flags, client, id);
-  const { anchor, replyTo } = await annotateAnchor(flags, client, id);
-  const annotation: Omit<Annotation, "createdAt"> = {
+  const { anchor, replyTo, target } = await annotateAnchor(flags, client, id);
+  const base: Omit<Annotation, "createdAt"> = {
     id: stringFlag(flags, "annotation-id") ?? newAnnotationId(),
     kind: stringFlag(flags, "kind") ?? "comment",
     anchor,
@@ -172,7 +175,9 @@ async function sessionAnnotateCommand({
     author,
   };
 
-  if (replyTo !== undefined) annotation.replyTo = replyTo;
+  if (replyTo !== undefined) base.replyTo = replyTo;
+  const annotation: Omit<Annotation, "createdAt"> =
+    target === undefined ? base : { ...base, target };
   out(await client.sessionAnnotate(id, annotation, stringFlag(flags, "author-name")));
 
   return 0;
@@ -340,6 +345,7 @@ async function sessionEventsCommand({
 }: SessionContext): Promise<number> {
   const id = required(positional[1], "session id");
   const once = flags.once === true;
+  const ready = flags.ready === true;
   const stream = new Promise<number>((resolve) => {
     client.onEvent((event) => {
       if (event.sessionId !== id) return;
@@ -347,11 +353,24 @@ async function sessionEventsCommand({
       if (once) resolve(0);
     });
   });
+  let finished = false;
+  const disconnect = new Promise<number>((resolve) => {
+    client.onDisconnect(() => {
+      if (finished) return;
+      console.error("daemon connection closed - restart cueloop session events to resume");
+      resolve(1);
+    });
+  });
 
   await client.subscribe();
   await client.sessionGet(id);
+  if (ready) console.log(JSON.stringify({ event: "events.ready", sessionId: id }));
+
+  const code = await Promise.race([stream, disconnect]);
+
+  finished = true;
 
-  return stream;
+  return code;
 }
 
 async function sessionSendMessageCommand({