@cueloop/client 0.1.0-alpha.7 → 0.1.0-alpha.70

package/src/clipboard.ts

@@ -0,0 +1,33 @@
+/**
+ * Best-effort system clipboard. Each platform has its own tool; we try them in
+ * order and report whether one worked, so the caller can fall back to printing
+ * the line (the over-SSH case, where no clipboard tool exists). Mirrors how
+ * herdr confirms a copy.
+ */
+
+/** The clipboard-write commands to try, most-preferred first, for this platform. */
+export function clipboardCommands(platform: NodeJS.Platform = process.platform): string[][] {
+  if (platform === "darwin") return [["pbcopy"]];
+  if (platform === "win32") return [["clip.exe"]];
+
+  return [["wl-copy"], ["xclip", "-selection", "clipboard"], ["xsel", "--clipboard", "--input"]];
+}
+
+/** Copy `text` to the clipboard; false when no tool is available or all fail. */
+export async function copyToClipboard(text: string): Promise<boolean> {
+  for (const command of clipboardCommands()) {
+    try {
+      const proc = Bun.spawn(command, {
+        stdin: Buffer.from(text),
+        stdout: "ignore",
+        stderr: "ignore",
+      });
+
+      if ((await proc.exited) === 0) return true;
+    } catch {
+      // tool not installed - try the next one
+    }
+  }
+
+  return false;
+}

package/src/components/AnnotatableFileView.stories.tsx

@@ -0,0 +1,42 @@
+import React from "react";
+import { SCHEMA_VERSION, type Thread } from "@cueloop/schema";
+import { DARK } from "../theme";
+import type { Story, StoryMeta } from "./story";
+import { AnnotatableFileView } from "./AnnotatableFileView";
+
+export const meta: StoryMeta = { title: "Surfaces/AnnotatableFileView" };
+
+const SAMPLE = `export function add(a: number, b: number): number {\n  return a + b;\n}\n`;
+
+const SESSION: Thread = {
+  schemaVersion: SCHEMA_VERSION,
+  id: "ses_story",
+  workspace: { repoRoot: "/repo", branch: "main" },
+  artifact: { type: "plan", content: "# Plan\n", meta: {} },
+  revisions: [{ revision: 1, content: "# Plan\n", submittedAt: "2026-01-01T00:00:00Z" }],
+  annotations: [],
+  verdict: null,
+  status: "pending",
+  createdAt: "2026-01-01T00:00:00Z",
+};
+
+const noop = (): void => {};
+
+export const Loaded: Story = {
+  render: () => (
+    <AnnotatableFileView
+      path="src/add.ts"
+      loadContents={() => Promise.resolve(SAMPLE)}
+      session={SESSION}
+      quickActions={[]}
+      observer={false}
+      onAddComment={noop}
+      onReply={noop}
+      onUpdateAnnotation={noop}
+      onExit={noop}
+      theme={DARK}
+    />
+  ),
+  expectedColors: [DARK.textDim],
+  size: { width: 60, height: 12 },
+};

package/src/components/AnnotatableFileView.test.tsx

@@ -0,0 +1,102 @@
+/**
+ * A project file is its own annotation surface: selecting a line and typing leaves a comment whose
+ * anchor quotes that file line, handed up as an Anchor the app persists with a file target.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import { testRender } from "@opentui/react/test-utils";
+import React from "react";
+import { SCHEMA_VERSION, type Anchor, type Thread } from "@cueloop/schema";
+import { AnnotatableFileView } from "./AnnotatableFileView";
+import { DARK } from "../theme";
+import { dragText, typeText, pressKey, waitForText } from "../test-support";
+
+const SAMPLE = "export function add(a: number, b: number) {\n  return a + b;\n}\n";
+
+function planSession(): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_plan",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n", meta: {} },
+    revisions: [{ revision: 1, content: "# Plan\n", submittedAt: "2026-01-01T00:00:00Z" }],
+    annotations: [],
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00Z",
+  };
+}
+
+const noop = (): void => {};
+
+describe("AnnotatableFileView", () => {
+  test("commenting a file line hands up an anchor that quotes the line", async () => {
+    const onAddComment = mock((_anchor: Anchor, _body: string) => {});
+    const setup = await testRender(
+      <AnnotatableFileView
+        path="src/add.ts"
+        loadContents={() => Promise.resolve(SAMPLE)}
+        session={planSession()}
+        quickActions={[]}
+        observer={false}
+        onAddComment={onAddComment}
+        onReply={noop}
+        onUpdateAnnotation={noop}
+        onExit={noop}
+        theme={DARK}
+      />,
+      { width: 64, height: 12 },
+    );
+
+    // Act - select the middle line, type a comment, send it
+    await waitForText(setup, "return a + b");
+    await dragText(setup, "return a + b", "return a + b", "return a + b".length);
+    await typeText(setup, "why not reduce?");
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert - the surface built an anchor quoting the file line and handed it up with the body
+    expect(onAddComment).toHaveBeenCalled();
+    const [anchor, body] = onAddComment.mock.calls[0]!;
+    expect(anchor.quote).toContain("return a + b");
+    expect(body).toContain("why not reduce?");
+
+    setup.renderer.destroy();
+  });
+
+  test("a head-side (deleted-line) note never rebinds onto the current file", async () => {
+    const session = planSession();
+    // a note left on the removed side of this file: the worktree view must not show it
+    session.annotations = [
+      {
+        id: "h1",
+        kind: "comment",
+        anchor: { quote: "return a + b", prefix: "", suffix: "" },
+        target: { kind: "file", path: "src/add.ts", rev: "head" },
+        body: "deleted-side note",
+        createdAt: "2026-01-01T00:00:00Z",
+      },
+    ];
+    const setup = await testRender(
+      <AnnotatableFileView
+        path="src/add.ts"
+        loadContents={() => Promise.resolve(SAMPLE)}
+        session={session}
+        quickActions={[]}
+        observer={false}
+        onAddComment={noop}
+        onReply={noop}
+        onUpdateAnnotation={noop}
+        onExit={noop}
+        theme={DARK}
+      />,
+      { width: 64, height: 12 },
+    );
+
+    await waitForText(setup, "return a + b");
+
+    // Assert - the current file shows, but the head-side note is not attached to it
+    expect(setup.captureCharFrame()).not.toContain("deleted-side note");
+
+    setup.renderer.destroy();
+  });
+});

package/src/components/AnnotatableFileView.tsx

@@ -0,0 +1,126 @@
+// A project file shown as its own annotatable surface: the file's lines render through the diff
+// sheet as context rows (one line-number gutter, no +/- sign), so selecting text leaves a comment
+// anchored to the file exactly as a plan or diff comment is. Used where a review session exists to
+// hold the notes; the bare-launch welcome shell uses the read-only FileContentsView instead.
+
+import React, { useEffect, useRef, useState } from "react";
+import { makeAnchor, annotationTarget, type Anchor, type Thread } from "@cueloop/schema";
+import type { Theme } from "../theme";
+import type { QuickAction } from "../config";
+import { useComponentTheme } from "./theme-context";
+import { DiffContentView } from "./DiffContentView";
+import { diffRowBlocks, fileContentsRows, marksByRows } from "../view-diff";
+
+export interface AnnotatableFileViewProps {
+  path: string;
+  loadContents: (path: string) => Promise<string | null>;
+  session: Thread;
+  quickActions: QuickAction[];
+  observer: boolean;
+  resolved?: boolean;
+  suspended?: boolean;
+  focusedAnnotationId?: string;
+  onFocusAnnotation?: (annotationId: string | undefined) => void;
+  onComposingChange?: (composing: boolean) => void;
+  onCursorChange?: (rowIndex: number) => void;
+  onObserverBlocked?: (reason: "observer" | "resolved") => void;
+  /** Persist a comment on this file; the view built the anchor against the file's own lines. */
+  onAddComment: (anchor: Anchor, body: string) => void;
+  onReply: (rootAnnotationId: string, body: string) => void;
+  onUpdateAnnotation: (id: string, body: string) => void;
+  onExit: () => void;
+  theme?: Theme;
+}
+
+/** A finished read for a specific path; `lines` is null when the file could not be read. */
+interface FileLoad {
+  path: string;
+  lines: string[] | null;
+}
+
+export function AnnotatableFileView(props: AnnotatableFileViewProps): React.ReactNode {
+  const tokens = useComponentTheme(props.theme);
+  const [loaded, setLoaded] = useState<FileLoad | null>(null);
+  const loadRef = useRef(props.loadContents);
+  useEffect(() => {
+    loadRef.current = props.loadContents;
+  });
+
+  useEffect(() => {
+    let alive = true;
+    void loadRef.current(props.path).then(
+      (contents) => {
+        if (alive)
+          setLoaded({ path: props.path, lines: contents === null ? null : contents.split("\n") });
+      },
+      () => {
+        if (alive) setLoaded({ path: props.path, lines: null });
+      },
+    );
+
+    return () => {
+      alive = false;
+    };
+  }, [props.path]);
+
+  if (loaded === null || loaded.path !== props.path) {
+    return (
+      <box style={{ flexGrow: 1, paddingLeft: 1, paddingTop: 1 }}>
+        <text fg={tokens.textDim}>loading...</text>
+      </box>
+    );
+  }
+  if (loaded.lines === null) {
+    return (
+      <box
+        style={{ flexGrow: 1, alignItems: "center", justifyContent: "center", paddingBottom: 2 }}
+      >
+        <text fg={tokens.textDim}>File deleted</text>
+      </box>
+    );
+  }
+
+  const rows = fileContentsRows(props.path, loaded.lines.join("\n"));
+  // the file's worktree notes: these rows are the current file, so a head-side (deleted-line) note
+  // must stay orphaned here rather than rebind to similar surviving text
+  const fileNotes = props.session.annotations.filter((annotation) => {
+    const target = annotationTarget(annotation);
+
+    return target.kind === "file" && target.path === props.path && target.rev === "worktree";
+  });
+
+  return (
+    <DiffContentView
+      rows={rows}
+      session={props.session}
+      marks={marksByRows(fileNotes, rows, props.focusedAnnotationId)}
+      quickActions={props.quickActions}
+      observer={props.observer}
+      commentsEnabled
+      resolved={props.resolved}
+      suspended={props.suspended}
+      fileView
+      onComposingChange={props.onComposingChange}
+      onObserverBlocked={props.onObserverBlocked}
+      onCursorChange={props.onCursorChange}
+      focusedAnnotationId={props.focusedAnnotationId}
+      onFocusAnnotation={props.onFocusAnnotation}
+      onAnnotate={(span, body) =>
+        props.onAddComment(
+          makeAnchor(
+            diffRowBlocks(rows),
+            span.start.blockIndex,
+            span.start.char,
+            span.end.char,
+            span.end.blockIndex,
+          ),
+          body,
+        )
+      }
+      onReply={props.onReply}
+      onUpdateAnnotation={props.onUpdateAnnotation}
+      onExit={props.onExit}
+      theme={props.theme}
+    />
+  );
+}

package/src/components/AnnotationCards.stories.tsx

@@ -0,0 +1,87 @@
+import React from "react";
+import type { Annotation } from "@cueloop/schema";
+import { DARK } from "../theme";
+import { annotationPaletteFor } from "../annotation-palette";
+import { slashItemsFrom } from "../slash-palette";
+import { DEFAULT_QUICK_ACTIONS } from "../config";
+import type { Story, StoryMeta } from "./story";
+import { CommentRow, ComposerPalette, DiscussionCard } from "./AnnotationCards";
+
+export const meta: StoryMeta = { title: "Chrome/AnnotationCards" };
+
+const palette = annotationPaletteFor(DARK);
+
+function annotation(id: string, body: string, author?: string): Annotation {
+  const comment: Annotation = {
+    id,
+    kind: "comment",
+    anchor: { quote: "the daemon", prefix: "", suffix: "" },
+    body,
+    createdAt: "2026-09-07T10:00:00.000Z",
+  };
+
+  if (author !== undefined) comment.author = author;
+
+  return comment;
+}
+
+// A two-voice discussion: the owner's comment then a collaborator's reply, each
+// segment wearing its own accent edge.
+export const TwoVoices: Story = {
+  render: () => (
+    <DiscussionCard
+      tokens={DARK}
+      segments={[
+        {
+          color: palette.cardEdge,
+          node: <CommentRow annotation={annotation("a", "Which daemon?")} tokens={DARK} />,
+        },
+        {
+          color: DARK.text,
+          node: (
+            <CommentRow
+              annotation={annotation("b", "The one the CLI spawns.", "fp:collab")}
+              tokens={DARK}
+            />
+          ),
+        },
+      ]}
+    />
+  ),
+  expectedColors: [palette.cardEdge, DARK.text],
+  size: { width: 60, height: 8 },
+};
+
+export const FocusedCard: Story = {
+  render: () => (
+    <DiscussionCard
+      focused
+      tokens={DARK}
+      segments={[
+        {
+          color: palette.cardEdge,
+          node: (
+            <CommentRow annotation={annotation("a", "Needs an eviction story.")} tokens={DARK} />
+          ),
+        },
+      ]}
+    />
+  ),
+  expectedColors: [DARK.text],
+  size: { width: 60, height: 6 },
+};
+
+// The palette a leading "/" opens under the composer, with the second item selected.
+export const SlashPaletteOpen: Story = {
+  render: () => (
+    <ComposerPalette
+      slashActive
+      slashItems={slashItemsFrom(DEFAULT_QUICK_ACTIONS)}
+      slashIndex={1}
+      inline={null}
+      tokens={DARK}
+    />
+  ),
+  expectedColors: [DARK.accent, DARK.textDim],
+  size: { width: 90, height: 8 },
+};

package/src/components/AnnotationCards.tsx

@@ -0,0 +1,303 @@
+/**
+ * The inline comment pieces every annotated surface renders: the composer (a
+ * textarea in a card row), the "/" palette and inline completion hint below it,
+ * the edge-segmented discussion card, and one comment row. The plan thread view
+ * and the diff sheet both draw their comments with these, so a discussion looks
+ * and behaves the same on prose and on code.
+ */
+
+import React, { useEffect, useRef, useState } from "react";
+import type { BoxRenderable, KeyBinding, TextareaRenderable } from "@opentui/core";
+import type { Annotation } from "@cueloop/schema";
+import type { Theme } from "../theme";
+import { lighten } from "../annotation-palette";
+import { useFrameMeasure } from "../use-frame-measure";
+import type { InlineSlash, SlashItem } from "../slash-palette";
+
+/* -------------------------------------------------------------- composer */
+
+// cmd+enter sends (super under the kitty protocol, meta where cmd arrives
+// ESC-prefixed, ctrl as the fallback where the terminal itself consumes
+// cmd+enter); plain enter breaks the line
+const COMPOSE_KEY_BINDINGS: KeyBinding[] = [
+  { name: "return", super: true, action: "submit" },
+  { name: "return", meta: true, action: "submit" },
+  { name: "return", ctrl: true, action: "submit" },
+  { name: "return", action: "newline" },
+  { name: "return", shift: true, action: "newline" },
+];
+
+function composeRowCount(text: string, contentWidth: number): number {
+  const usableWidth = contentWidth > 0 ? contentWidth : Number.MAX_SAFE_INTEGER;
+  let visualRowCount = 0;
+
+  for (const line of text.split("\n")) {
+    visualRowCount += Math.max(1, Math.ceil(line.length / usableWidth));
+  }
+
+  // no cap: the card is the discussion, and folding is its containment
+  return Math.max(1, visualRowCount);
+}
+
+export function Composer({
+  seed,
+  glyph,
+  tokens,
+  onSave,
+  onReady,
+  onInput,
+}: {
+  seed: string;
+  glyph: string;
+  tokens: Theme;
+  onSave: (body: string) => void;
+  onReady: () => void;
+  onInput: (text: string) => void;
+}): React.ReactNode {
+  const editorRef = useRef<TextareaRenderable | null>(null);
+  const [rows, setRows] = useState(1);
+
+  // once per mount (the composer is keyed by its seed): later re-renders
+  // must NOT reset the caret, or input lands before a just-typed newline
+  useEffect(() => {
+    const editor = editorRef.current;
+
+    if (!editor) return;
+    editor.cursorOffset = seed.length;
+    setRows(composeRowCount(editor.plainText, editor.width));
+    onReady();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  return (
+    <box style={{ flexDirection: "row" }}>
+      <text selectable={false} fg={tokens.text} style={{ flexShrink: 0 }}>{`${glyph} `}</text>
+      <textarea
+        ref={editorRef}
+        focused
+        initialValue={seed}
+        cursorStyle={{ style: "block", blinking: true }}
+        keyBindings={COMPOSE_KEY_BINDINGS}
+        onSubmit={() => onSave(editorRef.current?.plainText ?? "")}
+        onContentChange={() => {
+          const editor = editorRef.current;
+
+          if (!editor) return;
+          setRows(composeRowCount(editor.plainText, editor.width));
+          onInput(editor.plainText);
+        }}
+        style={{
+          height: rows,
+          flexGrow: 1,
+          backgroundColor: "transparent",
+          focusedBackgroundColor: "transparent",
+          textColor: tokens.text,
+          focusedTextColor: tokens.text,
+        }}
+      />
+    </box>
+  );
+}
+
+/* ---------------------------------------------------------- slash palette */
+
+function SlashList({
+  items,
+  selected,
+  tokens,
+}: {
+  items: SlashItem[];
+  selected: number;
+  tokens: Theme;
+}): React.ReactNode {
+  const WINDOW = 5;
+  const start = Math.max(0, Math.min(selected - 2, items.length - WINDOW));
+  const visible = items.slice(start, start + WINDOW);
+
+  if (items.length === 0) return <text fg={tokens.textDim}>no matching actions</text>;
+
+  const nameColumn = Math.min(36, Math.max(16, ...visible.map((item) => item.name.length + 5)));
+
+  return (
+    <box style={{ flexDirection: "column" }}>
+      {visible.map((item, offset) => {
+        const index = start + offset;
+        const isSelected = index === selected;
+        const name = `${isSelected ? "→ " : "  "}/${item.name}`.padEnd(nameColumn);
+
+        return (
+          <text key={item.name} style={{ flexShrink: 0, wrapMode: "none" }}>
+            <span fg={isSelected ? tokens.accent : tokens.textMuted}>{name}</span>
+            <span fg={tokens.textDim}>{item.description}</span>
+          </text>
+        );
+      })}
+      {items.length > WINDOW ? (
+        <text fg={tokens.textDim}>{`(${selected + 1}/${items.length})`}</text>
+      ) : null}
+    </box>
+  );
+}
+
+/** Below the composer: the palette list for a leading "/", else the inline tab-hint, else nothing. */
+export function ComposerPalette({
+  slashActive,
+  slashItems,
+  slashIndex,
+  inline,
+  tokens,
+}: {
+  slashActive: boolean;
+  slashItems: SlashItem[];
+  slashIndex: number;
+  inline: InlineSlash | null;
+  tokens: Theme;
+}): React.ReactNode {
+  if (slashActive) {
+    return (
+      <box style={{ flexDirection: "column", marginLeft: 3 }}>
+        <SlashList
+          items={slashItems}
+          selected={Math.min(slashIndex, Math.max(0, slashItems.length - 1))}
+          tokens={tokens}
+        />
+      </box>
+    );
+  }
+  if (inline === null) return null;
+
+  return (
+    <box style={{ flexDirection: "row", marginLeft: 3 }}>
+      <text>
+        <span fg={tokens.textDim}>{"⇥ "}</span>
+        <span fg={tokens.accent}>{`/${inline.suggestion.name}`}</span>
+        <span fg={tokens.textDim}>{`  ${inline.suggestion.description}`}</span>
+      </text>
+    </box>
+  );
+}
+
+/* ------------------------------------------------------------ discussion card */
+
+/** One card row group with its own accent-edge color, one per voice. */
+export interface EdgeSegment {
+  color: string;
+  node: React.ReactNode;
+}
+
+/**
+ * The comment-card frame. The accent edge is drawn by hand so that (a) its
+ * corner cells are half-height glyphs ("╷"/"╵") terminating flush with the
+ * hairline rows, and (b) each voice's rows carry their own edge color with
+ * zero gap. Focus lightens every segment; the hairlines never change.
+ */
+export function DiscussionCard({
+  segments,
+  tokens,
+  focused = false,
+  onFocus,
+}: {
+  segments: EdgeSegment[];
+  tokens: Theme;
+  focused?: boolean;
+  onFocus?: () => void;
+}): React.ReactNode {
+  const segmentRefs = useRef<Array<BoxRenderable | null>>([]);
+  const noHeights: number[] = [];
+  const heights = useFrameMeasure(
+    () => segmentRefs.current.map((renderable) => renderable?.height ?? 0),
+    (left, right) => left.join() === right.join(),
+    noHeights,
+  );
+
+  const edgeColor = (color: string): string => (focused ? lighten(color) : color);
+  const glyphs = focused
+    ? { top: "╻", middle: "┃", bottom: "╹" }
+    : { top: "╷", middle: "│", bottom: "╵" };
+  const edgeRows: Array<{ glyph: string; color: string }> = [
+    {
+      glyph: glyphs.top,
+      color: edgeColor(segments[0]?.color ?? tokens.border),
+    },
+  ];
+
+  for (let index = 0; index < segments.length; index++) {
+    const segmentRows = Math.max(1, heights[index] ?? 1);
+
+    for (let row = 0; row < segmentRows; row++) {
+      edgeRows.push({
+        glyph: glyphs.middle,
+        color: edgeColor(segments[index]!.color),
+      });
+    }
+  }
+  edgeRows.push({
+    glyph: glyphs.bottom,
+    color: edgeColor(segments[segments.length - 1]?.color ?? tokens.border),
+  });
+
+  return (
+    <box style={{ flexDirection: "row", marginTop: 1, marginLeft: 2 }}>
+      <text selectable={false} style={{ flexShrink: 0, width: 1 }}>
+        {edgeRows.map((row, index) => (
+          <span key={index} fg={row.color}>
+            {index < edgeRows.length - 1 ? `${row.glyph}\n` : row.glyph}
+          </span>
+        ))}
+      </text>
+      <box
+        onMouseDown={onFocus}
+        style={{
+          flexGrow: 1,
+          flexDirection: "column",
+          border: ["top", "right", "bottom"],
+          borderStyle: "single",
+          borderColor: tokens.border,
+          backgroundColor: "transparent",
+          paddingLeft: 1,
+          paddingRight: 1,
+        }}
+      >
+        {segments.map((segment, index) => (
+          <box
+            key={index}
+            ref={(renderable: BoxRenderable | null) => {
+              segmentRefs.current[index] = renderable;
+            }}
+            style={{ flexDirection: "column" }}
+          >
+            {segment.node}
+          </box>
+        ))}
+      </box>
+    </box>
+  );
+}
+
+export function CommentRow({
+  annotation,
+  tokens,
+}: {
+  annotation: Annotation;
+  tokens: Theme;
+}): React.ReactNode {
+  // own comments (no author) wear the filled dot, collaborators the outline
+  const own = annotation.author === undefined;
+  const glyph = own ? "●" : "○";
+  const glyphColor = own ? tokens.text : tokens.textMuted;
+
+  return (
+    <box style={{ flexDirection: "column" }}>
+      {annotation.body.split("\n").map((line, lineIndex) => (
+        <box key={lineIndex} style={{ flexDirection: "row" }}>
+          <text selectable={false} fg={glyphColor} style={{ flexShrink: 0 }}>
+            {lineIndex === 0 ? `${glyph} ` : "  "}
+          </text>
+          <text fg={tokens.text} style={{ wrapMode: "word", flexGrow: 1, flexShrink: 1 }}>
+            {line}
+          </text>
+        </box>
+      ))}
+    </box>
+  );
+}