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

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();
   });

package/src/intent-dispatch.test.ts

@@ -0,0 +1,213 @@
+/**
+ * The intent reducer in isolation: with the App component's dependencies
+ * mocked, each Intent maps to exactly the controller call or state update it
+ * should - the navigation clamps, the annotation wrap-around, the verdict
+ * cycle, and the submit-reveal fix, none of which needed a rendered TUI.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+import type { ReviewSession } from "@cueloop/schema";
+import { createIntentDispatch, type IntentDispatchDeps } from "./intent-dispatch";
+import type { DisplayBlock } from "./view-plan";
+
+function block(text: string): DisplayBlock {
+  return { text, kind: "text", work: true } as unknown as DisplayBlock;
+}
+
+function sessionWith(annotationIds: string[]): ReviewSession {
+  return {
+    annotations: annotationIds.map((id) => ({ id })),
+    workingCopy: undefined,
+  } as unknown as ReviewSession;
+}
+
+/** A deps bag where every effect is a mock and every read has a plain default. */
+function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDeps {
+  const controller = {
+    setStatus: mock(),
+    open: mock(),
+    cut: mock(),
+    annotate: mock(),
+    updateAnnotation: mock(),
+    removeAnnotation: mock(),
+    walkStart: mock(),
+    walkForward: mock(),
+    walkBack: mock(),
+    walkLeave: mock(),
+    submit: mock(),
+    share: mock(),
+    finishReview: mock(),
+    optInAutoClose: mock(),
+    dismissCompletion: mock(),
+    saveReviewPanel: mock(),
+  };
+  return {
+    controller: controller as unknown as IntentDispatchDeps["controller"],
+    onExit: mock(),
+    isDiff: false,
+    display: [],
+    rows: [],
+    cursor: 0,
+    inbox: null,
+    inboxCursor: 0,
+    mode: { type: "normal" },
+    session: null,
+    reviewMode: "expanded",
+    reviewWidth: 34,
+    terminalWidth: 120,
+    focusedAnnotationId: undefined,
+    liveInput: { current: "" },
+    reviewWidthRef: { current: 34 },
+    planSheetRef: { current: null },
+    setCursor: mock(),
+    setInboxCursor: mock(),
+    setMode: mock(),
+    setReviewMode: mock(),
+    setReviewWidth: mock(),
+    setRailTab: mock(),
+    setFocusedAnnotationId: mock(),
+    setPulsedAnnotationId: mock(),
+    selectCardFromDocument: mock(),
+    runEditorHandOff: mock(),
+    openCardEdit: mock(),
+    ...overrides,
+  };
+}
+
+describe("move", () => {
+  test("down clamps at the last row and up clamps at the first", () => {
+    // Arrange
+    const deps = makeDeps({ display: [block("a"), block("b"), block("c")] });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "move", to: "down" });
+
+    // Assert
+    const advance = (deps.setCursor as ReturnType<typeof mock>).mock.calls[0]![0] as (current: number) => number;
+    expect(advance(2)).toBe(2); // already at the end, stays
+    expect(advance(0)).toBe(1);
+  });
+
+  test("bottom jumps to the last navigable row", () => {
+    // Arrange
+    const deps = makeDeps({ display: [block("a"), block("b"), block("c")] });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "move", to: "bottom" });
+
+    // Assert
+    expect(deps.setCursor).toHaveBeenCalledWith(2);
+  });
+});
+
+describe("annotation navigation", () => {
+  test("nextAnnotation wraps from the last annotation back to the first", () => {
+    // Arrange
+    const deps = makeDeps({ session: sessionWith(["a1", "a2", "a3"]), focusedAnnotationId: "a3" });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "nextAnnotation" });
+
+    // Assert
+    expect(deps.selectCardFromDocument).toHaveBeenCalledWith("a1");
+  });
+
+  test("prevAnnotation wraps from the first annotation to the last", () => {
+    // Arrange
+    const deps = makeDeps({ session: sessionWith(["a1", "a2", "a3"]), focusedAnnotationId: "a1" });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "prevAnnotation" });
+
+    // Assert
+    expect(deps.selectCardFromDocument).toHaveBeenCalledWith("a3");
+  });
+
+  test("cycling skips annotations a revision already addressed", () => {
+    // Arrange: a2 is addressed, so next from a1 lands on a3
+    const session = sessionWith(["a1", "a2", "a3"]);
+    (session.annotations[1] as { resolution?: object }).resolution = { revision: 2, source: "agent" };
+    const deps = makeDeps({ session, focusedAnnotationId: "a1" });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "nextAnnotation" });
+
+    // Assert
+    expect(deps.selectCardFromDocument).toHaveBeenCalledWith("a3");
+  });
+});
+
+describe("cycleVerdict", () => {
+  test("advances through the verdict list in the submit overlay", () => {
+    // Arrange
+    const deps = makeDeps({ mode: { type: "submit", verdict: "approve", summary: "" } });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "cycleVerdict", direction: 1 });
+
+    // Assert
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "submit", verdict: "request_changes", summary: "" });
+  });
+});
+
+describe("openSubmit", () => {
+  test("force-opens the review rail so the confirm card can never be hidden", () => {
+    // Arrange
+    const deps = makeDeps({ session: sessionWith([]), reviewMode: "hidden" });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "openSubmit" });
+
+    // Assert
+    expect(deps.setReviewMode).toHaveBeenCalledWith("expanded");
+    expect(deps.setRailTab).toHaveBeenCalledWith("review");
+    expect(deps.setMode).toHaveBeenCalledWith({ type: "submit", verdict: "approve", summary: "" });
+  });
+
+  test("does nothing without a session", () => {
+    // Arrange
+    const deps = makeDeps({ session: null });
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "openSubmit" });
+
+    // Assert
+    expect(deps.setMode).not.toHaveBeenCalled();
+  });
+});
+
+describe("share", () => {
+  test("dispatches to the controller's share", () => {
+    // Arrange
+    const deps = makeDeps();
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "share" });
+
+    // Assert
+    expect(deps.controller.share).toHaveBeenCalled();
+  });
+});
+
+describe("exit", () => {
+  test("calls the exit hook with 0", () => {
+    // Arrange
+    const deps = makeDeps();
+    const dispatch = createIntentDispatch(deps);
+
+    // Act
+    dispatch({ type: "exit" });
+
+    // Assert
+    expect(deps.onExit).toHaveBeenCalledWith(0);
+  });
+});