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

package/src/app/App.diff.test.tsx

@@ -0,0 +1,313 @@
+/** Diff-review flow in the virtual terminal: the diff sheet annotates like the thread view. */
+
+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 React from "react";
+import { DaemonServer } from "@cueloop/daemon";
+import type { Thread } from "@cueloop/schema";
+import { App } from "./App";
+import { pullRequestReviewLayout } from "./launch-layout";
+import { DARK } from "../appearance/theme";
+import {
+  clickText,
+  dragText,
+  isolateUserConfig,
+  navCommand,
+  press,
+  pressKey,
+  renderReadyApp,
+  typeText,
+  waitForState,
+  waitForText,
+} from "../testing/test-support";
+
+const PATCH = `diff --git a/src/store.ts b/src/store.ts
+index 111..222 100644
+--- a/src/store.ts
++++ b/src/store.ts
+@@ -1,4 +1,4 @@
+ export class Store {
+-  private items = [];
++  private items = new Map();
+ }
+`;
+
+let home: string;
+let restoreUserConfig: () => void;
+let server: DaemonServer;
+let session: Thread;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-diff-"));
+  restoreUserConfig = isolateUserConfig(home);
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "diff", content: PATCH, meta: { title: "working tree" } },
+  });
+});
+afterEach(() => {
+  restoreUserConfig();
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+async function renderApp(sessionId = session.id) {
+  const setup = await renderReadyApp(<App home={home} sessionId={sessionId} />, {
+    width: 120,
+    height: 30,
+  });
+
+  await waitForText(setup, "new Map()");
+
+  return setup;
+}
+
+describe("diff review", () => {
+  test("a submitted JJ review uses the existing refresh action and shows its source", async () => {
+    const jjReview = server.core.sessionCreate({
+      workspace: { repoRoot: "/repo", branch: "jj" },
+      artifact: {
+        type: "diff",
+        content: PATCH,
+        meta: { title: "JJ change", vcs: "jj", vcsChangeId: "abcdefghijklmnopqrstuvwxyzaaaaaa" },
+      },
+    });
+    const setup = await renderReadyApp(<App home={home} sessionId={jjReview.id} />, {
+      width: 120,
+      height: 30,
+    });
+
+    await waitForText(setup, "new Map()");
+    expect(setup.captureCharFrame()).toContain("vcs: jj");
+    expect(setup.captureCharFrame()).toContain("refresh");
+  });
+
+  test("pull request review shows its brief beside Changes and signals a moved head", async () => {
+    const pullRequest = server.core.sessionCreate({
+      workspace: { repoRoot: "/repo", branch: "detached" },
+      artifact: {
+        type: "diff",
+        content: PATCH,
+        meta: {
+          title: "Fix store",
+          pr: "org/repo#42",
+          prBrief: "# Fix store\n\n## PR description\n\nUse a map.",
+          prHeadSha: "head-1",
+          prRefreshHeadSha: "head-2",
+        },
+      },
+    });
+    const setup = await renderReadyApp(
+      <App home={home} sessionId={pullRequest.id} layout={pullRequestReviewLayout()} />,
+      { width: 160, height: 30 },
+    );
+
+    await waitForText(setup, "Use a map.");
+    await waitForText(setup, "new Map()");
+    await waitForText(setup, "refresh");
+    const refreshSpan = setup
+      .captureSpans()
+      .lines.flatMap((line) => line.spans)
+      .find((span) => span.text.includes("refresh"));
+    const refreshColor = refreshSpan?.fg
+      .toInts()
+      .slice(0, 3)
+      .map((part) => part.toString(16).padStart(2, "0"))
+      .join("");
+
+    expect(`#${refreshColor}`).toBe(DARK.warning);
+  });
+
+  test("a resolved pull request review does not offer refresh", async () => {
+    const pullRequest = server.core.sessionCreate({
+      workspace: { repoRoot: "/repo", branch: "detached" },
+      artifact: {
+        type: "diff",
+        content: PATCH,
+        meta: {
+          title: "Fix store",
+          pr: "org/repo#42",
+          prHeadSha: "head-1",
+          prRefreshHeadSha: "head-2",
+        },
+      },
+    });
+
+    server.core.sessionSendMessage(pullRequest.id, "approved", "Ready to merge.");
+    const setup = await renderReadyApp(
+      <App home={home} sessionId={pullRequest.id} layout={pullRequestReviewLayout()} />,
+      { width: 160, height: 30 },
+    );
+
+    await waitForText(setup, "new Map()");
+    expect(setup.captureCharFrame()).not.toContain("refresh");
+  });
+
+  test("renders file header, hunks, and signed lines", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    // Assert
+    const frame = setup.captureCharFrame();
+
+    expect(frame).toContain("src/store.ts");
+    expect(frame).toContain("@@ -1,4 +1,4 @@");
+    expect(frame).toMatch(/- {2,}private items = \[\];/);
+    expect(frame).toMatch(/\+ {2,}private items = new Map\(\);/);
+  });
+
+  test("a drag marks the code, typing comments on it, and the comment lands in feedback", async () => {
+    // Arrange
+    const setup = await renderApp();
+
+    // Act - mark "new Map()" on the added line and just start typing, as in the thread view
+    await dragText(setup, "new Map()", "new Map()", "new Map()".length);
+    await typeText(setup, "Map needs an eviction story.");
+    await waitForText(setup, "● Map needs an eviction story.");
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert - the discussion card hangs under the line; the anchor is the marked words
+    await waitForState(setup, () => server.core.sessionGet(session.id).annotations.length === 1);
+    await waitForText(setup, "● Map needs an eviction story.");
+    expect(server.core.sessionGet(session.id).annotations[0]!.anchor.quote).toBe("new Map()");
+
+    // Act - submit with the session chord (cmd+enter, no composer open), cycle to request changes
+    await pressKey(setup, "RETURN", { meta: true });
+    await waitForText(setup, "[approve]");
+    await press(setup, "right");
+    await waitForText(setup, "[changes]");
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert
+    await waitForText(setup, "feedback sent");
+    const resolved = server.core.sessionGet(session.id);
+
+    expect(resolved.message!.body).toContain("new Map()");
+    expect(resolved.message!.body).toContain("Map needs an eviction story.");
+  });
+
+  test("pasting an image into a diff comment drops in an [Image #n] placeholder", async () => {
+    // Arrange - mark the added line and open the inline comment composer
+    const setup = await renderApp();
+
+    await dragText(setup, "new Map()", "new Map()", "new Map()".length);
+    await typeText(setup, "see ");
+
+    // Act - a burst of control bytes stands in for the binary an image paste delivers
+    await setup.mockInput.pasteBracketedText("
");
+
+    // Assert - the same placeholder the summary composer shows
+    await waitForText(setup, "see [Image #1]");
+  });
+
+  test("a comment reopens with its mark painted on the code", async () => {
+    // Arrange - a stored comment anchored to the added line's words
+    server.core.sessionAnnotate(session.id, {
+      id: "a_existing",
+      kind: "comment",
+      anchor: { quote: "new Map()", prefix: "  private items = ", suffix: ";" },
+      body: "Existing note.",
+    });
+
+    // Act
+    const setup = await renderApp();
+
+    // Assert
+    await waitForText(setup, "● Existing note.");
+  });
+
+  test("option+c folds the caret's file to its band; its title restores the body", async () => {
+    // Arrange - the caret opens on the file's first code line
+    const setup = await renderApp();
+
+    // Act
+    await navCommand(setup, "c");
+
+    // Assert - the body is gone but the band (with its counts) remains
+    await waitForState(setup, () => !setup.captureCharFrame().includes("new Map()"));
+    const collapsed = setup.captureCharFrame();
+
+    expect(collapsed).toContain("src/store.ts");
+    expect(collapsed).toContain("+1");
+
+    // Act - the title unfolds it again
+    await clickText(setup, "src/store.ts");
+
+    // Assert
+    await waitForText(setup, "new Map()");
+  });
+
+  test("curation needs full file contents; a legacy diff answers", async () => {
+    // Arrange - the session carries no artifact.files
+    const setup = await renderApp();
+
+    // Act
+    await navCommand(setup, "x");
+
+    // Assert
+    await waitForText(setup, "hunk curation needs full file contents");
+  });
+
+  test("rejecting the only change empties the curated working copy", async () => {
+    // Arrange - a diff session that carries full file contents
+    const withFiles = server.core.sessionCreate({
+      workspace: { repoRoot: "/repo", branch: "main" },
+      artifact: {
+        type: "diff",
+        content: PATCH,
+        meta: { title: "working tree" },
+        files: [
+          {
+            path: "src/store.ts",
+            oldContents: "export class Store {\n  private items = [];\n}\n",
+            newContents: "export class Store {\n  private items = new Map();\n}\n",
+            status: "modified",
+          },
+        ],
+      },
+    });
+    const setup = await renderApp(withFiles.id);
+
+    // Act - place the caret on the added line and reject its change
+    await clickText(setup, "new Map()");
+    await navCommand(setup, "x");
+
+    // Assert - the single change is gone, so the curated working copy is empty
+    await waitForState(setup, () => server.core.sessionGet(withFiles.id).workingCopy === "");
+    const stored = server.core.sessionGet(withFiles.id);
+
+    expect(stored.workingCopy).toBe("");
+    expect(setup.captureCharFrame()).not.toContain("change rejected");
+  });
+
+  test("a diff opens with the Changes column listing every changed file", async () => {
+    // Arrange - two changed files; config.ts is not in the patch text, so it can
+    // only appear here by way of the Changes column reading artifact.files
+    const withFiles = server.core.sessionCreate({
+      workspace: { repoRoot: "/repo", branch: "main" },
+      artifact: {
+        type: "diff",
+        content: PATCH,
+        meta: { title: "working tree" },
+        files: [
+          { path: "src/store.ts", oldContents: "a", newContents: "b", status: "modified" },
+          { path: "src/config.ts", oldContents: "", newContents: "c", status: "added" },
+        ],
+      },
+    });
+    const setup = await renderReadyApp(<App home={home} sessionId={withFiles.id} />, {
+      width: 120,
+      height: 30,
+    });
+
+    await waitForText(setup, "cueloop");
+
+    // Assert - the context default opens the column for a diff, so both files show
+    await waitForText(setup, "config.ts");
+    expect(setup.captureCharFrame()).toContain("store.ts");
+  });
+});

package/src/app/App.export.test.tsx

@@ -0,0 +1,105 @@
+/** Tier-2 wiring for the notes-vault export: with [integrations.obsidian] set to export on resolve, submitting a review writes the note into the vault and surfaces the path in the status line. */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import React from "react";
+import { DaemonServer } from "@cueloop/daemon";
+import type { Thread } from "@cueloop/schema";
+import { App } from "./App";
+import {
+  isolateUserConfig,
+  waitForState,
+  waitForText,
+  pressKey,
+  renderReadyApp,
+} from "../testing/test-support";
+
+const PLAN = `# Migration Plan
+
+Move the store atomically.
+`;
+
+let home: string;
+let vault: string;
+let server: DaemonServer;
+let session: Thread;
+let restoreUserConfig: () => void;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-app-export-"));
+  vault = join(home, "vault");
+  mkdirSync(vault);
+  const configPath = join(home, "config.toml");
+
+  writeFileSync(
+    configPath,
+    `[integrations.obsidian]\nvault = ${JSON.stringify(vault)}\nexportOn = "message"\n`,
+  );
+  restoreUserConfig = isolateUserConfig(home, "config.toml");
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: {
+      type: "plan",
+      content: PLAN,
+      meta: { title: "Migration Plan", planPath: "plan.md" },
+    },
+  });
+});
+afterEach(() => {
+  restoreUserConfig();
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("obsidian export on resolve", () => {
+  test("submitting a review writes the plan into the vault and shows the path", async () => {
+    // Arrange
+    const setup = await renderReadyApp(<App home={home} sessionId={session.id} />, {
+      width: 120,
+      height: 32,
+    });
+
+    await waitForText(setup, "cueloop");
+
+    // Act
+    await pressKey(setup, "RETURN", { meta: true }); // open the submit overlay, keep the default message (approve)
+
+    // Assert
+    await waitForText(setup, "[approve]");
+
+    // Act
+    await pressKey(setup, "RETURN", { meta: true }); // submit
+
+    // Assert
+    // the export is an async round-trip after resolve; the status line lands
+    // on a later render than the file write
+    const dir = join(vault, "cueloop");
+
+    await waitForState(setup, () => existsSync(dir));
+    await waitForText(setup, "exported to");
+
+    const notes = readdirSync(dir);
+
+    expect(notes.length).toBe(1);
+    expect(notes[0]).toMatch(/^\d{4}-\d{2}-\d{2} - Migration Plan\.md$/);
+    const written = readFileSync(join(dir, notes[0]!), "utf8");
+
+    expect(written).toContain("source: cueloop");
+    expect(written).toContain(`session: ${session.id}`);
+    expect(written).toContain("message: approved");
+    expect(written).toContain("Move the store atomically.");
+    expect(setup.captureCharFrame()).toContain("exported to");
+  });
+});

package/src/app/App.focus.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, test } from "bun:test";
+import { nextFocusPane, reconciledFocus, threadsNavHandled, visiblePanes } from "./App";
+
+describe("threads keyboard nav", () => {
+  const base = () => {
+    let cursor = 1;
+    let opened = 0;
+
+    return {
+      setInboxCursor: (update: (cursor: number) => number) => (cursor = update(cursor)),
+      openSession: () => (opened += 1),
+      read: () => ({
+        get cursor() {
+          return cursor;
+        },
+        get opened() {
+          return opened;
+        },
+      }),
+    };
+  };
+
+  test("moves the cursor and opens only when the Threads pane is quiet and focused", () => {
+    const spy = base();
+    const call = (name: string) =>
+      threadsNavHandled({
+        focusedPane: "threads",
+        quiet: true,
+        key: { name },
+        count: 3,
+        setInboxCursor: spy.setInboxCursor,
+        openSession: spy.openSession,
+      });
+
+    expect(call("down")).toBe(true);
+    expect(spy.read().cursor).toBe(2);
+    expect(call("down")).toBe(true); // clamps at the last row
+    expect(spy.read().cursor).toBe(2);
+    expect(call("k")).toBe(true);
+    expect(spy.read().cursor).toBe(1);
+    expect(call("return")).toBe(true);
+    expect(spy.read().opened).toBe(1);
+  });
+
+  test("defers when another pane is focused, keys are owned elsewhere, or the inbox is empty", () => {
+    const spy = base();
+    const params = {
+      quiet: true,
+      key: { name: "down" },
+      count: 3,
+      setInboxCursor: spy.setInboxCursor,
+      openSession: spy.openSession,
+    };
+
+    expect(threadsNavHandled({ ...params, focusedPane: "changes" })).toBe(false);
+    expect(threadsNavHandled({ ...params, focusedPane: "threads", quiet: false })).toBe(false);
+    expect(threadsNavHandled({ ...params, focusedPane: "threads", count: 0 })).toBe(false);
+    expect(spy.read().cursor).toBe(1);
+  });
+});
+
+describe("pane focus cycle", () => {
+  test("visiblePanes lists only the open panes, in reading order", () => {
+    expect(visiblePanes(true, true, true, true)).toEqual([
+      "threads",
+      "thread",
+      "changes",
+      "project",
+    ]);
+    expect(visiblePanes(true, false, true, true)).toEqual(["threads", "changes", "project"]);
+    expect(visiblePanes(false, false, true, false)).toEqual(["changes"]);
+  });
+
+  test("nextFocusPane wraps forward and back over the visible panes", () => {
+    const panes = visiblePanes(true, false, true, true);
+
+    expect(nextFocusPane("threads", panes, false)).toBe("changes");
+    expect(nextFocusPane("project", panes, false)).toBe("threads");
+    expect(nextFocusPane("threads", panes, true)).toBe("project");
+    expect(nextFocusPane("changes", [], false)).toBe("changes");
+  });
+
+  test("reconciledFocus falls back only when the focused pane is not navigable", () => {
+    expect(reconciledFocus(["threads", "changes"], "threads")).toBeNull();
+    expect(reconciledFocus(["threads", "changes"], "thread")).toBe("threads");
+    expect(reconciledFocus(["changes", "project"], "thread")).toBe("changes");
+    expect(reconciledFocus([], "thread")).toBeNull();
+  });
+});

package/src/app/App.identity.test.tsx

@@ -0,0 +1,84 @@
+/** Reviewer identity surfaces: the Account settings tab and the author-name tooltip on a comment dot. */
+
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import React from "react";
+import { DaemonServer } from "@cueloop/daemon";
+import { App } from "./App";
+import {
+  isolateUserConfig,
+  locateText,
+  renderReadyApp,
+  waitForText,
+} from "../testing/test-support";
+
+const PLAN = "# Migration Plan\n\nThe daemon persists sessions to disk atomically.\n";
+
+let home: string;
+let restoreUserConfig: () => void;
+let server: DaemonServer;
+let sessionId: string;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "cueloop-identity-"));
+  restoreUserConfig = isolateUserConfig(home);
+  server = new DaemonServer({ home, idleExitMs: 0 });
+  server.start();
+  const session = server.core.sessionCreate({
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: {
+      type: "plan",
+      content: PLAN,
+      meta: { title: "Migration Plan", planPath: "plan.md" },
+    },
+  });
+
+  sessionId = session.id;
+});
+afterEach(() => {
+  restoreUserConfig();
+  server.stop();
+  rmSync(home, { recursive: true, force: true });
+});
+
+async function renderApp() {
+  return renderReadyApp(<App home={home} sessionId={sessionId} />, { width: 120, height: 32 });
+}
+
+test("the Account settings tab shows the display name row and the GitHub sync action", async () => {
+  const setup = await renderApp();
+
+  await setup.mockMouse.click(1, 0);
+  await waitForText(setup, "settings");
+  const menu = setup.captureCharFrame().split("\n");
+  const settingsRow = menu.findIndex((line) => line.includes("settings"));
+
+  await setup.mockMouse.click(menu[settingsRow]!.indexOf("settings") + 1, settingsRow);
+  await waitForText(setup, "Account");
+  const dialog = setup.captureCharFrame().split("\n");
+  const accountRow = dialog.findIndex((line) => line.includes("Account"));
+
+  await setup.mockMouse.click(dialog[accountRow]!.indexOf("Account") + 1, accountRow);
+  await waitForText(setup, "Display name");
+  expect(setup.captureCharFrame()).toContain("Sync from GitHub");
+});
+
+test("hovering an own comment's dot surfaces the author tooltip", async () => {
+  server.core.sessionAnnotate(sessionId, {
+    id: "a_own",
+    kind: "comment",
+    anchor: { quote: "atomically", prefix: "sessions to disk ", suffix: "." },
+    body: "My note.",
+  });
+  const setup = await renderApp();
+
+  await waitForText(setup, "● My note.");
+  // the tooltip is not painted until the pointer is over the dot
+  expect(setup.captureCharFrame()).not.toContain("you");
+  const dot = locateText(setup, "● My note.");
+
+  await setup.mockMouse.moveTo(dot.column, dot.row);
+  await waitForText(setup, "you");
+});