@cueloop/client 0.1.0-alpha.8 → 0.1.0-alpha.80

package/src/components/WelcomePlayground.test.tsx

@@ -0,0 +1,47 @@
+/**
+ * The welcome page is a real annotation surface, but ephemeral: selecting its copy and typing leaves
+ * a comment that shows inline, exactly as a file does, and it lives only in the component - there is
+ * no controller or daemon behind it, so nothing is persisted. The copy prompts the two first gestures.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { testRender } from "@opentui/react/test-utils";
+import React from "react";
+import { WelcomePlayground } from "./WelcomePlayground";
+import { DARK } from "../theme";
+import { dragText, typeText, pressKey, waitForText } from "../test-support";
+
+describe("WelcomePlayground", () => {
+  test("the copy prompts the select-and-type and the slash gestures", async () => {
+    const setup = await testRender(
+      <WelcomePlayground version="1.2.3" quickActions={[]} theme={DARK} />,
+      { width: 80, height: 24 },
+    );
+
+    await waitForText(setup, "Getting started");
+    const frame = setup.captureCharFrame();
+
+    expect(frame).toContain("start typing to leave your first comment");
+    expect(frame).toContain('type "/"');
+
+    setup.renderer.destroy();
+  });
+
+  test("selecting the copy and typing leaves a comment inline, exactly like a file", async () => {
+    const setup = await testRender(
+      <WelcomePlayground version="1.2.3" quickActions={[]} theme={DARK} />,
+      { width: 80, height: 24 },
+    );
+
+    // Act - select the practice line, type a comment, send it
+    await waitForText(setup, "quick brown fox");
+    await dragText(setup, "quick brown fox", "quick brown fox", "quick brown fox".length);
+    await typeText(setup, "my first note");
+    await pressKey(setup, "RETURN", { meta: true });
+
+    // Assert - the note renders on the surface, no controller or daemon involved
+    await waitForText(setup, "my first note");
+
+    setup.renderer.destroy();
+  });
+});

package/src/components/WelcomePlayground.tsx

@@ -0,0 +1,142 @@
+// The welcome page as a live annotation playground: the onboarding copy renders through the same
+// diff sheet a file uses, so selecting text and typing leaves a comment with the identical gesture a
+// real review uses. The notes are ephemeral - there is no file or thread behind onboarding copy, so
+// they live only in this component's state and are never stored or re-anchored. The copy teaches the
+// two first gestures: select-and-type to comment, and "/" for the quick actions and skills.
+
+import React, { useMemo, useState } from "react";
+import {
+  makeAnchor,
+  newAnnotationId,
+  SCHEMA_VERSION,
+  type Annotation,
+  type Thread,
+} from "@cueloop/schema";
+import type { Theme } from "../theme";
+import type { QuickAction } from "../config";
+import { DiffContentView } from "./DiffContentView";
+import { diffRowBlocks, fileContentsRows, marksByRows } from "../view-diff";
+
+export interface WelcomePlaygroundProps {
+  version: string;
+  quickActions: QuickAction[];
+  /** Reports whether the playground composer is open, so the shell suspends its inbox keys while typing. */
+  onComposingChange?: (composing: boolean) => void;
+  suspended?: boolean;
+  theme?: Theme;
+}
+
+const DOCS_URL = "https://cueloop.dev/docs/";
+
+/** The playground copy: a heading, the two guided prompts, a line to practice on, and the links. */
+function welcomeCopy(version: string): string {
+  return [
+    "Getting started",
+    "Comment on agent-authored work.",
+    "",
+    "This page is a playground. Nothing you write here is saved.",
+    "",
+    "Select the line below and start typing to leave your first comment:",
+    "",
+    "    The quick brown fox jumps over the lazy dog.",
+    "",
+    'While composing, type "/" to see the quick actions and skills.',
+    "",
+    "Start",
+    "  - select a thread",
+    "  - inspect files and changes",
+    "",
+    "Learn",
+    `  - docs        ${DOCS_URL}`,
+    "",
+    "Version",
+    `  - cueloop v${version}`,
+  ].join("\n");
+}
+
+/** An ephemeral thread that holds nothing but the playground's notes, so the surface groups
+ *  discussions exactly as a real review does without any of it reaching the daemon. */
+function playgroundThread(annotations: Annotation[]): Thread {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "welcome",
+    workspace: { repoRoot: "", branch: "main" },
+    artifact: { type: "plan", content: "", meta: {} },
+    revisions: [],
+    annotations,
+    message: null,
+    status: "pending",
+    createdAt: "1970-01-01T00:00:00.000Z",
+  };
+}
+
+export function WelcomePlayground(props: WelcomePlaygroundProps): React.ReactNode {
+  const [annotations, setAnnotations] = useState<Annotation[]>([]);
+  const rows = useMemo(
+    () => fileContentsRows("welcome", welcomeCopy(props.version)),
+    [props.version],
+  );
+  const session = playgroundThread(annotations);
+
+  return (
+    <DiffContentView
+      rows={rows}
+      session={session}
+      marks={marksByRows(annotations, rows)}
+      quickActions={props.quickActions}
+      observer={false}
+      commentsEnabled
+      fileView
+      suspended={props.suspended}
+      onComposingChange={props.onComposingChange}
+      onAnnotate={(span, body) =>
+        setAnnotations((current) => [
+          ...current,
+          {
+            id: newAnnotationId(),
+            kind: "comment",
+            anchor: makeAnchor(
+              diffRowBlocks(rows),
+              span.start.blockIndex,
+              span.start.char,
+              span.end.char,
+              span.end.blockIndex,
+            ),
+            target: { kind: "welcome" },
+            body,
+            createdAt: new Date().toISOString(),
+          },
+        ])
+      }
+      onReply={(rootAnnotationId, body) =>
+        setAnnotations((current) => {
+          const root = current.find((annotation) => annotation.id === rootAnnotationId);
+
+          if (!root) return current;
+
+          return [
+            ...current,
+            {
+              id: newAnnotationId(),
+              kind: "comment",
+              anchor: root.anchor,
+              target: { kind: "welcome" },
+              body,
+              replyTo: rootAnnotationId,
+              createdAt: new Date().toISOString(),
+            },
+          ];
+        })
+      }
+      onUpdateAnnotation={(id, body) =>
+        setAnnotations((current) =>
+          current.map((annotation) =>
+            annotation.id === id ? { ...annotation, body } : annotation,
+          ),
+        )
+      }
+      onExit={() => {}}
+      theme={props.theme}
+    />
+  );
+}