@cueloop/client 0.1.0-alpha.17 → 0.1.0-alpha.19

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.17",
+  "version": "0.1.0-alpha.19",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@cueloop/daemon": "0.1.0-alpha.17",
-    "@cueloop/extension-api": "0.1.0-alpha.17",
-    "@cueloop/integration-obsidian": "0.1.0-alpha.17",
-    "@cueloop/schema": "0.1.0-alpha.17",
+    "@cueloop/daemon": "0.1.0-alpha.19",
+    "@cueloop/extension-api": "0.1.0-alpha.19",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.19",
+    "@cueloop/schema": "0.1.0-alpha.19",
     "@opentui/core": "^0.5.1",
     "@opentui/keymap": "0.5.1",
     "@opentui/react": "^0.5.1",

package/src/App.tsx

@@ -17,7 +17,7 @@ import { displayText, marksByDisplay, spanKey, startSpan, type Mark, type SpanSt
 import { noteForFile, viewedCount } from "./walk";
 import { DARK, dimmedTheme } from "./theme";
 import { DEFAULT_KEYS, loadConfig } from "./config";
-import { returnPaneFor } from "./herdr";
+import { returnPaneFor } from "@cueloop/schema";
 import { createReviewController } from "./session-controller";
 import { reduceKey, type Intent, type KeyState } from "./keymap";
 import { KeyBindings, type HintMode } from "./key-bindings";

package/src/herdr.test.ts

@@ -2,46 +2,17 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { focusHerdrPane, returnPaneFor } from "./herdr";
+import { focusHerdrPane } from "./herdr";
 
 let dir: string;
-const savedEnv: Record<string, string | undefined> = {};
 
 beforeEach(() => {
   dir = mkdtempSync(join(tmpdir(), "cueloop-herdr-"));
-  for (const k of ["HERDR_ENV", "HERDR_PANE_ID", "HERDR_BIN_PATH", "CUELOOP_RETURN_PANE"]) {
-    savedEnv[k] = process.env[k];
-    delete process.env[k];
-  }
 });
 afterEach(() => {
-  for (const [k, v] of Object.entries(savedEnv)) {
-    if (v === undefined) delete process.env[k];
-    else process.env[k] = v;
-  }
   rmSync(dir, { recursive: true, force: true });
 });
 
-describe("returnPaneFor", () => {
-  test("outside herdr there is never a return target", () => {
-    expect(returnPaneFor("w1:p1")).toBeUndefined();
-  });
-
-  test("env override wins, session meta is the fallback", () => {
-    process.env.HERDR_ENV = "1";
-    process.env.HERDR_PANE_ID = "w1:p9";
-    expect(returnPaneFor("w1:p1")).toBe("w1:p1");
-    process.env.CUELOOP_RETURN_PANE = "w1:p2";
-    expect(returnPaneFor("w1:p1")).toBe("w1:p2");
-  });
-
-  test("returning to our own pane is a no-op", () => {
-    process.env.HERDR_ENV = "1";
-    process.env.HERDR_PANE_ID = "w1:p1";
-    expect(returnPaneFor("w1:p1")).toBeUndefined();
-  });
-});
-
 describe("focusHerdrPane", () => {
   test("resolves the pane's tab and focuses it", () => {
     const log = join(dir, "calls.log");
@@ -54,15 +25,13 @@ if [ "$1" = "pane" ]; then echo '{"result":{"pane":{"tab_id":"w1:t3"}}}'; fi
 `,
     );
     Bun.spawnSync(["chmod", "+x", stub]);
-    process.env.HERDR_BIN_PATH = stub;
-    expect(focusHerdrPane("w1:p1")).toBe(true);
+    expect(focusHerdrPane(stub, "w1:p1")).toBe(true);
     const calls = readFileSync(log, "utf8").trim().split("\n");
     expect(calls[0]).toBe("pane get w1:p1");
     expect(calls[1]).toBe("tab focus w1:t3");
   });
 
   test("a missing binary never throws", () => {
-    process.env.HERDR_BIN_PATH = join(dir, "nope");
-    expect(focusHerdrPane("w1:p1")).toBe(false);
+    expect(focusHerdrPane(join(dir, "nope"), "w1:p1")).toBe(false);
   });
 });

package/src/herdr.ts

@@ -1,33 +1,20 @@
 /**
- * First-class herdr return: 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";
-}
-
-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;
-}
-
 /** 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;
     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/integrations.test.ts

@@ -0,0 +1,29 @@
+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 () => {
+    const exporters = await loadBundledExporters(integrations());
+    expect(exporters.map((exporter) => exporter.name)).toEqual(["obsidian"]);
+  });
+
+  test("runsOn mirrors the configured export policy", async () => {
+    const onApprove = (await loadBundledExporters(integrations({ exportOn: "approve" })))[0]!;
+    expect(onApprove.runsOn("approve")).toBeTrue();
+    expect(onApprove.runsOn("request_changes")).toBeFalse();
+
+    const onResolve = (await loadBundledExporters(integrations({ exportOn: "resolve" })))[0]!;
+    expect(onResolve.runsOn("approve")).toBeTrue();
+    expect(onResolve.runsOn("request_changes")).toBeTrue();
+
+    const manual = (await loadBundledExporters(integrations({ exportOn: "manual" })))[0]!;
+    expect(manual.runsOn("approve")).toBeFalse();
+    expect(manual.runsOn("request_changes")).toBeFalse();
+  });
+});

package/src/integrations.ts

@@ -0,0 +1,28 @@
+/**
+ * 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) }];
+}

package/src/session-controller.ts

@@ -11,22 +11,23 @@ import { SystemClock, type Clock, type TimerHandle } from "@opentui/core";
 import { DaemonClient } from "@cueloop/daemon/client";
 import {
   cutBlock,
+  detectHerdr,
   makeAnchor,
   newAnnotationId,
   parseBlocks,
   resolveAnchor,
   restoreBlock,
   restoreLine,
+  returnPaneFor,
   type ReviewSession,
   type VerdictKind,
 } from "@cueloop/schema";
-import { Registry, type Exporter } from "@cueloop/extension-api";
-import { createObsidianExtension, shouldExport, type ObsidianConfig } from "@cueloop/integration-obsidian";
+import { loadBundledExporters, type BundledExporter } from "./integrations";
 import { buildDisplay, nextWorkBlock, type DisplayBlock } from "./view-plan";
 import { diffRowAnchor, diffRows, type DiffRow } from "./view-diff";
 import { firstUnviewedIndex, walkFiles, type WalkFile } from "./walk";
 import { editInEditor } from "./editor";
-import { focusHerdrPane, returnPaneFor } from "./herdr";
+import { focusHerdrPane } from "./herdr";
 import { persistAutoClose, type AutoClose, type CueloopConfig } from "./config";
 
 /**
@@ -139,8 +140,7 @@ class Controller implements ReviewController {
   };
   private listeners = new Set<() => void>();
   private autoClose: AutoClose = "off";
-  private obsidian: ObsidianConfig | null = null;
-  private exporters = new Map<string, Exporter>();
+  private exporters: BundledExporter[] = [];
   private readonly clock: Clock;
   private countdown: TimerHandle | undefined;
   /** Projections keyed by session identity so renders reuse one computation. */
@@ -205,11 +205,8 @@ class Controller implements ReviewController {
 
   applyConfig(config: CueloopConfig): void {
     this.autoClose = config.ui.autoClose;
-    this.obsidian = config.integrations.obsidian;
-    // bundled integrations register through the public extension API
-    const registry = new Registry();
-    void registry.load("obsidian", createObsidianExtension(config.integrations.obsidian)).then((record) => {
-      this.exporters = record.exporters;
+    void loadBundledExporters(config.integrations).then((exporters) => {
+      this.exporters = exporters;
     });
   }
 
@@ -446,11 +443,10 @@ class Controller implements ReviewController {
         // The completion overlay heading already states the verdict, so the
         // status line stays empty here - only export/error messages fill it.
         this.update({ session: resolved, status: "" });
-        // notes-vault export: guarded by config, default is manual (no-op)
-        const obsidian = this.obsidian;
-        const exporter = this.exporters.get("obsidian");
-        if (obsidian && exporter && shouldExport(obsidian.exportOn, verdict)) {
-          void exporter(resolved).then((exportResult) => {
+        // notes-vault export: guarded by each exporter's policy (default manual = no-op)
+        for (const exporter of this.exporters) {
+          if (!exporter.runsOn(verdict)) continue;
+          void exporter.run(resolved).then((exportResult) => {
             this.setStatus(exportResult.success && exportResult.path ? `exported to ${exportResult.path}` : `export failed: ${exportResult.error ?? "unknown"}`);
           });
         }
@@ -474,8 +470,9 @@ class Controller implements ReviewController {
 
   finishReview(): void {
     this.clearCountdown();
+    const herdr = detectHerdr();
     const pane = returnPaneFor(this.snapshot.session?.artifact.meta.herdrPane);
-    if (pane) focusHerdrPane(pane);
+    if (herdr && pane) focusHerdrPane(herdr.binPath, pane);
     this.options.onExit?.(0);
   }