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

package/src/review.test.ts

@@ -1,167 +0,0 @@
-/**
- * The shared review core against a real DaemonServer in a temp home:
- * workspace resolution, title derivation, open-or-revise by agentSessionId,
- * and both awaitVerdict 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 { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { ReviewSession } from "@cueloop/schema";
-import { DaemonServer } from "./server";
-import { DaemonClient } from "./client";
-import { openReview, resolveWorkspace } from "./review";
-
-const PLAN = "# Rollout Plan\n\nShip it in two stages.\n";
-
-let home: string;
-let server: DaemonServer;
-let client: DaemonClient;
-
-beforeEach(async () => {
-  home = mkdtempSync(join(tmpdir(), "cueloop-review-core-"));
-  server = new DaemonServer({ home, idleExitMs: 0 });
-  server.start();
-  client = await DaemonClient.connect({ home });
-});
-afterEach(() => {
-  client.close();
-  server.stop();
-  rmSync(home, { recursive: true, force: true });
-});
-
-function sh(args: string[], cwd: string): void {
-  const p = Bun.spawnSync(args, { cwd, stdout: "ignore", stderr: "ignore" });
-  if (p.exitCode !== 0) throw new Error(`${args.join(" ")} failed`);
-}
-
-describe("resolveWorkspace", () => {
-  test("a git repo resolves to its root and branch", async () => {
-    const repo = mkdtempSync(join(tmpdir(), "cueloop-ws-"));
-    try {
-      sh(["git", "init", "-q", "-b", "main"], repo);
-      sh(["git", "config", "user.email", "t@t"], repo);
-      sh(["git", "config", "user.name", "t"], repo);
-      sh(["git", "commit", "-q", "--allow-empty", "-m", "init"], repo);
-      const ws = await resolveWorkspace(repo);
-      expect(ws.branch).toBe("main");
-      // macOS tmpdirs can resolve through /private; compare the tail
-      expect(ws.repoRoot.endsWith(repo.split("/").at(-1)!)).toBe(true);
-    } finally {
-      rmSync(repo, { recursive: true, force: true });
-    }
-  });
-
-  test("outside a repo the cwd itself is the workspace, branch detached", async () => {
-    const ws = await resolveWorkspace(home);
-    expect(ws).toEqual({ repoRoot: home, branch: "detached" });
-  });
-});
-
-describe("openReview", () => {
-  test("shapes the artifact: agent, derived title, cwd", async () => {
-    const review = await openReview(client, { type: "plan", content: PLAN, cwd: home, agent: "test-agent" });
-    const s = review.session;
-    expect(s.status).toBe("pending");
-    expect(s.artifact.type).toBe("plan");
-    expect(s.artifact.meta.agent).toBe("test-agent");
-    expect(s.artifact.meta.title).toBe("Rollout Plan");
-    expect(s.artifact.meta.cwd).toBe(home);
-    expect(s.workspace).toEqual({ repoRoot: home, branch: "detached" });
-  });
-
-  test("an explicit title wins; diffs never derive one from content", async () => {
-    const titled = await openReview(client, { type: "plan", content: PLAN, cwd: home, title: "Custom" });
-    expect(titled.session.artifact.meta.title).toBe("Custom");
-    const diff = await openReview(client, { type: "diff", content: "# not a heading\n", cwd: home });
-    expect(diff.session.artifact.meta.title).toBeUndefined();
-  });
-
-  test("a pre-resolved workspace skips git resolution", async () => {
-    const ws = { repoRoot: "/elsewhere", branch: "feature" };
-    const review = await openReview(client, { type: "diff", content: "d", cwd: home, workspace: ws });
-    expect(review.session.workspace).toEqual(ws);
-  });
-
-  test("the same agentSessionId revises instead of opening a new session", async () => {
-    const first = await openReview(client, { type: "plan", content: PLAN, cwd: home, agentSessionId: "agent-1" });
-    const second = await openReview(client, {
-      type: "plan",
-      content: PLAN + "\nStage three.\n",
-      cwd: home,
-      agentSessionId: "agent-1",
-    });
-    expect(second.id).toBe(first.id);
-    expect(second.session.revisions.length).toBe(2);
-    expect(second.session.status).toBe("pending");
-    const other = await openReview(client, { type: "plan", content: PLAN, cwd: home, agentSessionId: "agent-2" });
-    expect(other.id).not.toBe(first.id);
-  });
-});
-
-describe("awaitVerdict: one long-poll (the hook shape)", () => {
-  test("times out to pending; a later wait collects the stored verdict", async () => {
-    const review = await openReview(client, { type: "plan", content: PLAN, cwd: home });
-    expect(await review.awaitVerdict({ timeoutMs: 50 })).toBe("pending");
-    await client.sessionResolve(review.id, "approve", "Fine.");
-    const verdict = await review.awaitVerdict({ timeoutMs: 1_000 });
-    expect(verdict).not.toBe("pending");
-    if (verdict === "pending") throw new Error("unreachable");
-    expect(verdict.allow).toBe(true);
-    expect(verdict.feedback).toContain("Fine.");
-    expect(verdict.session.verdict!.kind).toBe("approve");
-  });
-
-  test("request_changes maps to allow=false with feedback.md attached", async () => {
-    const review = await openReview(client, { type: "plan", content: PLAN, cwd: home });
-    const waiting = review.awaitVerdict({ timeoutMs: 5_000 });
-    await client.sessionResolve(review.id, "request_changes", "One stage only.");
-    const verdict = await waiting;
-    if (verdict === "pending") throw new Error("expected a verdict");
-    expect(verdict.allow).toBe(false);
-    expect(verdict.feedback).toContain("# Review: request changes");
-    expect(verdict.feedback).toContain("One stage only.");
-  });
-});
-
-describe("awaitVerdict: chunked loop (the pi shape)", () => {
-  test("onProgress sees fresh sessions between chunks; the verdict ends the loop", async () => {
-    const review = await openReview(client, { type: "plan", content: PLAN, cwd: home });
-    const seen: ReviewSession[] = [];
-    const waiting = review.awaitVerdict({
-      timeoutMs: Infinity,
-      pollMs: 100,
-      onProgress: (s) => seen.push(s),
-    });
-    await client.sessionAnnotate(review.id, {
-      id: "a1",
-      kind: "comment",
-      anchor: { quote: "two stages", prefix: "in ", suffix: "." },
-      body: "Name them.",
-    });
-    // give the loop a chunk to observe the annotation before resolving
-    for (let i = 0; i < 100 && !seen.some((s) => s.annotations.length === 1); i++) await Bun.sleep(20);
-    expect(seen.some((s) => s.annotations.length === 1)).toBe(true);
-    await client.sessionResolve(review.id, "request_changes", "Too vague.");
-    const verdict = await waiting;
-    if (verdict === "pending") throw new Error("expected a verdict");
-    expect(verdict.allow).toBe(false);
-    expect(verdict.session.annotations.length).toBe(1);
-  }, 15_000);
-
-  test("abort surfaces as pending and leaves the session collectable", async () => {
-    const review = await openReview(client, { type: "plan", content: PLAN, cwd: home });
-    const controller = new AbortController();
-    const waiting = review.awaitVerdict({ timeoutMs: Infinity, pollMs: 100, signal: controller.signal });
-    controller.abort();
-    expect(await waiting).toBe("pending");
-    expect((await client.sessionGet(review.id)).status).toBe("pending");
-  });
-
-  test("a finite budget runs out to pending", async () => {
-    const review = await openReview(client, { type: "plan", content: PLAN, cwd: home });
-    expect(await review.awaitVerdict({ timeoutMs: 120, pollMs: 50 })).toBe("pending");
-  });
-});

package/src/review.ts

@@ -1,174 +0,0 @@
-/**
- * The shared review core: one open/wait/verdict path for every consumer -
- * CLI commands and agent adapters. openReview resolves the workspace, shapes
- * the artifact, and opens-or-revises by agentSessionId; awaitVerdict maps the
- * wait contract (#14) onto the agent contract through verdictResponse. An
- * adapter keeps only two bespoke parts: parsing its host's event shape and
- * serializing the decision in its host's contract.
- */
-
-import type { ArtifactType, ReviewSession, WorkspaceKey } from "@cueloop/schema";
-import { verdictResponse } from "./api";
-import type { DaemonClient } from "./client";
-
-// Adapters and CLI verbs reach the verdict mapping through this module too,
-// so a session obtained outside a ReviewHandle maps the same way.
-export { verdictResponse };
-
-async function git(args: string[], cwd: string): Promise<string | null> {
-  try {
-    const proc = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
-    const out = await new Response(proc.stdout).text();
-    if ((await proc.exited) !== 0) return null;
-    return out.trim();
-  } catch {
-    return null;
-  }
-}
-
-/** Workspace key resolution (#9): repo root + branch 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";
-  return { repoRoot, branch };
-}
-
-function firstHeading(md: string): string | undefined {
-  const m = md.match(/^#\s+(.+)$/m);
-  return m?.[1]?.trim();
-}
-
-export interface OpenReviewOptions {
-  type: ArtifactType;
-  content: string;
-  /** Workspace resolution root and meta.cwd; defaults to process.cwd(). */
-  cwd?: string;
-  /** Pre-resolved workspace key; skips git resolution when the caller already has it. */
-  workspace?: WorkspaceKey;
-  agent?: string;
-  /** When set, a resubmit from the same agent session becomes a revision, not a new session. */
-  agentSessionId?: string;
-  planPath?: string;
-  pr?: string;
-  herdrPane?: string;
-  /** Defaults to the plan's first markdown heading; diffs get no derived title. */
-  title?: string;
-}
-
-export interface AwaitVerdictOptions {
-  /** Total wait budget; Infinity keeps polling until resolved or aborted. */
-  timeoutMs: number;
-  /** Chunk length for the poll loop; between chunks the session is re-read for progress. */
-  pollMs?: number;
-  /** Called with the fresh session after each chunk that is still pending. */
-  onProgress?: (session: ReviewSession) => void;
-  signal?: AbortSignal;
-}
-
-/** A resolved review mapped onto the agent contract, plus the full session. */
-export interface VerdictOutcome {
-  allow: boolean;
-  feedback: string;
-  session: ReviewSession;
-}
-
-/** Sentinel distinguishing an abort from any daemon response. */
-const ABORTED = Symbol("aborted");
-
-function raceAbort<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T | typeof ABORTED> {
-  if (!signal) return promise;
-  if (signal.aborted) {
-    promise.catch(() => {});
-    return Promise.resolve(ABORTED);
-  }
-  return new Promise<T | typeof ABORTED>((resolve, reject) => {
-    const onAbort = () => {
-      // The daemon request keeps running until the client closes; swallow its
-      // eventual rejection so the abort path never leaks an unhandled error.
-      promise.catch(() => {});
-      resolve(ABORTED);
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    promise.then(
-      (v) => {
-        signal.removeEventListener("abort", onAbort);
-        resolve(v);
-      },
-      (e) => {
-        signal.removeEventListener("abort", onAbort);
-        reject(e);
-      },
-    );
-  });
-}
-
-export class ReviewHandle {
-  constructor(
-    private readonly client: DaemonClient,
-    readonly session: ReviewSession,
-  ) {}
-
-  get id(): string {
-    return this.session.id;
-  }
-
-  /**
-   * Block on the verdict. "pending" means the budget ran out or the signal
-   * aborted - the session stays open and the verdict is collectable later
-   * (verdicts outlive waits, #14). With only timeoutMs this is one long-poll;
-   * pollMs/onProgress/signal switch to the chunked loop.
-   */
-  async awaitVerdict(opts: AwaitVerdictOptions): Promise<VerdictOutcome | "pending"> {
-    const { timeoutMs, pollMs, onProgress, signal } = opts;
-    if (pollMs === undefined && onProgress === undefined && signal === undefined) {
-      const resolved = await this.client.sessionWait(this.session.id, timeoutMs);
-      return resolved === null ? "pending" : outcome(resolved);
-    }
-    const chunkMs = pollMs ?? 10_000;
-    const deadline = Number.isFinite(timeoutMs) ? Date.now() + timeoutMs : undefined;
-    for (;;) {
-      const budget = deadline === undefined ? chunkMs : Math.min(chunkMs, deadline - Date.now());
-      if (budget <= 0 || signal?.aborted) return "pending";
-      const resolved = await raceAbort(this.client.sessionWait(this.session.id, budget), signal);
-      if (resolved === ABORTED) return "pending";
-      if (resolved !== null) return outcome(resolved);
-      // Still pending after this chunk: re-read to surface reviewer progress.
-      const current = await raceAbort(this.client.sessionGet(this.session.id), signal);
-      if (current === ABORTED) return "pending";
-      onProgress?.(current);
-    }
-  }
-}
-
-function outcome(session: ReviewSession): VerdictOutcome {
-  return { ...verdictResponse(session), session };
-}
-
-/** Open a review session (or revise the agent session's existing one) and hand back the wait surface. */
-export async function openReview(client: DaemonClient, opts: OpenReviewOptions): Promise<ReviewHandle> {
-  const cwd = opts.cwd ?? process.cwd();
-  const workspace = opts.workspace ?? (await resolveWorkspace(cwd));
-  // Resubmits from the same agent session become revisions, not new sessions.
-  if (opts.agentSessionId !== undefined) {
-    const existing = (await client.sessionList()).find(
-      (s) => s.artifact.meta.agentSessionId === opts.agentSessionId,
-    );
-    if (existing !== undefined) {
-      return new ReviewHandle(client, await client.sessionSubmitRevision(existing.id, opts.content));
-    }
-  }
-  const session = await client.sessionCreate(workspace, {
-    type: opts.type,
-    content: opts.content,
-    meta: {
-      agent: opts.agent,
-      agentSessionId: opts.agentSessionId,
-      planPath: opts.planPath,
-      pr: opts.pr,
-      herdrPane: opts.herdrPane,
-      title: opts.title ?? (opts.type === "plan" ? firstHeading(opts.content) : undefined),
-      cwd,
-    },
-  });
-  return new ReviewHandle(client, session);
-}