@ramarivera/coding-buddy 0.4.0-alpha.1 → 0.4.0-alpha.3

package/README.md

@@ -196,11 +196,10 @@ MCP is an industry-standard protocol. Skills are Markdown files. Hooks and statu
 
 ```
 claude-buddy/
-├── server/          # MCP server — tools, engine, art, reactions, state
-├── skills/buddy/    # /buddy slash command
-├── hooks/           # PostToolUse + Stop hooks (error & comment detection)
-├── statusline/      # Animated right-aligned buddy display
-└── cli/             # install, show, hunt, verify, doctor, backup, uninstall
+├── core/                  # shared buddy domain logic — engine, reactions, achievements, models
+├── adapters/claude/       # Claude adapter — MCP server, storage, skills, hooks, UI, installer
+├── adapters/pi/           # pi adapter — native pi extension (planned)
+└── cli/                   # host-agnostic CLI entrypoints/utilities
 ```
 
 </details>

package/{hooks → adapters/claude/hooks}/hooks.json

@@ -6,7 +6,7 @@
                 "hooks": [
                     {
                         "type": "command",
-                        "command": "./hooks/react.sh"
+                        "command": "./adapters/claude/hooks/react.sh"
                     }
                 ]
             }
@@ -16,7 +16,7 @@
                 "hooks": [
                     {
                         "type": "command",
-                        "command": "./hooks/buddy-comment.sh"
+                        "command": "./adapters/claude/hooks/buddy-comment.sh"
                     }
                 ]
             }
@@ -26,7 +26,7 @@
                 "hooks": [
                     {
                         "type": "command",
-                        "command": "./hooks/name-react.sh"
+                        "command": "./adapters/claude/hooks/name-react.sh"
                     }
                 ]
             }

package/{cli → adapters/claude/install}/backup.ts

@@ -73,7 +73,7 @@ function createBackup(): string {
   const dir = join(BACKUPS_DIR, ts);
   mkdirSync(dir, { recursive: true });
 
-  const manifest: Record<string, any> = { timestamp: ts, files: [] };
+  const manifest: { timestamp: string; files: string[] } = { timestamp: ts, files: [] };
 
   // 1. settings.json
   const settings = tryRead(SETTINGS);
@@ -202,9 +202,9 @@ function restoreBackup(ts: string) {
   const mcpBak = join(dir, "mcpserver.json");
   if (existsSync(mcpBak)) {
     const ourMcp = JSON.parse(readFileSync(mcpBak, "utf8"));
-    let claudeJson: Record<string, any> = {};
+    let claudeJson: { mcpServers?: Record<string, unknown> } = {};
     try {
-      claudeJson = JSON.parse(readFileSync(CLAUDE_JSON, "utf8"));
+      claudeJson = JSON.parse(readFileSync(CLAUDE_JSON, "utf8")) as { mcpServers?: Record<string, unknown> };
     } catch { /* empty */ }
     if (!claudeJson.mcpServers) claudeJson.mcpServers = {};
     claudeJson.mcpServers["claude-buddy"] = ourMcp;

package/{cli → adapters/claude/install}/disable.ts

@@ -12,6 +12,26 @@ import { readFileSync, writeFileSync, existsSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 
+interface HookCommand {
+  type: "command";
+  command: string;
+}
+
+interface HookMatcherEntry {
+  matcher?: string;
+  hooks?: HookCommand[];
+}
+
+interface ClaudeSettings {
+  statusLine?: { command?: string };
+  hooks?: Record<string, HookMatcherEntry[]>;
+  [key: string]: unknown;
+}
+
+function hasBuddyHook(entry: HookMatcherEntry): boolean {
+  return (entry.hooks ?? []).some((hook) => hook.command.includes("claude-buddy"));
+}
+
 const GREEN = "\x1b[32m";
 const YELLOW = "\x1b[33m";
 const BOLD = "\x1b[1m";
@@ -44,7 +64,7 @@ try {
 
 // 2. Remove status line + hooks from settings.json
 try {
-  const settings = JSON.parse(readFileSync(SETTINGS, "utf8"));
+  const settings = JSON.parse(readFileSync(SETTINGS, "utf8")) as ClaudeSettings;
   let changed = false;
 
   if (settings.statusLine?.command?.includes("buddy")) {
@@ -58,7 +78,7 @@ try {
       if (settings.hooks[hookType]) {
         const before = settings.hooks[hookType].length;
         settings.hooks[hookType] = settings.hooks[hookType].filter(
-          (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("claude-buddy")),
+          (h) => !hasBuddyHook(h),
         );
         if (settings.hooks[hookType].length < before) changed = true;
         if (settings.hooks[hookType].length === 0) delete settings.hooks[hookType];

package/{cli → adapters/claude/install}/doctor.ts

@@ -10,12 +10,12 @@
 
 import { readFileSync, existsSync, statSync } from "fs";
 import { execSync } from "child_process";
-import { join, resolve, dirname } from "path";
+import { join, resolve } from "path";
 import { homedir } from "os";
 
-const PROJECT_ROOT = resolve(dirname(import.meta.dir));
+const PROJECT_ROOT = resolve(import.meta.dir, "../../..");
 const HOME = homedir();
-const STATUS_SCRIPT = join(PROJECT_ROOT, "statusline", "buddy-status.sh");
+const STATUS_SCRIPT = join(PROJECT_ROOT, "adapters", "claude", "statusline", "buddy-status.sh");
 
 const RED = "\x1b[31m";
 const GREEN = "\x1b[32m";
@@ -49,9 +49,13 @@ function tryRead(path: string): string | null {
   try { return readFileSync(path, "utf8"); } catch { return null; }
 }
 
-function tryParseJson(text: string | null): any | null {
+function tryParseJson(text: string | null): unknown {
   if (!text) return null;
-  try { return JSON.parse(text); } catch { return null; }
+  try { return JSON.parse(text) as unknown; } catch { return null; }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
 }
 
 // ─── Header ─────────────────────────────────────────────────────────────────
@@ -103,18 +107,20 @@ section("claude-buddy state");
 const menagerie = tryParseJson(tryRead(join(HOME, ".claude-buddy", "menagerie.json")));
 const status = tryParseJson(tryRead(join(HOME, ".claude-buddy", "status.json")));
 
-if (menagerie) {
-  const activeSlot = menagerie.active ?? "buddy";
-  const companion = menagerie.companions?.[activeSlot];
+if (isRecord(menagerie)) {
+  const activeSlot = typeof menagerie.active === "string" ? menagerie.active : "buddy";
+  const companions = isRecord(menagerie.companions) ? menagerie.companions : {};
+  const companion = companions[activeSlot];
   row("Active slot", activeSlot);
-  row("Total slots", String(Object.keys(menagerie.companions ?? {}).length));
-  if (companion) {
-    row("Companion name", companion.name ?? "(none)");
-    row("Species", companion.bones?.species ?? "(none)");
-    row("Rarity", companion.bones?.rarity ?? "(none)");
-    row("Hat", companion.bones?.hat ?? "(none)");
-    row("Eye", companion.bones?.eye ?? "(none)");
-    row("Shiny", String(companion.bones?.shiny ?? false));
+  row("Total slots", String(Object.keys(companions).length));
+  if (isRecord(companion)) {
+    const bones = isRecord(companion.bones) ? companion.bones : {};
+    row("Companion name", typeof companion.name === "string" ? companion.name : "(none)");
+    row("Species", typeof bones.species === "string" ? bones.species : "(none)");
+    row("Rarity", typeof bones.rarity === "string" ? bones.rarity : "(none)");
+    row("Hat", typeof bones.hat === "string" ? bones.hat : "(none)");
+    row("Eye", typeof bones.eye === "string" ? bones.eye : "(none)");
+    row("Shiny", String(typeof bones.shiny === "boolean" ? bones.shiny : false));
   } else {
     err(`No companion found in active slot "${activeSlot}"`);
   }
@@ -122,9 +128,9 @@ if (menagerie) {
   err("No manifest found at ~/.claude-buddy/menagerie.json");
 }
 
-if (status) {
-  row("Status muted", String(status.muted ?? false));
-  row("Current reaction", status.reaction || "(none)");
+if (isRecord(status)) {
+  row("Status muted", String(typeof status.muted === "boolean" ? status.muted : false));
+  row("Current reaction", typeof status.reaction === "string" && status.reaction.length > 0 ? status.reaction : "(none)");
 } else {
   warn("No status state at ~/.claude-buddy/status.json");
 }
@@ -135,24 +141,25 @@ section("Claude Code config");
 const settings = tryParseJson(tryRead(join(HOME, ".claude", "settings.json")));
 const claudeJson = tryParseJson(tryRead(join(HOME, ".claude.json")));
 
-if (settings?.statusLine) {
+if (isRecord(settings) && "statusLine" in settings && settings.statusLine !== undefined) {
   console.log(`  ${DIM}statusLine:${NC}`);
   console.log(`    ${JSON.stringify(settings.statusLine, null, 2).split("\n").join("\n    ")}`);
 } else {
   warn("No statusLine in ~/.claude/settings.json");
 }
 
-if (settings?.hooks) {
+if (isRecord(settings) && isRecord(settings.hooks)) {
   console.log(`  ${DIM}hooks:${NC}`);
   for (const event of Object.keys(settings.hooks)) {
-    const count = settings.hooks[event]?.length ?? 0;
+    const hookEntries = settings.hooks[event];
+    const count = Array.isArray(hookEntries) ? hookEntries.length : 0;
     row(`  ${event}`, `${count} entr${count === 1 ? "y" : "ies"}`);
   }
 } else {
   warn("No hooks configured");
 }
 
-if (claudeJson?.mcpServers?.["claude-buddy"]) {
+if (isRecord(claudeJson) && isRecord(claudeJson.mcpServers) && isRecord(claudeJson.mcpServers["claude-buddy"])) {
   ok("MCP server registered in ~/.claude.json");
   console.log(`    ${JSON.stringify(claudeJson.mcpServers["claude-buddy"], null, 2).split("\n").join("\n    ")}`);
 } else {

package/{cli → adapters/claude/install}/hunt.ts

@@ -10,11 +10,11 @@
 import {
   searchBuddy, renderBuddy, SPECIES, RARITIES, STAT_NAMES,
   type Species, type Rarity, type StatName, type SearchCriteria,
-} from "../server/engine.ts";
+} from "../../../core/engine.ts";
 import {
   saveCompanionSlot, saveActiveSlot, writeStatusState,
   slugify, unusedName, listCompanionSlots,
-} from "../server/state.ts";
+} from "../storage/state.ts";
 import { createInterface } from "readline";
 
 const CYAN  = "\x1b[36m";
@@ -67,8 +67,8 @@ ${CYAN}╚═══════════════════════
   const statsAns = await ask(`\n  Configure stats? [Y/n]: `);
   if (statsAns.toLowerCase() !== "n") {
     wantPeak = await pickFromList("Peak stat (highest):", STAT_NAMES);
-    const dumpOptions = STAT_NAMES.filter((s) => s !== wantPeak);
-    wantDump = await pickFromList("Dump stat (lowest):", dumpOptions as any);
+    const dumpOptions = STAT_NAMES.filter((s): s is Exclude<StatName, typeof wantPeak> => s !== wantPeak);
+    wantDump = await pickFromList("Dump stat (lowest):", dumpOptions);
     console.log(`${GREEN}✓${NC} peak=${wantPeak} dump=${wantDump}`);
   }
 

package/{cli → adapters/claude/install}/install.ts

@@ -7,12 +7,13 @@
 
 import { readFileSync, writeFileSync, mkdirSync, existsSync, cpSync } from "fs";
 import { execSync } from "child_process";
-import { join, resolve, dirname } from "path";
+import { join, resolve } from "path";
 import { homedir } from "os";
 
-import { generateBones, renderBuddy, renderFace, RARITY_STARS } from "../server/engine.ts";
-import { loadCompanion, saveCompanion, resolveUserId, writeStatusState } from "../server/state.ts";
-import { generateFallbackName } from "../server/reactions.ts";
+import { generateBones, renderBuddy, renderFace, RARITY_STARS } from "../../../core/engine.ts";
+import { loadCompanion, saveCompanion, writeStatusState } from "../storage/state.ts";
+import { resolveUserId } from "../storage/identity.ts";
+import { generateFallbackName } from "../../../core/reactions.ts";
 
 const CYAN = "\x1b[36m";
 const GREEN = "\x1b[32m";
@@ -25,7 +26,7 @@ const NC = "\x1b[0m";
 const CLAUDE_DIR = join(homedir(), ".claude");
 const SETTINGS_FILE = join(CLAUDE_DIR, "settings.json");
 const BUDDY_DIR = join(CLAUDE_DIR, "skills", "buddy");
-const PROJECT_ROOT = resolve(dirname(import.meta.dir));
+const PROJECT_ROOT = resolve(import.meta.dir, "../../..");
 
 function banner() {
   console.log(`
@@ -92,15 +93,50 @@ function preflight(): boolean {
 
 // ─── Load / update settings.json ────────────────────────────────────────────
 
-function loadSettings(): Record<string, any> {
+interface HookCommand {
+  type: "command";
+  command: string;
+}
+
+interface HookMatcherEntry {
+  matcher?: string;
+  hooks?: HookCommand[];
+}
+
+interface ClaudeStatusLineConfig {
+  type: "command";
+  command: string;
+  padding: number;
+  refreshInterval: number;
+}
+
+interface ClaudeSettings {
+  statusLine?: ClaudeStatusLineConfig;
+  hooks?: Partial<Record<"SessionStart" | "SessionEnd" | "PostToolUse" | "Stop" | "UserPromptSubmit", HookMatcherEntry[]>>;
+  permissions?: {
+    allow?: string[];
+  };
+  [key: string]: unknown;
+}
+
+interface ClaudeJsonConfig {
+  mcpServers?: Record<string, { command: string; args: string[]; cwd: string }>;
+  [key: string]: unknown;
+}
+
+function hasBuddyHook(entry: HookMatcherEntry): boolean {
+  return (entry.hooks ?? []).some((hook) => hook.command.includes("claude-buddy"));
+}
+
+function loadSettings(): ClaudeSettings {
   try {
-    return JSON.parse(readFileSync(SETTINGS_FILE, "utf8"));
+    return JSON.parse(readFileSync(SETTINGS_FILE, "utf8")) as ClaudeSettings;
   } catch {
     return {};
   }
 }
 
-function saveSettings(settings: Record<string, any>) {
+function saveSettings(settings: ClaudeSettings) {
   mkdirSync(CLAUDE_DIR, { recursive: true });
   writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2) + "\n");
 }
@@ -108,12 +144,12 @@ function saveSettings(settings: Record<string, any>) {
 // ─── Step 1: Register MCP server (in ~/.claude.json) ────────────────────────
 
 function installMcp() {
-  const serverPath = join(PROJECT_ROOT, "server", "index.ts");
+  const serverPath = join(PROJECT_ROOT, "adapters", "claude", "server", "index.ts");
   const claudeJsonPath = join(homedir(), ".claude.json");
 
-  let claudeJson: Record<string, any> = {};
+  let claudeJson: ClaudeJsonConfig = {};
   try {
-    claudeJson = JSON.parse(readFileSync(claudeJsonPath, "utf8"));
+    claudeJson = JSON.parse(readFileSync(claudeJsonPath, "utf8")) as ClaudeJsonConfig;
   } catch { /* fresh config */ }
 
   if (!claudeJson.mcpServers) claudeJson.mcpServers = {};
@@ -131,7 +167,7 @@ function installMcp() {
 // ─── Step 2: Install skill ──────────────────────────────────────────────────
 
 function installSkill() {
-  const srcSkill = join(PROJECT_ROOT, "skills", "buddy", "SKILL.md");
+  const srcSkill = join(PROJECT_ROOT, "adapters", "claude", "skills", "buddy", "SKILL.md");
   mkdirSync(BUDDY_DIR, { recursive: true });
   cpSync(srcSkill, join(BUDDY_DIR, "SKILL.md"), { force: true });
   ok("Skill installed: ~/.claude/skills/buddy/SKILL.md");
@@ -139,8 +175,8 @@ function installSkill() {
 
 // ─── Step 3: Configure status line (with animation refresh) ─────────────────
 
-function installStatusLine(settings: Record<string, any>) {
-  const statusScript = join(PROJECT_ROOT, "statusline", "buddy-status.sh");
+function installStatusLine(settings: ClaudeSettings) {
+  const statusScript = join(PROJECT_ROOT, "adapters", "claude", "statusline", "buddy-status.sh");
 
   settings.statusLine = {
     type: "command",
@@ -167,15 +203,15 @@ function detectTmux(): boolean {
   }
 }
 
-function installPopupHooks(settings: Record<string, any>) {
-  const popupManager = join(PROJECT_ROOT, "popup", "popup-manager.sh");
+function installPopupHooks(settings: ClaudeSettings) {
+  const popupManager = join(PROJECT_ROOT, "adapters", "claude", "popup", "popup-manager.sh");
 
   if (!settings.hooks) settings.hooks = {};
 
   // SessionStart: open popup
   if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
   settings.hooks.SessionStart = settings.hooks.SessionStart.filter(
-    (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("claude-buddy")),
+    (h) => !hasBuddyHook(h),
   );
   settings.hooks.SessionStart.push({
     hooks: [{ type: "command", command: `${popupManager} start` }],
@@ -184,7 +220,7 @@ function installPopupHooks(settings: Record<string, any>) {
   // SessionEnd: close popup
   if (!settings.hooks.SessionEnd) settings.hooks.SessionEnd = [];
   settings.hooks.SessionEnd = settings.hooks.SessionEnd.filter(
-    (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("claude-buddy")),
+    (h) => !hasBuddyHook(h),
   );
   settings.hooks.SessionEnd.push({
     hooks: [{ type: "command", command: `${popupManager} stop` }],
@@ -195,17 +231,17 @@ function installPopupHooks(settings: Record<string, any>) {
 
 // ─── Step 4: Register hooks ─────────────────────────────────────────────────
 
-function installHooks(settings: Record<string, any>) {
-  const reactHook    = join(PROJECT_ROOT, "hooks", "react.sh");
-  const commentHook  = join(PROJECT_ROOT, "hooks", "buddy-comment.sh");
-  const nameHook     = join(PROJECT_ROOT, "hooks", "name-react.sh");
+function installHooks(settings: ClaudeSettings) {
+  const reactHook    = join(PROJECT_ROOT, "adapters", "claude", "hooks", "react.sh");
+  const commentHook  = join(PROJECT_ROOT, "adapters", "claude", "hooks", "buddy-comment.sh");
+  const nameHook     = join(PROJECT_ROOT, "adapters", "claude", "hooks", "name-react.sh");
 
   if (!settings.hooks) settings.hooks = {};
 
   // PostToolUse: detect errors/test failures/successes in Bash output
   if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
   settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(
-    (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("claude-buddy")),
+    (h) => !hasBuddyHook(h),
   );
   settings.hooks.PostToolUse.push({
     matcher: "Bash",
@@ -215,7 +251,7 @@ function installHooks(settings: Record<string, any>) {
   // Stop: extract <!-- buddy: --> comment from Claude's response
   if (!settings.hooks.Stop) settings.hooks.Stop = [];
   settings.hooks.Stop = settings.hooks.Stop.filter(
-    (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("claude-buddy")),
+    (h) => !hasBuddyHook(h),
   );
   settings.hooks.Stop.push({
     hooks: [{ type: "command", command: commentHook }],
@@ -224,7 +260,7 @@ function installHooks(settings: Record<string, any>) {
   // UserPromptSubmit: detect buddy's name in user message → instant status line reaction
   if (!settings.hooks.UserPromptSubmit) settings.hooks.UserPromptSubmit = [];
   settings.hooks.UserPromptSubmit = settings.hooks.UserPromptSubmit.filter(
-    (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("claude-buddy")),
+    (h) => !hasBuddyHook(h),
   );
   settings.hooks.UserPromptSubmit.push({
     hooks: [{ type: "command", command: nameHook }],
@@ -235,7 +271,7 @@ function installHooks(settings: Record<string, any>) {
 
 // ─── Step 5: Ensure MCP tools are allowed ───────────────────────────────────
 
-function ensurePermissions(settings: Record<string, any>) {
+function ensurePermissions(settings: ClaudeSettings) {
   if (!settings.permissions) settings.permissions = {};
   if (!settings.permissions.allow) settings.permissions.allow = [];
 

package/{cli → adapters/claude/install}/pick.ts

@@ -18,12 +18,12 @@
 import {
   loadActiveSlot, saveActiveSlot, listCompanionSlots,
   loadCompanionSlot, saveCompanionSlot, slugify, unusedName, writeStatusState,
-} from "../server/state.ts";
+} from "../storage/state.ts";
 import {
   generateBones, SPECIES, RARITIES, STAT_NAMES, RARITY_STARS,
   type Species, type Rarity, type StatName, type BuddyBones, type Companion,
-} from "../server/engine.ts";
-import { renderCompanionCard } from "../server/art.ts";
+} from "../../../core/engine.ts";
+import { renderCompanionCard } from "../rendering/art.ts";
 import { randomBytes } from "crypto";
 
 // ─── ANSI ─────────────────────────────────────────────────────────────────────

package/{cli → adapters/claude/install}/settings.ts

@@ -7,7 +7,7 @@
  *   bun run settings cooldown 0     Set comment cooldown (0-300 seconds)
  */
 
-import { loadConfig, saveConfig } from "../server/state.ts";
+import { loadConfig, saveConfig } from "../storage/state.ts";
 
 const args = process.argv.slice(2);
 const key = args[0];

package/{cli → adapters/claude/install}/show.ts

@@ -2,8 +2,8 @@
  * claude-buddy show — display current companion in terminal
  */
 
-import { renderBuddy, renderFace, RARITY_STARS } from "../server/engine.ts";
-import { loadCompanion, loadReaction } from "../server/state.ts";
+import { renderBuddy, renderFace, RARITY_STARS } from "../../../core/engine.ts";
+import { loadCompanion, loadReaction } from "../storage/state.ts";
 
 const BOLD = "\x1b[1m";
 const DIM = "\x1b[2m";

package/{cli → adapters/claude/install}/uninstall.ts

@@ -6,6 +6,26 @@ import { readFileSync, writeFileSync, existsSync, rmSync, readdirSync } from "fs
 import { join } from "path";
 import { homedir } from "os";
 
+interface HookCommand {
+  type: "command";
+  command: string;
+}
+
+interface HookMatcherEntry {
+  matcher?: string;
+  hooks?: HookCommand[];
+}
+
+interface ClaudeSettings {
+  statusLine?: { command?: string };
+  hooks?: Record<string, HookMatcherEntry[]>;
+  [key: string]: unknown;
+}
+
+function hasBuddyHook(entry: HookMatcherEntry): boolean {
+  return (entry.hooks ?? []).some((hook) => hook.command.includes("claude-buddy"));
+}
+
 const GREEN = "\x1b[32m";
 const YELLOW = "\x1b[33m";
 const NC = "\x1b[0m";
@@ -63,7 +83,7 @@ try {
 
 // Remove hooks and statusline from settings.json
 try {
-  const settings = JSON.parse(readFileSync(SETTINGS_FILE, "utf8"));
+  const settings = JSON.parse(readFileSync(SETTINGS_FILE, "utf8")) as ClaudeSettings;
   let changed = false;
 
   if (settings.statusLine?.command?.includes("buddy")) {
@@ -76,7 +96,7 @@ try {
     if (settings.hooks?.[hookType]) {
       const before = settings.hooks[hookType].length;
       settings.hooks[hookType] = settings.hooks[hookType].filter(
-        (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("claude-buddy")),
+        (h) => !hasBuddyHook(h),
       );
       if (settings.hooks[hookType].length < before) {
         ok(`${hookType} hooks removed`);

package/{.claude-plugin → adapters/claude/plugin}/plugin.json

@@ -21,7 +21,7 @@
             "type": "stdio",
             "command": "bun",
             "args": [
-                "server/index.ts"
+                "adapters/claude/server/index.ts"
             ]
         }
     }

package/adapters/claude/popup/buddy-popup.sh

@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+# claude-buddy popup entry point -- runs INSIDE the tmux popup
+#
+# Architecture:
+#   - Render loop runs in BACKGROUND (only writes to stdout, never reads stdin)
+#   - Input forwarder runs in FOREGROUND (owns stdin exclusively)
+#
+# The reopen loop in popup-manager.sh handles:
+#   - ESC forwarding (when tmux closes popup on ESC)
+#   - CC pane death detection
+#   - Dynamic resizing on reopen
+#
+# Env vars (set by popup-manager.sh via -e):
+#   CC_PANE    -- tmux pane ID for Claude Code (e.g. %0)
+#   BUDDY_DIR  -- ~/.claude-buddy
+#   BUDDY_SID  -- session ID (sanitized pane number, e.g. "0")
+# Args: $1 = SID (fallback for tmux < 3.4 without -e support)
+
+set -uo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+# Session ID: from env (tmux 3.4+), $1 arg, or "default"
+BUDDY_SID="${BUDDY_SID:-${1:-default}}"
+
+# On tmux 3.2-3.3, env vars are passed via file (no -e flag support)
+ENV_FILE="${HOME}/.claude-buddy/popup-env.$BUDDY_SID"
+if [ -z "${CC_PANE:-}" ] && [ -f "$ENV_FILE" ]; then
+  . "$ENV_FILE"
+fi
+
+if [ -z "${CC_PANE:-}" ]; then
+  echo "Error: CC_PANE not set" >&2
+  sleep 2
+  exit 1
+fi
+
+# ─── Cleanup on exit ─────────────────────────────────────────────────────────
+cleanup() {
+  [ -n "${RENDER_PID:-}" ] && kill "$RENDER_PID" 2>/dev/null
+  tput cnorm 2>/dev/null
+  stty sane 2>/dev/null
+}
+trap cleanup EXIT INT TERM HUP
+
+# Hide cursor
+tput civis 2>/dev/null
+
+# ─── Render loop in BACKGROUND (stdout only, no stdin) ───────────────────────
+"$SCRIPT_DIR/buddy-render.sh" </dev/null &
+RENDER_PID=$!
+
+# ─── Input forwarder in FOREGROUND ───────────────────────────────────────────
+# Raw mode: all bytes pass through without terminal interpretation.
+# No SIGINT on Ctrl-C, no EOF on Ctrl-D, no CR-to-NL on Enter.
+stty raw -echo 2>/dev/null
+
+# Use perl for raw byte forwarding. bash's read -n1 internally overrides
+# terminal settings on each call (saves/restores tty mode), which undoes
+# stty raw and re-enables signal processing. perl's sysread doesn't touch
+# the terminal at all -- it reads raw bytes from the file descriptor.
+#
+# Batching: first byte is a blocking read, then non-blocking drain of any
+# remaining bytes (paste arrives as a burst). The batch is sent to CC in
+# a single tmux send-keys call for efficiency.
+exec perl -e '
+  use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);
+  my $pane = $ENV{CC_PANE};
+  while (1) {
+    my $buf;
+    my $n = sysread(STDIN, $buf, 1);
+    last unless $n;
+    # Non-blocking drain for paste batching
+    my $flags = fcntl(STDIN, F_GETFL, 0);
+    fcntl(STDIN, F_SETFL, $flags | O_NONBLOCK);
+    while (sysread(STDIN, my $more, 4096)) {
+      $buf .= $more;
+    }
+    fcntl(STDIN, F_SETFL, $flags);
+
+    # F12 (\e[24~) = close popup and enter scroll mode
+    if ($buf =~ /\e\[24~/) {
+      my $buddy_dir = $ENV{BUDDY_DIR} || "$ENV{HOME}/.claude-buddy";
+      my $sid = $ENV{BUDDY_SID} // "default";
+      open(my $fh, ">", "$buddy_dir/popup-scroll.$sid");
+      close($fh) if $fh;
+      exit 0;
+    }
+
+    system("tmux", "send-keys", "-t", $pane, "-l", "--", $buf);
+  }
+'