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

package/src/herdr.ts

@@ -1,33 +1,37 @@
 /**
- * First-class herdr return (#23): a review opened beside an agent should hand
- * focus back to the agent's pane when it closes, not leave the reviewer on a
- * dead tab. Detection is the ambient env contract; the return target comes
- * from CUELOOP_RETURN_PANE (set by whoever opened this pane) or the session's
- * recorded herdrPane (set by the adapter hook). Everything here is
- * best-effort: focus failures never block closing the review.
+ * First-class herdr return: a review opened beside an agent hands focus back
+ * to the agent's pane when it closes, not leaving the reviewer on a dead tab.
+ * The env contract and the return-target rule live in @cueloop/schema; this
+ * module owns the one reviewer-side action that spawns the herdr CLI. Focus
+ * is best-effort - a failure never blocks closing the review.
  */
 
-export function insideHerdr(): boolean {
-  return process.env.HERDR_ENV === "1";
-}
+import * as v from "valibot";
 
-export function returnPaneFor(sessionHerdrPane?: string): string | undefined {
-  if (!insideHerdr()) return undefined;
-  const pane = process.env.CUELOOP_RETURN_PANE ?? sessionHerdrPane;
-  // returning to our own pane would be a no-op at best
-  return pane && pane !== process.env.HERDR_PANE_ID ? pane : undefined;
-}
+const HerdrPaneSchema = v.object({
+  result: v.optional(v.object({ pane: v.optional(v.object({ tab_id: v.optional(v.string()) })) })),
+});
 
 /** Focus the tab holding the target pane. Synchronous: runs just before exit. */
-export function focusHerdrPane(paneId: string): boolean {
-  const bin = process.env.HERDR_BIN_PATH ?? "herdr";
+export function focusHerdrPane(binPath: string, paneId: string): boolean {
   try {
-    const got = Bun.spawnSync([bin, "pane", "get", paneId], { stdout: "pipe", stderr: "ignore" });
+    const got = Bun.spawnSync([binPath, "pane", "get", paneId], {
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+
     if (got.exitCode !== 0) return false;
-    const parsed = JSON.parse(got.stdout.toString()) as { result?: { pane?: { tab_id?: string } } };
-    const tab = parsed.result?.pane?.tab_id;
+    const parsed = v.safeParse(HerdrPaneSchema, JSON.parse(got.stdout.toString()));
+
+    if (!parsed.success) return false;
+    const tab = parsed.output.result?.pane?.tab_id;
+
     if (!tab) return false;
-    return Bun.spawnSync([bin, "tab", "focus", tab], { stdout: "ignore", stderr: "ignore" }).exitCode === 0;
+
+    return (
+      Bun.spawnSync([binPath, "tab", "focus", tab], { stdout: "ignore", stderr: "ignore" })
+        .exitCode === 0
+    );
   } catch {
     return false;
   }

package/src/index.ts

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

package/src/integrations.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import { OBSIDIAN_DEFAULTS } from "@cueloop/integration-obsidian";
+import { loadBundledExporters } from "./integrations";
+import type { IntegrationsConfig } from "./config";
+
+function integrations(overrides: Partial<typeof OBSIDIAN_DEFAULTS> = {}): IntegrationsConfig {
+  return { obsidian: { ...OBSIDIAN_DEFAULTS, ...overrides } };
+}
+
+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/integrations.ts

@@ -0,0 +1,32 @@
+/**
+ * Bundled integration wiring: composes the configured integrations into
+ * generic exporters plus their run policy, so the session controller depends
+ * only on the extension seam, never on an integration's own config type. This
+ * and config.ts are the only client modules that name a concrete integration.
+ */
+
+import { Registry, type Exporter } from "@cueloop/extension-api";
+import { createObsidianExtension, shouldExport } from "@cueloop/integration-obsidian";
+import type { VerdictKind } from "@cueloop/schema";
+import type { IntegrationsConfig } from "./config";
+
+/** An exporter plus the policy deciding which verdicts trigger it. */
+export interface BundledExporter {
+  name: string;
+  run: Exporter;
+  runsOn(verdict: VerdictKind): boolean;
+}
+
+/** Load the bundled integrations from config as generic exporters. */
+export async function loadBundledExporters(
+  integrations: IntegrationsConfig,
+): Promise<BundledExporter[]> {
+  const registry = new Registry();
+  const obsidian = integrations.obsidian;
+  const record = await registry.load("obsidian", createObsidianExtension(obsidian));
+  const run = record.exporters.get("obsidian");
+
+  if (!run) return [];
+
+  return [{ name: "obsidian", run, runsOn: (verdict) => shouldExport(obsidian.exportOn, verdict) }];
+}