@cueloop/client 0.1.0-alpha.21 → 0.1.0-alpha.23

package/src/components/ReviewRail.tsx

@@ -8,7 +8,7 @@
 
 import React, { forwardRef, useImperativeHandle, useRef } from "react";
 import type { ScrollBoxRenderable } from "@opentui/core";
-import type { Annotation, ReviewSession } from "@cueloop/schema";
+import { isAddressed, type Annotation, type ReviewSession } from "@cueloop/schema";
 import type { Theme } from "../theme";
 import { useComponentTheme } from "./theme-context";
 import { Tabs, Tab, TabList } from "./primitives/Tabs";
@@ -40,6 +40,8 @@ export interface ReviewRailProps {
   onSelectCard: (id: string) => void;
   onActivateCard: (id: string) => void;
   onSubmitRequest: () => void;
+  /** Publish the plan as a share; omitted for non-owners (hides the button). */
+  onShareRequest?: () => void;
   /** Rail column width; the app derives it from the persisted review layout. */
   width?: number;
   /**
@@ -68,6 +70,7 @@ export const ReviewRail = forwardRef<ReviewRailHandle, ReviewRailProps>(function
     onSelectCard,
     onActivateCard,
     onSubmitRequest,
+    onShareRequest,
     width = 34,
     onCollapse,
     theme,
@@ -76,6 +79,9 @@ export const ReviewRail = forwardRef<ReviewRailHandle, ReviewRailProps>(function
 ): React.ReactNode {
   const tokens = useComponentTheme(theme);
   const scrollRef = useRef<ScrollBoxRenderable | null>(null);
+  // addressed annotations leave the card list; a dim count keeps them honest
+  const openAnnotations = session.annotations.filter((annotation) => !isAddressed(annotation));
+  const addressedCount = session.annotations.length - openAnnotations.length;
 
   useImperativeHandle(handleRef, () => ({
     revealCard: (annotationId: string): void => {
@@ -101,11 +107,12 @@ export const ReviewRail = forwardRef<ReviewRailHandle, ReviewRailProps>(function
       ) : (
         <>
           {session.workingCopy !== undefined ? <text fg={tokens.textDim}>± plan edits → one diff</text> : null}
-          {session.annotations.length === 0 ? (
-            <text fg={tokens.textDim}>no annotations yet</text>
+          {addressedCount > 0 ? <text fg={tokens.textDim}>✓ {addressedCount} addressed by revision</text> : null}
+          {openAnnotations.length === 0 ? (
+            <text fg={tokens.textDim}>{session.annotations.length === 0 ? "no annotations yet" : "all annotations addressed"}</text>
           ) : (
             <scrollbox ref={scrollRef} style={{ flexGrow: 1 }} focused={false}>
-              {session.annotations.map((annotation) => (
+              {openAnnotations.map((annotation) => (
                 <AnnotationCard
                   key={annotation.id}
                   id={`annotation-card-${annotation.id}`}
@@ -145,6 +152,11 @@ export const ReviewRail = forwardRef<ReviewRailHandle, ReviewRailProps>(function
               {`Submit review (${pendingCount}) ⏎`}
             </Button>
           )}
+          {onShareRequest && session.status !== "resolved" ? (
+            <Button variant="plain" onPress={onShareRequest} theme={theme}>
+              {"Share plan ⇧S"}
+            </Button>
+          ) : null}
         </>
       )}
       {/* the collapse chevron: muted, left-bound, one column from the divider.

package/src/components/stories.test.tsx

@@ -28,10 +28,15 @@ describe("stories catalog", () => {
 
   for (const { moduleTitle, storyName, story } of stories) {
     test(`${moduleTitle}/${storyName} renders, snapshots, and carries its colors`, async () => {
+      // Arrange
       const size = story.size ?? { width: 80, height: 24 };
+
+      // Act
       const setup = await testRender(story.render(), size);
       await setup.waitForVisualIdle();
       const frame = setup.captureCharFrame();
+
+      // Assert
       expect(frame).toMatchSnapshot(`${moduleTitle}/${storyName}`);
       if (story.expectedColors?.length) {
         const seenColors = new Set<string>();

package/src/config.test.ts

@@ -8,20 +8,28 @@ import { DARK } from "./theme";
 
 describe("loadConfig", () => {
   test("defaults when no file exists", () => {
+    // Act
     const config = loadConfig({ userConfigPath: "/nonexistent/config.toml" });
+
+    // Assert
     expect(config.keys["comment"]).toEqual(["c"]);
     expect(config.theme.accent).toBe(DARK.accent);
   });
 
   test("user config rebinds actions and overrides theme tokens", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg-"));
     const path = join(dir, "config.toml");
     writeFileSync(
       path,
       `[keys]\ncomment = "a"\nsubmit = ["return", "S"]\n\n[theme]\naccent = "#ff0000"\n`,
     );
+
     try {
+      // Act
       const config = loadConfig({ userConfigPath: path });
+
+      // Assert
       expect(config.keys["comment"]).toEqual(["a"]);
       expect(config.keys["submit"]).toEqual(["return", "S"]);
       expect(config.keys["cut"]).toEqual(["x"]); // untouched defaults survive
@@ -33,14 +41,19 @@ describe("loadConfig", () => {
   });
 
   test("repo config layers over user config", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg2-"));
     const user = join(dir, "user.toml");
     const repoRoot = join(dir, "repo");
     writeFileSync(user, `[keys]\ncomment = "a"\n`);
     Bun.spawnSync(["mkdir", "-p", join(repoRoot, ".cueloop")]);
     writeFileSync(join(repoRoot, ".cueloop", "config.toml"), `[keys]\ncomment = "z"\n`);
+
     try {
+      // Act
       const config = loadConfig({ userConfigPath: user, repoRoot });
+
+      // Assert
       expect(config.keys["comment"]).toEqual(["z"]);
     } finally {
       rmSync(dir, { recursive: true, force: true });
@@ -48,11 +61,16 @@ describe("loadConfig", () => {
   });
 
   test("broken config never blocks a review", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg3-"));
     const path = join(dir, "config.toml");
     writeFileSync(path, "not [valid toml");
+
     try {
+      // Act
       const config = loadConfig({ userConfigPath: path });
+
+      // Assert
       expect(config.keys["comment"]).toEqual(["c"]);
     } finally {
       rmSync(dir, { recursive: true, force: true });
@@ -60,11 +78,16 @@ describe("loadConfig", () => {
   });
 
   test("[ui] parses auto_close and the editor override", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg4-"));
     const path = join(dir, "config.toml");
     writeFileSync(path, `[ui]\nauto_close = 3\neditor = "code --wait"\n`);
+
     try {
+      // Act
       const config = loadConfig({ userConfigPath: path });
+
+      // Assert
       expect(config.ui.autoClose).toBe(3);
       expect(config.ui.editor).toBe("code --wait");
     } finally {
@@ -73,10 +96,13 @@ describe("loadConfig", () => {
   });
 
   test("[ui] editor defaults to undefined and ignores a blank value", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg5-"));
     const path = join(dir, "config.toml");
     writeFileSync(path, `[ui]\neditor = "   "\n`);
+
     try {
+      // Assert
       expect(loadConfig({ userConfigPath: "/nonexistent/config.toml" }).ui.editor).toBeUndefined();
       expect(loadConfig({ userConfigPath: path }).ui.editor).toBeUndefined();
     } finally {
@@ -85,17 +111,25 @@ describe("loadConfig", () => {
   });
 
   test("[ui] review panel defaults to an expanded rail at the default width", () => {
+    // Act
     const config = loadConfig({ userConfigPath: "/nonexistent/config.toml" });
+
+    // Assert
     expect(config.ui.reviewState).toBe("expanded");
     expect(config.ui.reviewWidth).toBe(REVIEW_DEFAULT_WIDTH);
   });
 
   test("[ui] parses review_width (clamped) and review_state", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg6-"));
     const path = join(dir, "config.toml");
     writeFileSync(path, `[ui]\nreview_width = 999\nreview_state = "compact"\n`);
+
     try {
+      // Act
       const config = loadConfig({ userConfigPath: path });
+
+      // Assert
       expect(config.ui.reviewWidth).toBe(REVIEW_MAX_WIDTH); // out-of-range width clamps
       expect(config.ui.reviewState).toBe("compact");
     } finally {
@@ -104,11 +138,16 @@ describe("loadConfig", () => {
   });
 
   test("[ui] ignores an unknown review_state and a non-numeric width", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg7-"));
     const path = join(dir, "config.toml");
     writeFileSync(path, `[ui]\nreview_width = "wide"\nreview_state = "sideways"\n`);
+
     try {
+      // Act
       const config = loadConfig({ userConfigPath: path });
+
+      // Assert
       expect(config.ui.reviewWidth).toBe(REVIEW_DEFAULT_WIDTH);
       expect(config.ui.reviewState).toBe("expanded");
     } finally {
@@ -117,16 +156,25 @@ describe("loadConfig", () => {
   });
 
   test("persistReviewWidth and persistReviewState round-trip through the config file", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg8-"));
     const path = join(dir, "config.toml");
+
     try {
+      // Act
       persistReviewWidth(42, path);
       persistReviewState("hidden", path);
+
+      // Assert
       const config = loadConfig({ userConfigPath: path });
       expect(config.ui.reviewWidth).toBe(42);
       expect(config.ui.reviewState).toBe("hidden");
+
       // a second write replaces the key in place rather than appending a duplicate
+      // Act
       persistReviewWidth(30, path);
+
+      // Assert
       expect(loadConfig({ userConfigPath: path }).ui.reviewWidth).toBe(30);
     } finally {
       rmSync(dir, { recursive: true, force: true });
@@ -136,7 +184,10 @@ describe("loadConfig", () => {
 
 describe("integrations.obsidian config", () => {
   test("defaults when the section is absent", () => {
+    // Act
     const config = loadConfig({ userConfigPath: "/nonexistent/config.toml" });
+
+    // Assert
     expect(config.integrations.obsidian.vault).toBeUndefined();
     expect(config.integrations.obsidian.folder).toBe("cueloop");
     expect(config.integrations.obsidian.filenameFormat).toBe("{YYYY}-{MM}-{DD} - {title}");
@@ -145,14 +196,19 @@ describe("integrations.obsidian config", () => {
   });
 
   test("user config sets the section; invalid enum values are ignored", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg-obs-"));
     const path = join(dir, "config.toml");
     writeFileSync(
       path,
       `[integrations.obsidian]\nvault = "/notes/vault"\nfolder = "plans"\nexportOn = "approve"\nseparator = "comma"\n`,
     );
+
     try {
+      // Act
       const config = loadConfig({ userConfigPath: path });
+
+      // Assert
       expect(config.integrations.obsidian.vault).toBe("/notes/vault");
       expect(config.integrations.obsidian.folder).toBe("plans");
       expect(config.integrations.obsidian.exportOn).toBe("approve");
@@ -164,14 +220,19 @@ describe("integrations.obsidian config", () => {
   });
 
   test("repo config layers over user config for the section", () => {
+    // Arrange
     const dir = mkdtempSync(join(tmpdir(), "cueloop-cfg-obs2-"));
     const user = join(dir, "user.toml");
     const repoRoot = join(dir, "repo");
     writeFileSync(user, `[integrations.obsidian]\nvault = "/user/vault"\nexportOn = "resolve"\n`);
     Bun.spawnSync(["mkdir", "-p", join(repoRoot, ".cueloop")]);
     writeFileSync(join(repoRoot, ".cueloop", "config.toml"), `[integrations.obsidian]\nfolder = "repo-plans"\n`);
+
     try {
+      // Act
       const config = loadConfig({ userConfigPath: user, repoRoot });
+
+      // Assert
       expect(config.integrations.obsidian.vault).toBe("/user/vault"); // user layer survives
       expect(config.integrations.obsidian.exportOn).toBe("resolve");
       expect(config.integrations.obsidian.folder).toBe("repo-plans"); // repo layer wins
@@ -183,6 +244,7 @@ describe("integrations.obsidian config", () => {
 
 describe("actionFor", () => {
   test("resolves keys and shifted keys to actions", () => {
+    // Assert
     expect(actionFor(DEFAULT_KEYS, "j", false)).toBe("down");
     expect(actionFor(DEFAULT_KEYS, "g", true)).toBe("bottom"); // G
     expect(actionFor(DEFAULT_KEYS, "return", false)).toBe("submit");

package/src/config.ts

@@ -52,6 +52,7 @@ export const DEFAULT_KEYS: Record<string, string[]> = {
   prev_annotation: ["p"],
   delete_annotation: ["backspace"],
   submit: ["return", "enter"],
+  share: ["S"],
   quit: ["q"],
   walk: ["w"],
   review_cycle: ["b"],

package/src/editor.test.ts

@@ -6,35 +6,42 @@ import { editInEditor, resolveEditor, resolveEditorCommand } from "./editor";
 
 describe("resolveEditor", () => {
   test("a clean environment falls back to nano so editing always works", () => {
+    // Assert
     expect(resolveEditor(undefined, {})).toBe("nano");
   });
 
   test("the environment chain wins in order: CUELOOP_EDITOR, VISUAL, EDITOR", () => {
+    // Assert
     expect(resolveEditor(undefined, { EDITOR: "vim", VISUAL: "code", CUELOOP_EDITOR: "hx" })).toBe("hx");
     expect(resolveEditor(undefined, { EDITOR: "vim", VISUAL: "code" })).toBe("code");
     expect(resolveEditor(undefined, { EDITOR: "vim" })).toBe("vim");
   });
 
   test("the [ui] editor config overrides the environment", () => {
+    // Assert
     expect(resolveEditor("code --wait", { EDITOR: "vim" })).toBe("code --wait");
   });
 });
 
 describe("resolveEditorCommand", () => {
   test("a known GUI editor gets its wait flag appended and is trusted to wait", () => {
+    // Assert
     expect(resolveEditorCommand("code")).toEqual({ argv: ["code", "--wait"], waits: true });
     expect(resolveEditorCommand("subl")).toEqual({ argv: ["subl", "--new-window", "--wait"], waits: true });
   });
 
   test("an existing wait flag is not duplicated", () => {
+    // Assert
     expect(resolveEditorCommand("code --wait").argv).toEqual(["code", "--wait"]);
   });
 
   test("a terminal editor is left alone and trusted to hold the tty", () => {
+    // Assert
     expect(resolveEditorCommand("vim")).toEqual({ argv: ["vim"], waits: true });
   });
 
   test("an unknown editor is neither flagged nor trusted to wait", () => {
+    // Assert
     expect(resolveEditorCommand("my-editor")).toEqual({ argv: ["my-editor"], waits: false });
   });
 });
@@ -62,12 +69,18 @@ describe("editInEditor", () => {
   };
 
   test("an editor that changes the file reports the new content", () => {
+    // Act
     const result = editInEditor("old", "plan.md", { editor: stubEditor("writer.sh", `printf 'new' > "$1"`) });
+
+    // Assert
     expect(result).toEqual({ content: "new", changed: true });
   });
 
   test("a fast, unchanged return opens the gate; confirming re-reads the saved file", () => {
+    // Arrange
     let askedLabel = "";
+
+    // Act
     const result = editInEditor("keep", "plan.md", {
       editor: stubEditor("gui-like.sh", "exit 0"),
       now: instant(),
@@ -77,21 +90,29 @@ describe("editInEditor", () => {
         return true;
       },
     });
+
+    // Assert
     expect(askedLabel).toContain("gui-like.sh");
     expect(result).toEqual({ content: "saved in the GUI", changed: true });
   });
 
   test("declining the gate keeps the original content", () => {
+    // Act
     const result = editInEditor("keep", "plan.md", {
       editor: stubEditor("gui-like.sh", "exit 0"),
       now: instant(),
       confirmSaved: () => false,
     });
+
+    // Assert
     expect(result).toEqual({ content: "keep", changed: false });
   });
 
   test("a terminal editor that makes no change never opens the gate", () => {
+    // Arrange
     let asked = false;
+
+    // Act
     const result = editInEditor("keep", "plan.md", {
       editor: stubEditor("vi", "exit 0"),
       now: instant(),
@@ -100,11 +121,14 @@ describe("editInEditor", () => {
         return true;
       },
     });
+
+    // Assert
     expect(asked).toBeFalse();
     expect(result).toEqual({ content: "keep", changed: false });
   });
 
   test("a nonzero editor exit throws", () => {
+    // Assert
     expect(() => editInEditor("x", "plan.md", { editor: stubEditor("fail.sh", "exit 3") })).toThrow("editor exited 3");
   });
 });

package/src/herdr.test.ts

@@ -15,6 +15,7 @@ afterEach(() => {
 
 describe("focusHerdrPane", () => {
   test("resolves the pane's tab and focuses it", () => {
+    // Arrange
     const log = join(dir, "calls.log");
     const stub = join(dir, "herdr");
     writeFileSync(
@@ -25,6 +26,8 @@ if [ "$1" = "pane" ]; then echo '{"result":{"pane":{"tab_id":"w1:t3"}}}'; fi
 `,
     );
     Bun.spawnSync(["chmod", "+x", stub]);
+
+    // Assert
     expect(focusHerdrPane(stub, "w1:p1")).toBe(true);
     const calls = readFileSync(log, "utf8").trim().split("\n");
     expect(calls[0]).toBe("pane get w1:p1");
@@ -32,6 +35,7 @@ if [ "$1" = "pane" ]; then echo '{"result":{"pane":{"tab_id":"w1:t3"}}}'; fi
   });
 
   test("a missing binary never throws", () => {
+    // Assert
     expect(focusHerdrPane(join(dir, "nope"), "w1:p1")).toBe(false);
   });
 });

package/src/index.ts

@@ -1,2 +1,4 @@
 export { runClient, type RunClientOptions } from "./run";
 export { serveClient, type ServeHandle, type ServeOptions } from "./serve";
+export { App, type AppProps } from "./App";
+export { publishShare, type ShareResult, type ShareTarget } from "./share";

package/src/integrations.test.ts

@@ -9,20 +9,32 @@ function integrations(overrides: Partial<typeof OBSIDIAN_DEFAULTS> = {}): Integr
 
 describe("loadBundledExporters", () => {
   test("composes the obsidian integration into one named exporter", async () => {
+    // Act
     const exporters = await loadBundledExporters(integrations());
+
+    // Assert
     expect(exporters.map((exporter) => exporter.name)).toEqual(["obsidian"]);
   });
 
   test("runsOn mirrors the configured export policy", async () => {
+    // Arrange
     const onApprove = (await loadBundledExporters(integrations({ exportOn: "approve" })))[0]!;
+
+    // Assert
     expect(onApprove.runsOn("approve")).toBeTrue();
     expect(onApprove.runsOn("request_changes")).toBeFalse();
 
+    // Arrange
     const onResolve = (await loadBundledExporters(integrations({ exportOn: "resolve" })))[0]!;
+
+    // Assert
     expect(onResolve.runsOn("approve")).toBeTrue();
     expect(onResolve.runsOn("request_changes")).toBeTrue();
 
+    // Arrange
     const manual = (await loadBundledExporters(integrations({ exportOn: "manual" })))[0]!;
+
+    // Assert
     expect(manual.runsOn("approve")).toBeFalse();
     expect(manual.runsOn("request_changes")).toBeFalse();
   });