@cueloop/daemon 0.1.0-alpha.10 → 0.1.0-alpha.100

package/src/curate.ts

@@ -0,0 +1,109 @@
+/**
+ * The curated patch of a diff review: the submitted changes minus the hunks and
+ * change blocks the reviewer rejected. The daemon computes it from the
+ * session's reject decisions so the working copy every client sees is one and
+ * the same; the client only maps rows to decisions.
+ */
+
+import { diffAcceptRejectHunk, parseDiffFromFile, type FileDiffMetadata } from "@pierre/diffs";
+import {
+  unifiedDiffText,
+  type DiffFileContents,
+  type DiffFileStatus,
+  type HunkRejection,
+} from "@cueloop/schema";
+
+/**
+ * Context lines around each change. Matching git's default (3) makes the model
+ * split hunks like the rendered working-tree patch does; a row is mapped by
+ * absolute line number, never by counting hunks, so a whole-hunk reject can
+ * only ever span the model hunk it lands in.
+ */
+export const DIFF_CONTEXT = 3;
+
+/** Parse one file's full contents into a non-partial diff model. */
+export function parseFileDiff(file: DiffFileContents): FileDiffMetadata {
+  return parseDiffFromFile(
+    { name: file.path, contents: file.oldContents },
+    { name: file.path, contents: file.newContents },
+    { context: DIFF_CONTEXT },
+  );
+}
+
+/**
+ * Apply one file's rejections and return its curated patch, or null when the
+ * curated content equals the old content (every change rejected - no patch).
+ * Whole-hunk rejections supersede change-level ones for the same hunk. Because
+ * `diffAcceptRejectHunk` returns a model with the same hunk/content shape, the
+ * indices stay valid across calls; they are applied high-to-low regardless, so
+ * the order is deterministic.
+ */
+function curateFilePatch(file: DiffFileContents, rejections: HunkRejection[]): string | null {
+  let model = parseFileDiff(file);
+  const wholeHunks = new Set(
+    rejections
+      .filter((rejection) => rejection.changeIndex === undefined)
+      .map((rejection) => rejection.hunkIndex),
+  );
+
+  for (const hunkIndex of [...wholeHunks].sort((a, b) => b - a)) {
+    model = diffAcceptRejectHunk(model, hunkIndex, "reject");
+  }
+  const changeRejections = rejections
+    .filter(
+      (rejection) => rejection.changeIndex !== undefined && !wholeHunks.has(rejection.hunkIndex),
+    )
+    .sort((a, b) => b.hunkIndex - a.hunkIndex || b.changeIndex! - a.changeIndex!);
+
+  for (const rejection of changeRejections) {
+    model = diffAcceptRejectHunk(model, rejection.hunkIndex, {
+      type: "reject",
+      changeIndex: rejection.changeIndex!,
+    });
+  }
+  const curatedNew = model.additionLines.join("");
+
+  if (curatedNew === file.oldContents) return null;
+  const patch = unifiedDiffText(file.oldContents, curatedNew, file.path);
+
+  if (patch === null) return null;
+
+  return withFileStateHeaders(patch, file.path, file.status, curatedNew);
+}
+
+/**
+ * Point the diff headers at /dev/null for a created or fully-deleted file so the
+ * curated patch applies. git's status - not empty contents - decides existence,
+ * so editing an existing empty file stays a modify; a deletion whose removals
+ * were partly restored also falls back to a modify.
+ */
+function withFileStateHeaders(
+  patch: string,
+  path: string,
+  status: DiffFileStatus,
+  curatedNew: string,
+): string {
+  if (status === "added") return patch.replace(`--- a/${path}`, "--- /dev/null");
+  if (status === "deleted" && curatedNew === "") {
+    return patch.replace(`+++ b/${path}`, "+++ /dev/null");
+  }
+
+  return patch;
+}
+
+/**
+ * The curated unified-diff patch of the accepted changes across every file.
+ * Files with no net change (unchanged, or with all changes rejected) drop out.
+ */
+export function curateDiff(files: DiffFileContents[], rejections: HunkRejection[]): string {
+  const parts: string[] = [];
+
+  for (const file of files) {
+    const fileRejections = rejections.filter((rejection) => rejection.path === file.path);
+    const patch = curateFilePatch(file, fileRejections);
+
+    if (patch) parts.push(patch);
+  }
+
+  return parts.join("\n");
+}

package/src/daemon-sdk-effect.ts

@@ -0,0 +1,113 @@
+import { Context, Effect, Layer, Stream, Queue, Cause, type Scope } from "effect";
+import {
+  connectOwnerSdk,
+  normalizeSdkError,
+  type OwnerDaemonSdk,
+  type DaemonSdkError,
+  type SdkThread,
+  type SdkThreadId,
+} from "./daemon-sdk";
+import type { ConnectOptions } from "./client";
+import type { DaemonRequestOptions } from "./client-errors";
+
+type EffectMethods<Methods> = {
+  readonly [Key in keyof Methods]: Methods[Key] extends (
+    ...args: infer Arguments
+  ) => Promise<infer Result>
+    ? (...args: Arguments) => Effect.Effect<Result, DaemonSdkError>
+    : never;
+};
+
+/** The Effect service owns a scoped connection while daemon-owned work outlives local waits. */
+export class CueloopSdk extends Context.Service<
+  CueloopSdk,
+  {
+    readonly ids: OwnerDaemonSdk["ids"];
+    readonly threads: EffectMethods<OwnerDaemonSdk["threads"]> & {
+      watch(threadId: SdkThreadId): Stream.Stream<SdkThread, DaemonSdkError>;
+    };
+    readonly comments: EffectMethods<OwnerDaemonSdk["comments"]>;
+    readonly sessions: EffectMethods<OwnerDaemonSdk["sessions"]>;
+    readonly agents: EffectMethods<OwnerDaemonSdk["agents"]>;
+  }
+>()("@cueloop/daemon/CueloopSdk") {
+  static ownerLayer(
+    options: Omit<ConnectOptions, "role"> = {},
+  ): Layer.Layer<CueloopSdk, DaemonSdkError> {
+    return Layer.effect(CueloopSdk, acquireOwnerSdk(options).pipe(Effect.map(effectSdkService)));
+  }
+}
+
+function acquireOwnerSdk(
+  options: Omit<ConnectOptions, "role">,
+): Effect.Effect<OwnerDaemonSdk, DaemonSdkError, Scope.Scope> {
+  return Effect.acquireRelease(
+    Effect.tryPromise({ try: () => connectOwnerSdk(options), catch: normalizeSdkError }),
+    (sdk) => Effect.sync(() => sdk.close()),
+  );
+}
+
+function sdkEffect<Result>(
+  request: (options: DaemonRequestOptions) => Promise<Result>,
+  options?: DaemonRequestOptions,
+): Effect.Effect<Result, DaemonSdkError> {
+  return Effect.tryPromise({
+    try: (signal) =>
+      request({
+        ...options,
+        signal: options?.signal ? AbortSignal.any([signal, options.signal]) : signal,
+      }),
+    catch: normalizeSdkError,
+  });
+}
+
+function effectSdkService(sdk: OwnerDaemonSdk): CueloopSdk["Service"] {
+  return {
+    ids: sdk.ids,
+    threads: {
+      watch: (threadId) =>
+        Stream.callback<SdkThread, DaemonSdkError>(
+          Effect.fn(function* (queue) {
+            yield* Effect.acquireRelease(
+              Effect.sync(() =>
+                sdk.observeThread({
+                  threadId,
+                  onValue: (thread) => {
+                    Queue.offerUnsafe(queue, thread);
+                  },
+                  onError: (error) => {
+                    if (error._tag === "DaemonClientError" || error.kind === "protocol")
+                      Queue.failCauseUnsafe(queue, Cause.fail(error));
+                  },
+                }),
+              ),
+              (stop) => Effect.sync(stop),
+            );
+          }),
+          { bufferSize: 1, strategy: "sliding" },
+        ),
+      get: (id, options) => sdkEffect((request) => sdk.threads.get(id, request), options),
+      create: (input, options) =>
+        sdkEffect((request) => sdk.threads.create(input, request), options),
+    },
+    comments: {
+      add: (input, options) => sdkEffect((request) => sdk.comments.add(input, request), options),
+      list: (id, options) => sdkEffect((request) => sdk.comments.list(id, request), options),
+      reply: (input, options) =>
+        sdkEffect((request) => sdk.comments.reply(input, request), options),
+    },
+    sessions: {
+      sendMessage: (input, options) =>
+        sdkEffect((request) => sdk.sessions.sendMessage(input, request), options),
+    },
+    agents: {
+      get: (id, options) => sdkEffect((request) => sdk.agents.get(id, request), options),
+      prompt: (input, options) =>
+        sdkEffect((request) => sdk.agents.prompt(input, request), options),
+      replyToComment: (input, options) =>
+        sdkEffect((request) => sdk.agents.replyToComment(input, request), options),
+      wait: (input, options) => sdkEffect((request) => sdk.agents.wait(input, request), options),
+      cancel: (id, options) => sdkEffect((request) => sdk.agents.cancel(id, request), options),
+    },
+  };
+}

package/src/daemon-sdk.test.ts

@@ -0,0 +1,306 @@
+import { expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Effect, Stream } from "effect";
+import { DaemonServer } from "./server";
+import { DaemonClient } from "./client";
+import { connectOwnerSdk, connectReviewSdk } from "./daemon-sdk";
+import { CueloopSdk } from "./daemon-sdk-effect";
+
+import { createTestSdkHarness } from "../../../test/helpers/sdk-harness";
+
+test("SDK accepts once, waits for its own submission and cancelling a wait preserves work", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-sdk-"));
+  const harness = createTestSdkHarness();
+  const server = new DaemonServer({
+    home,
+    idleExitMs: 0,
+    threadAgent: { enabled: true, adapter: harness.adapter },
+  });
+
+  server.start();
+  const sdk = await connectOwnerSdk({ home });
+
+  try {
+    const thread = await sdk.threads.create({
+      workspace: { repoRoot: home, branch: "main" },
+      artifact: { type: "plan", content: "Explain this", meta: {} },
+    });
+    const input = {
+      threadId: thread.id,
+      operationId: sdk.ids.operation("ask-once"),
+      text: "Explain",
+    };
+    const accepted = await sdk.agents.prompt(input);
+    const duplicate = await sdk.agents.prompt(input);
+
+    expect(duplicate).toEqual(accepted);
+    expect((await sdk.agents.get(thread.id)).submissions).toHaveLength(1);
+    await expect(sdk.agents.prompt({ ...input, text: "Different" })).rejects.toMatchObject({
+      code: "operation_conflict",
+    });
+    const cancel = new AbortController();
+    const abandonedWait = sdk.agents.wait(accepted, { signal: cancel.signal });
+
+    cancel.abort();
+    await expect(abandonedWait).rejects.toMatchObject({ kind: "cancelled" });
+    expect(harness.cancelled()).toBe(0);
+    const completed = sdk.agents.wait(accepted);
+
+    harness.complete();
+    expect((await completed).outcome).toBe("completed");
+    const message = {
+      threadId: thread.id,
+      operationId: sdk.ids.operation("approve-once"),
+      outcome: "approved" as const,
+      summary: "Good",
+    };
+    const sent = await sdk.sessions.sendMessage(message);
+
+    expect(await sdk.sessions.sendMessage(message)).toEqual(sent);
+  } finally {
+    sdk.close();
+    server.stop();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("Effect scope supports review comments and typed owner-only capabilities", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-sdk-effect-"));
+  const server = new DaemonServer({ home, idleExitMs: 0 });
+
+  server.start();
+
+  try {
+    const program = Effect.gen(function* () {
+      const sdk = yield* CueloopSdk;
+      const thread = yield* sdk.threads.create({
+        workspace: { repoRoot: home, branch: "main" },
+        artifact: { type: "plan", content: "Discuss this", meta: {} },
+      });
+      const snapshots = yield* sdk.threads.watch(thread.id).pipe(Stream.take(1), Stream.runCollect);
+
+      expect(snapshots[0]?.id).toBe(thread.id);
+      const client = yield* Effect.promise(() => DaemonClient.connect({ home }));
+
+      try {
+        yield* Effect.promise(() =>
+          client.sessionComment(thread.id, {
+            id: "comment",
+            kind: "comment",
+            anchor: { quote: "Discuss", prefix: "", suffix: " this" },
+            body: "Why?",
+          }),
+        );
+      } finally {
+        client.close();
+      }
+      yield* sdk.comments.reply({
+        threadId: thread.id,
+        commentId: "comment",
+        body: "Because",
+        replyId: "reply",
+      });
+      const comments = yield* sdk.comments.list(thread.id);
+
+      expect(comments.at(-1)).toMatchObject({ id: "reply", replyTo: "comment", body: "Because" });
+
+      return thread.id;
+    });
+    const id = await Effect.runPromise(
+      program.pipe(Effect.provide(CueloopSdk.ownerLayer({ home }))),
+    );
+    const review = await connectReviewSdk({ home, role: "agent", author: "review-agent" });
+
+    try {
+      expect((await review.threads.get(id)).id).toBe(id);
+      expect("agents" in review).toBe(false);
+      const capped = await DaemonClient.connect({ home, role: "agent", author: "review-agent" });
+
+      try {
+        await expect(capped.agentPrompt({ id, text: "Forbidden" })).rejects.toMatchObject({
+          code: "forbidden",
+        });
+      } finally {
+        capped.close();
+      }
+    } finally {
+      review.close();
+    }
+  } finally {
+    server.stop();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("lost response after message commit is uncertain and an explicit retry survives server restart", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-sdk-lost-response-"));
+  let server = new DaemonServer({ home, idleExitMs: 0 });
+
+  server.start();
+  const connection = await DaemonClient.connect({ home });
+
+  try {
+    const thread = await connection.sessionCreate(
+      { repoRoot: home, branch: "main" },
+      { type: "plan", content: "Approve this", meta: {} },
+    );
+    const send = server.core.sessionSendMessage.bind(server.core);
+
+    server.core.sessionSendMessage = (...args) => {
+      const result = send(...args);
+
+      connection.close();
+
+      return result;
+    };
+    await expect(
+      connection.sessionSendMessage(thread.id, "approved", "Done", undefined, "lost-ack"),
+    ).rejects.toMatchObject({ kind: "connection", certainty: "unknown" });
+    const original = server.core.sessionGet(thread.id).message;
+
+    server.stop();
+    server = new DaemonServer({ home, idleExitMs: 0 });
+    server.start();
+    const sdk = await connectOwnerSdk({ home });
+
+    try {
+      expect(
+        await sdk.sessions.sendMessage({
+          threadId: sdk.ids.thread(thread.id),
+          operationId: sdk.ids.operation("lost-ack"),
+          outcome: "approved",
+          summary: "Done",
+        }),
+      ).toEqual(original!);
+      expect(
+        (await sdk.threads.get(sdk.ids.thread(thread.id))).history?.entries.filter(
+          (entry) => entry.type === "message",
+        ),
+      ).toHaveLength(1);
+    } finally {
+      sdk.close();
+    }
+  } finally {
+    connection.close();
+    server.stop();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("Effect interruption aborts the completion wait without stopping the harness", async () => {
+  const { Fiber } = await import("effect");
+  const home = mkdtempSync(join(tmpdir(), "cueloop-sdk-interrupt-"));
+  const harness = createTestSdkHarness();
+  const server = new DaemonServer({
+    home,
+    idleExitMs: 0,
+    threadAgent: { enabled: true, adapter: harness.adapter },
+  });
+
+  server.start();
+
+  try {
+    const program = Effect.gen(function* () {
+      const sdk = yield* CueloopSdk;
+      const thread = yield* sdk.threads.create({
+        workspace: { repoRoot: home, branch: "main" },
+        artifact: { type: "plan", content: "Explain", meta: {} },
+      });
+      const accepted = yield* sdk.agents.prompt({
+        threadId: thread.id,
+        operationId: sdk.ids.operation("interrupt"),
+        text: "Explain",
+      });
+      const fiber = yield* Effect.forkChild(sdk.agents.wait(accepted));
+
+      yield* Effect.yieldNow;
+      yield* Fiber.interrupt(fiber);
+      expect(harness.cancelled()).toBe(0);
+      yield* Effect.sync(() => harness.complete());
+      const completed = yield* sdk.agents.wait(accepted);
+
+      expect(completed.outcome).toBe("completed");
+    });
+
+    await Effect.runPromise(program.pipe(Effect.provide(CueloopSdk.ownerLayer({ home }))));
+  } finally {
+    server.stop();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("lost prompt acknowledgement replays original acceptance after restart without a harness", async () => {
+  const home = mkdtempSync(join(tmpdir(), "cueloop-sdk-lost-prompt-"));
+  const harness = createTestSdkHarness();
+  let server = new DaemonServer({
+    home,
+    idleExitMs: 0,
+    threadAgent: { enabled: true, adapter: harness.adapter },
+  });
+
+  server.start();
+  const connection = await DaemonClient.connect({ home });
+
+  try {
+    const thread = await connection.sessionCreate(
+      { repoRoot: home, branch: "main" },
+      { type: "plan", content: "Explain", meta: {} },
+    );
+
+    await connection.subscribe();
+    connection.onEvent((event) => {
+      if (event.event === "agent.updated") connection.close();
+    });
+    await expect(
+      connection.agentPrompt({ id: thread.id, text: "Once", operationId: "lost-prompt" }),
+    ).rejects.toMatchObject({ kind: "connection", certainty: "unknown" });
+    const inspect = await DaemonClient.connect({ home });
+    const accepted = await inspect.agentGet(thread.id);
+
+    inspect.close();
+    server.stop();
+    server = new DaemonServer({ home, idleExitMs: 0, threadAgent: { enabled: true } });
+    server.start();
+    const sdk = await connectOwnerSdk({ home });
+
+    try {
+      const replay = await sdk.agents.prompt({
+        threadId: sdk.ids.thread(thread.id),
+        operationId: sdk.ids.operation("lost-prompt"),
+        text: "Once",
+      });
+
+      expect(replay.submissionIds).toEqual(
+        accepted.promptOperations![0]!.result.map(sdk.ids.submission),
+      );
+      expect((await sdk.agents.get(sdk.ids.thread(thread.id))).submissions).toHaveLength(1);
+      expect((await sdk.agents.wait(replay)).outcome).toBe("failed");
+    } finally {
+      sdk.close();
+    }
+  } finally {
+    connection.close();
+    server.stop();
+    rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test("SDK identity types distinguish Thread, operation, and submission capabilities", () => {
+  type ThreadId = import("./daemon-sdk").SdkThreadId;
+  type OperationId = import("./daemon-sdk").SdkOperationId;
+  type SubmissionId = import("./daemon-sdk").SdkSubmissionId;
+  type Review = import("./daemon-sdk").ReviewDaemonSdk;
+  const operationIsThread: OperationId extends ThreadId ? true : false = false;
+  const submissionIsOperation: SubmissionId extends OperationId ? true : false = false;
+  const reviewHasAgent: "agents" extends keyof Review ? true : false = false;
+  const reviewCreatesThread: "create" extends keyof Review["threads"] ? true : false = false;
+
+  expect([operationIsThread, submissionIsOperation, reviewHasAgent, reviewCreatesThread]).toEqual([
+    false,
+    false,
+    false,
+    false,
+  ]);
+});