@bunshin-cc/bunshin 0.4.4 → 0.4.6

package/dist/claude-code-ui/.claude-plugin/plugin.json

@@ -0,0 +1,7 @@
+{
+  "name": "bunshin-ui",
+  "version": "0.0.0",
+  "description": "Bunshin for the person at the terminal: what the library served and why, live library changes, lessons from the session, reviews waiting. A band above the prompt, a /bunshin pane, toasts.",
+  "author": { "name": "Bunshin", "url": "https://bunshin.cc" },
+  "types": "./types/index.d.ts"
+}

package/dist/claude-code-ui/README.md

@@ -0,0 +1,29 @@
+# bunshin-ui: a Claude Code mod
+
+Bunshin's hooks talk to the model; this mod shows the person what they did. It draws the CLI's
+session feed (`.bunshin/v2/ui/<session>.json`, written by `packages/cli/src/v2/ui.ts`):
+
+- **above the prompt**: `◆ bunshin  show-me skill  picked by Jev (98%)   lib@207 · 3 served · 1 learned`
+- **`/bunshin`**: a pane with everything served this session and why, the lessons taken from it,
+  recent events, and Learn now (`l`), Sync (`s`), Review (`r`)
+- **toasts**: library updates that reached the session, lessons learned, reviews waiting, the
+  `/learn` nudge
+
+While it runs it writes a heartbeat beside the feed (`<session>.mod.json`), and the CLI stops
+printing its one-line fallback, so nothing is said twice. It draws nothing outside a project
+connected to Bunshin.
+
+Install (the CLI does this itself the first time a connected Claude Code session starts, and
+again after each upgrade):
+
+    bunshin ui install          # local marketplace ~/.bunshin/claude-code-ui, user scope
+    bunshin ui status
+    bunshin ui disable --harness claude-code    # neither the mod's drawing nor the lines
+
+Develop: `claude --plugin-dir adapters/claude-code-ui` hot-reloads on save;
+`claude plugin validate adapters/claude-code-ui`; `claude plugin test adapters/claude-code-ui`.
+Needs Claude Code 2.1.287+ with mods enabled for the account.
+
+Other harnesses read the same feed: pi draws it as a widget above the editor (`adapters/pi`);
+Codex gets nothing until it shows hook messages (`bunshin ui enable --harness codex` turns on the
+plain lines); any terminal can follow it with `bunshin ui --watch`.

package/dist/claude-code-ui/hooks/bunshin-ui.mjs

@@ -0,0 +1,310 @@
+// bunshin-ui: Bunshin for the person at the terminal.
+//
+// Bunshin's hooks talk to the model (additionalContext), which the person never sees. The CLI
+// keeps the person's side in a feed, .bunshin/v2/ui/<session>.json (packages/cli/src/v2/ui.ts):
+// what the library served and why, library changes that reached the session, lessons taken,
+// checkpoints, reviews waiting. This mod draws it:
+//
+//   above the prompt  one line: the latest document served and why, then the session's counts
+//   /bunshin          a pane: everything served, the lessons, recent events; Learn now, Sync, Review
+//   toasts            library updates, lessons learned, reviews waiting, the /learn nudge
+//
+// While it runs it writes a heartbeat beside the feed (<session>.mod.json); the CLI then stops
+// printing its plain one-line fallback (systemMessage), so nothing is said twice.
+
+const FEED = { plugin: "bunshin-ui", key: "feed" };
+const WHERE = { plugin: "bunshin-ui", key: "where" };
+const SEEN = { plugin: "bunshin-ui", key: "seen" };
+const PANEL = { plugin: "bunshin-ui", key: "panel" };
+
+const PANE_ID = "bunshin";
+const POLL_MS = 15_000;
+const BEAT_MS = 60_000;
+const TOAST_KINDS = new Set(["live", "learned", "review", "nudge", "offline"]);
+const BRAND = "magenta";
+
+// Session-only, rebuilt by session.start after a hot reload: closures over that session's $, for
+// timers and button presses (which run outside any hook).
+let host = null;
+let poll = null;
+let lastBeat = 0;
+let refreshing = false;
+
+export function register(on) {
+  on("session.start", async ($, e, next) => {
+    const result = await next(e);
+    host = {
+      refresh: () => refresh($),
+      act: (what) => act($, what),
+      review: () => showReview($),
+      session: () => showSession($),
+    };
+    await locate($);
+    await refresh($, { first: true });
+    try {
+      await $.command.register({ name: "bunshin", description: "Bunshin: what the library served this session, lessons, reviews", argumentHint: "[learn|sync|review]" });
+    } catch {
+      /* a command of that name exists (the bunshin plugin's own): the pane still opens from it below */
+    }
+    poll?.cancel();
+    poll = $.clock.every(POLL_MS, () => {
+      if (host) void host.refresh().catch(() => undefined);
+    });
+    return result;
+  });
+
+  // After each Bunshin hook has run (the settings hooks are below us in the chain), read the feed.
+  on("classic.SessionStart", after);
+  on("classic.UserPromptSubmit", after);
+  on("classic.PreToolUse", after);
+  on("classic.Stop", after);
+
+  // /clear and /resume change the session.
+  on("command.run", { command: ["clear", "resume"] }, async ($, e, next) => {
+    const result = await next(e);
+    await locate($);
+    void refresh($, { first: true }).catch(() => undefined);
+    return result;
+  });
+
+  on("command.run", { command: "bunshin" }, async ($, e, next) => {
+    const { value: where } = await $.state.get(WHERE);
+    if (!where) return { text: "Bunshin is not connected here: run `bunshin setup` in the project (or a folder above it)." };
+    const arg = String(e.args ?? "").trim().split(/\s+/)[0];
+    if (arg === "learn" || arg === "sync") {
+      void act($, arg).catch(() => undefined);
+    } else if (arg === "review") {
+      await showReview($);
+    } else {
+      await $.state.set(PANEL, { view: "session", busy: "", output: "" });
+    }
+    const opened = await $.ui.open({ id: PANE_ID, title: "Bunshin", focus: true, closeOnEscape: true, holdToasts: true });
+    if (opened && opened.isPlaced === false) {
+      const { value: feed } = await $.state.get(FEED);
+      return { text: feed ? plainSummary(feed) : "Bunshin: nothing yet this session." };
+    }
+    return {};
+  });
+
+  on("ui.render", { component: "AbovePrompt" }, async ($, e, next) => {
+    if (e.props.hasSurvey) return next(e);
+    const { value: feed } = await $.state.get(FEED);
+    if (!feed) return next(e);
+    const { Box, Text } = $.ui.resolve(e);
+    return band(Box, Text, feed, e.props.bodyColumns);
+  });
+
+  on("ui.render", { component: "Pane" }, async ($, e, next) => {
+    if (e.requestId !== PANE_ID || e.surface === "mobile") return next(e);
+    const { value: feed } = await $.state.get(FEED);
+    const { value: panel = { view: "session", busy: "", output: "" } } = await $.state.get(PANEL);
+    const { Box, Text, Button } = $.ui.resolve(e);
+    return pane({ Box, Text, Button }, feed, panel, e.props.bodyColumns, e.props.scroll?.bodyRows ?? 30);
+  });
+}
+
+/** After one of Bunshin's settings hooks ran (they sit below the mods in the chain): read the feed. */
+async function after($, e, next) {
+  const result = await next(e);
+  void refresh($).catch(() => undefined);
+  return result;
+}
+
+// ── data ────────────────────────────────────────────────────────────────────────────────────────
+
+const safe = (id) => String(id).replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "session";
+
+/** The connected project above the session's folder: the nearest one with .bunshin/config.json. */
+async function locate($) {
+  let where = null;
+  try {
+    const sessionId = await $.session.id();
+    let dir = await $.session.cwd();
+    for (let i = 0; i < 40 && dir; i++) {
+      if (await $.fs.exists(`${dir}/.bunshin/config.json`)) {
+        where = { store: `${dir}/.bunshin/v2`, project: dir, sessionId };
+        break;
+      }
+      const up = dir.replace(/\/[^/]+\/?$/, "");
+      if (!up || up === dir) break;
+      dir = up;
+    }
+  } catch {
+    where = null;
+  }
+  await $.state.set(WHERE, where);
+}
+
+async function refresh($, { first = false } = {}) {
+  if (refreshing) return;
+  refreshing = true;
+  try {
+    const { value: where } = await $.state.get(WHERE);
+    if (!where) return;
+    const file = `${where.store}/ui/${safe(where.sessionId)}.json`;
+    let feed = null;
+    try {
+      if (await $.fs.exists(file)) feed = JSON.parse(await $.fs.read(file));
+    } catch {
+      feed = null;
+    }
+    const now = await $.clock.now();
+    if (now - lastBeat >= BEAT_MS) {
+      lastBeat = now;
+      await $.fs.write(`${where.store}/ui/${safe(where.sessionId)}.mod.json`, JSON.stringify({ at: new Date(now).toISOString(), mod: "bunshin-ui" })).catch(() => undefined);
+    }
+    if (!feed || feed.v !== 1) {
+      await $.state.set(FEED, null);
+      return;
+    }
+    const { value: prev } = await $.state.get(FEED);
+    if (!prev || prev.updatedAt !== feed.updatedAt) await $.state.set(FEED, feed);
+    const { value: seen = 0 } = await $.state.get(SEEN);
+    const last = feed.events.at(-1)?.seq ?? 0;
+    if (first) {
+      // A new or reloaded session: what happened before now is in the pane, not replayed as toasts.
+      if (last !== seen) await $.state.set(SEEN, last);
+      return;
+    }
+    if (last <= seen) return;
+    for (const ev of feed.events.filter((x) => x.seq > seen && TOAST_KINDS.has(x.kind)).slice(-3)) {
+      $.ui.toast(`◆ Bunshin · ${ev.text}`, { timeoutMs: ev.kind === "learned" || ev.kind === "live" ? 8000 : 5000 });
+    }
+    await $.state.set(SEEN, last);
+  } finally {
+    refreshing = false;
+  }
+}
+
+/** Run the CLI for the session (its argv is in the feed, so the runtime copy the hooks use). */
+async function act($, what) {
+  const { value: where } = await $.state.get(WHERE);
+  const { value: feed } = await $.state.get(FEED);
+  if (!where) return;
+  const argv = [...(feed?.cli?.length ? feed.cli : ["bunshin"]), ...(what === "learn" ? ["learn"] : what === "sync" ? ["sync"] : what)];
+  const label = what === "learn" ? "Learning from this session…" : what === "sync" ? "Syncing…" : "Working…";
+  await $.state.set(PANEL, { view: "session", busy: label, output: "" });
+  const res = await $.process
+    .run(argv, { cwd: where.project, env: { CLAUDE_CODE_SESSION_ID: where.sessionId, BUNSHIN_HARNESS: "claude-code" }, timeoutMs: what === "learn" ? 300_000 : 60_000 })
+    .catch((err) => ({ exitCode: 1, stdout: "", stderr: String(err?.message ?? err) }));
+  const output = (res.exitCode === 0 ? res.stdout : res.stderr || res.stdout).trim();
+  await $.state.set(PANEL, { view: "session", busy: "", output });
+  if (output) $.ui.toast(`◆ Bunshin · ${output.split("\n")[0]}`, { timeoutMs: 6000 });
+  await refresh($);
+}
+
+function showSession($) {
+  return $.state.set(PANEL, { view: "session", busy: "", output: "" });
+}
+
+async function showReview($) {
+  const { value: where } = await $.state.get(WHERE);
+  const { value: feed } = await $.state.get(FEED);
+  if (!where) return;
+  await $.state.set(PANEL, { view: "review", busy: "Reading suggestions…", output: "" });
+  const res = await $.process
+    .run([...(feed?.cli?.length ? feed.cli : ["bunshin"]), "review", "list"], { cwd: where.project, env: { BUNSHIN_HARNESS: "claude-code" }, timeoutMs: 30_000 })
+    .catch((err) => ({ exitCode: 1, stdout: "", stderr: String(err?.message ?? err) }));
+  await $.state.set(PANEL, { view: "review", busy: "", output: (res.stdout || res.stderr).trim() || "Nothing waiting for review." });
+}
+
+// ── drawing ─────────────────────────────────────────────────────────────────────────────────────
+
+const label = (s) => (s.skill ? `${s.skill} skill` : `${s.title}`);
+const clip = (s, n) => (s.length > n ? `${s.slice(0, Math.max(1, n - 1))}…` : s);
+const hhmm = (iso) => String(iso).slice(11, 16);
+
+function counts(feed) {
+  const served = feed.served.filter((s) => s.how !== "hint").length;
+  return [
+    feed.library ? `lib@${feed.library}` : "",
+    served ? `${served} served` : "",
+    feed.lessons.length ? `${feed.lessons.length} learned` : "",
+    feed.review ? `${feed.review} to review` : "",
+  ].filter(Boolean);
+}
+
+/** The band above the prompt: ◆ bunshin  <latest served>  why · counts. One line, two when narrow. */
+function band(Box, Text, feed, columns) {
+  const latest = feed.served.find((s) => s.how !== "hint");
+  const hint = feed.served[0]?.how === "hint" ? feed.served.filter((s) => s.how === "hint" && s.at === feed.served[0].at) : [];
+  const meta = counts(feed).join(" · ");
+  const parts = [Text({ color: BRAND, bold: true, children: "◆ bunshin" })];
+  if (latest) {
+    parts.push(Text({ bold: true, children: `  ${clip(label(latest), 40)}` }));
+    if (columns >= 70) parts.push(Text({ dimColor: true, children: `  ${clip(latest.why, Math.max(12, columns - 70))}` }));
+  } else if (hint.length) {
+    parts.push(Text({ dimColor: true, children: `  maybe: ${clip(hint.map(label).join(", "), Math.max(20, columns - 40))}` }));
+  } else {
+    parts.push(Text({ dimColor: true, children: "  listening" }));
+  }
+  if (meta && columns >= 50) parts.push(Text({ dimColor: true, children: `   ${meta}` }));
+  return Box({ flexDirection: "row", paddingX: 1, children: parts });
+}
+
+function plainSummary(feed) {
+  const lines = [`◆ Bunshin — ${counts(feed).join(" · ") || "nothing yet"}`];
+  for (const s of feed.served.slice(0, 8)) lines.push(`- ${hhmm(s.at)} ${s.how} **${label(s)}** — ${s.why}`);
+  for (const l of feed.lessons.slice(-5)) lines.push(`- learned (${l.status}): ${l.target}: ${l.summary}`);
+  return lines.join("\n");
+}
+
+function heading(Text, text) {
+  return Text({ bold: true, color: BRAND, children: text });
+}
+
+function pane({ Box, Text, Button }, feed, panel, columns, rows) {
+  const width = Math.max(30, columns - 2);
+  const body = [];
+  if (!feed) {
+    body.push(Text({ dimColor: true, children: "Nothing yet: Bunshin's hooks write here as the session runs." }));
+  } else if (panel.view === "review") {
+    body.push(heading(Text, "Waiting for your review"));
+    body.push(Text({ children: panel.busy || panel.output, wrap: "wrap" }));
+    body.push(Text({ dimColor: true, children: "Apply or skip each in a terminal: bunshin review apply <id> · skip <id> · apply-all" }));
+  } else {
+    body.push(Text({ dimColor: true, children: clip(counts(feed).join(" · ") || "nothing served yet", width) }));
+    body.push(Text({ children: " " }));
+    body.push(heading(Text, "Served this session"));
+    const served = feed.served.slice(0, Math.max(3, Math.floor(rows / 3)));
+    if (!served.length) body.push(Text({ dimColor: true, children: "  nothing yet" }));
+    for (const s of served) {
+      body.push(
+        Box({
+          flexDirection: "row",
+          children: [
+            Text({ dimColor: true, children: `  ${hhmm(s.at)} ${s.how.padEnd(4)} ` }),
+            Text({ bold: s.how !== "hint", dimColor: s.how === "hint", children: clip(label(s), 36) }),
+            Text({ dimColor: true, children: `  ${clip(s.why, Math.max(10, width - 52))}` }),
+          ],
+        }),
+      );
+    }
+    body.push(Text({ children: " " }));
+    body.push(heading(Text, "Learned from this session"));
+    if (!feed.lessons.length) body.push(Text({ dimColor: true, children: feed.reflectedAt ? "  nothing new" : "  not reflected on yet (Learn now, or at session end)" }));
+    for (const l of feed.lessons.slice(-6)) body.push(Text({ children: clip(`  ${l.status.padEnd(10)} ${l.target}: ${l.summary}`, width), wrap: "truncate-end" }));
+    const recent = feed.events.filter((x) => x.kind !== "served" && x.kind !== "hint" && x.kind !== "push").slice(-4);
+    if (recent.length) {
+      body.push(Text({ children: " " }));
+      body.push(heading(Text, "Recent"));
+      for (const ev of recent) body.push(Text({ dimColor: true, children: clip(`  ${hhmm(ev.at)}  ${ev.text}`, width) }));
+    }
+    if (panel.busy || panel.output) {
+      body.push(Text({ children: " " }));
+      body.push(Text({ color: panel.busy ? "yellow" : undefined, children: clip(panel.busy || panel.output.split("\n").slice(-3).join("  "), width) }));
+    }
+  }
+  const buttons = [
+    Button({ label: "Learn now", hotkey: "l", onPress: () => host && void host.act("learn").catch(() => undefined) }),
+    Button({ label: "Sync", hotkey: "s", onPress: () => host && void host.act("sync").catch(() => undefined) }),
+    panel.view === "review"
+      ? Button({ label: "Session", hotkey: "b", onPress: () => host && void host.session().catch(() => undefined) })
+      : Button({ label: feed?.review ? `Review (${feed.review})` : "Review", hotkey: "r", onPress: () => host && void host.review().catch(() => undefined) }),
+  ];
+  return Box({
+    flexDirection: "column",
+    paddingX: 1,
+    children: [...body, Text({ children: " " }), Box({ flexDirection: "row", gap: 2, children: buttons })],
+  });
+}

package/dist/claude-code-ui/hooks/hooks.json

@@ -0,0 +1,4 @@
+{
+  "description": "Bunshin's session feed (.bunshin/v2/ui/<session>.json), drawn above the prompt and in /bunshin.",
+  "modules": ["./bunshin-ui.mjs"]
+}

package/dist/claude-code-ui/types/index.d.ts

@@ -0,0 +1,31 @@
+// State the bunshin-ui mod keeps in the session ($.state): survives hot reloads.
+export type BunshinUiServed = { id: string; title: string; kind: string; skill?: string; how: "auto" | "push" | "hint" | "load"; why: string; at: string };
+export type BunshinUiEvent = { seq: number; at: string; kind: string; text: string };
+export type BunshinUiLesson = { id: string; summary: string; status: string; target: string };
+export type BunshinUiFeed = {
+  v: number;
+  sessionId: string;
+  updatedAt: string;
+  library?: number;
+  served: BunshinUiServed[];
+  events: BunshinUiEvent[];
+  lessons: BunshinUiLesson[];
+  review: number;
+  checkpointAt?: string;
+  reflectedAt?: string;
+  cli: string[];
+  root: string;
+};
+export type BunshinUiWhere = { store: string; project: string; sessionId: string };
+export type BunshinUiPanel = { view: "session" | "review"; busy: string; output: string };
+
+declare module "claude-code" {
+  interface PluginState {
+    "bunshin-ui": {
+      feed: BunshinUiFeed | null;
+      where: BunshinUiWhere | null;
+      seen: number;
+      panel: BunshinUiPanel;
+    };
+  }
+}

package/dist/pi-extension.js

@@ -78,11 +78,20 @@ async function hook(event, ctx, extra = {}) {
     transcript_path: transcript(ctx),
     ...extra
   });
+  let output = {};
   try {
-    return JSON.parse(raw);
+    output = JSON.parse(raw);
   } catch {
     return {};
   }
+  showUi(output, ctx);
+  return output;
+}
+function showUi(output, ctx) {
+  if (!ctx.hasUI || !output.bunshinUi) return;
+  const { lines = [], notices = [] } = output.bunshinUi;
+  ctx.ui.setWidget("bunshin", lines.length ? lines : void 0);
+  for (const n of notices) ctx.ui.notify(`Bunshin: ${n}`, "info");
 }
 function bunshin(pi) {
   if (process.env.BUNSHIN_CHILD || process.env.BUNSHIN_DISABLE) return;
@@ -144,5 +153,6 @@ function bunshin(pi) {
 }
 export {
   bunshin as default,
+  showUi,
   transcriptLines
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunshin-cc/bunshin",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Shared memory for company AI agents. Connect Codex, Claude Code, or Pi to Bunshin.",
   "type": "module",
   "bin": {
@@ -50,7 +50,7 @@
     "knowledge"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json --noEmit && esbuild src/bin.ts --bundle --platform=node --target=node20 --format=esm --external:@anthropic-ai/sdk --external:yaml --outfile=dist/bin.js && esbuild src/git-remote-bunshin.ts --bundle --platform=node --target=node20 --format=esm --outfile=dist/git-remote-bunshin.js && esbuild ../../adapters/pi/index.ts --bundle --platform=node --target=node22 --format=esm --outfile=dist/pi-extension.js",
+    "build": "tsc -p tsconfig.json --noEmit && esbuild src/bin.ts --bundle --platform=node --target=node20 --format=esm --external:@anthropic-ai/sdk --external:yaml --outfile=dist/bin.js && esbuild src/git-remote-bunshin.ts --bundle --platform=node --target=node20 --format=esm --outfile=dist/git-remote-bunshin.js && esbuild ../../adapters/pi/index.ts --bundle --platform=node --target=node22 --format=esm --outfile=dist/pi-extension.js && node scripts/copy-mod.mjs",
     "dev": "tsx src/bin.ts",
     "test": "vitest run",
     "typecheck": "tsc -p tsconfig.json --noEmit"