@ramarivera/coding-buddy 0.4.0-alpha.1

package/cli/test-statusline.ts

@@ -0,0 +1,122 @@
+#!/usr/bin/env bun
+/**
+ * claude-buddy test-statusline — temporarily install a test status line
+ *
+ * Run: bun run test-statusline           # install test
+ *      bun run test-statusline restore   # restore original
+ *
+ * The test status line outputs multiple padding strategies side-by-side
+ * so you can see in actual Claude Code which one renders correctly.
+ *
+ * Your original statusLine config is backed up to ~/.claude-buddy/statusline.bak
+ */
+
+import { readFileSync, writeFileSync, existsSync, copyFileSync, chmodSync, mkdirSync } from "fs";
+import { join, dirname, resolve } from "path";
+import { homedir } from "os";
+
+const HOME = homedir();
+const SETTINGS = join(HOME, ".claude", "settings.json");
+const BACKUP = join(HOME, ".claude-buddy", "statusline.bak");
+const TEST_SCRIPT = join(HOME, ".claude-buddy", "test-statusline.sh");
+const SOURCE_SCRIPT = resolve(import.meta.dir, "test-statusline.sh");
+
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const BOLD = "\x1b[1m";
+const NC = "\x1b[0m";
+
+function ok(msg: string) { console.log(`${GREEN}✓${NC}  ${msg}`); }
+function info(msg: string) { console.log(`${CYAN}→${NC}  ${msg}`); }
+function warn(msg: string) { console.log(`${YELLOW}⚠${NC}  ${msg}`); }
+function err(msg: string) { console.log(`${RED}✗${NC}  ${msg}`); }
+
+const action = process.argv[2] || "install";
+
+// ─── Install ────────────────────────────────────────────────────────────────
+
+if (action === "install") {
+  console.log(`\n${BOLD}claude-buddy test status line installer${NC}\n`);
+
+  if (!existsSync(SETTINGS)) {
+    err("~/.claude/settings.json not found");
+    process.exit(1);
+  }
+  if (!existsSync(SOURCE_SCRIPT)) {
+    err(`Source test script missing: ${SOURCE_SCRIPT}`);
+    process.exit(1);
+  }
+
+  // Backup
+  if (existsSync(BACKUP)) {
+    warn(`Backup already exists at ${BACKUP}`);
+    warn("Run 'bun run test-statusline restore' first to revert");
+    process.exit(1);
+  }
+
+  mkdirSync(dirname(BACKUP), { recursive: true });
+  copyFileSync(SETTINGS, BACKUP);
+  ok(`Backed up settings to ${BACKUP}`);
+
+  // Copy the test script (no inline TS interpolation issues)
+  copyFileSync(SOURCE_SCRIPT, TEST_SCRIPT);
+  chmodSync(TEST_SCRIPT, 0o755);
+  ok(`Test script copied to ${TEST_SCRIPT}`);
+
+  // Update settings to use test script
+  const settings = JSON.parse(readFileSync(SETTINGS, "utf8"));
+  settings.statusLine = {
+    type: "command",
+    command: TEST_SCRIPT,
+    padding: 1,
+  };
+  writeFileSync(SETTINGS, JSON.stringify(settings, null, 2));
+  ok("settings.json updated");
+
+  console.log(`
+${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}
+${CYAN}  NEXT STEPS:${NC}
+
+  ${BOLD}1.${NC} Restart Claude Code completely
+  ${BOLD}2.${NC} Take a screenshot of the status line area
+  ${BOLD}3.${NC} Note which lines are visible and which markers align
+  ${BOLD}4.${NC} Restore your original config:
+
+     ${GREEN}bun run test-statusline restore${NC}
+
+  ${BOLD}What to look for:${NC}
+  - Are all 12 lines visible? (or only some?)
+  - Do SPACE_30_END, BRAILLE_30_END, NBSP_30_END align?
+  - Does the mushroom art appear in gold color?
+${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}
+`);
+  process.exit(0);
+}
+
+// ─── Restore ────────────────────────────────────────────────────────────────
+
+if (action === "restore") {
+  console.log(`\n${BOLD}claude-buddy test status line restore${NC}\n`);
+
+  if (!existsSync(BACKUP)) {
+    err(`No backup found at ${BACKUP}`);
+    err("Nothing to restore");
+    process.exit(1);
+  }
+
+  copyFileSync(BACKUP, SETTINGS);
+  ok("Original settings.json restored");
+
+  const { unlinkSync } = require("fs");
+  try { unlinkSync(BACKUP); ok("Backup file removed"); } catch { /* noop */ }
+  try { unlinkSync(TEST_SCRIPT); ok("Test script removed"); } catch { /* noop */ }
+
+  console.log(`\n${GREEN}Done.${NC} Restart Claude Code to apply.\n`);
+  process.exit(0);
+}
+
+err(`Unknown action: ${action}`);
+console.log(`Usage: bun run test-statusline [install|restore]`);
+process.exit(1);

package/cli/uninstall.ts

@@ -0,0 +1,110 @@
+/**
+ * claude-buddy uninstall — remove all integrations
+ */
+
+import { readFileSync, writeFileSync, existsSync, rmSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const NC = "\x1b[0m";
+
+function ok(msg: string) { console.log(`${GREEN}✓${NC}  ${msg}`); }
+function warn(msg: string) { console.log(`${YELLOW}⚠${NC}  ${msg}`); }
+
+const CLAUDE_DIR = join(homedir(), ".claude");
+const SETTINGS_FILE = join(CLAUDE_DIR, "settings.json");
+const SKILL_DIR = join(CLAUDE_DIR, "skills", "buddy");
+const STATE_DIR = join(homedir(), ".claude-buddy");
+
+console.log("\nclaude-buddy uninstall\n");
+
+// Stop all popup reopen loops and close any running popup
+try {
+  if (existsSync(STATE_DIR)) {
+    // Kill all session popup loops (popup-reopen-pid.*)
+    for (const f of readdirSync(STATE_DIR).filter(f => f.startsWith("popup-reopen-pid."))) {
+      const pidPath = join(STATE_DIR, f);
+      const pid = parseInt(readFileSync(pidPath, "utf8").trim(), 10);
+      if (pid > 0) { try { process.kill(pid); } catch { /* already dead */ } }
+      rmSync(pidPath, { force: true });
+    }
+    // Clean up all session-scoped files
+    const patterns = ["popup-stop.", "popup-resize.", "popup-env.", "popup-scroll.",
+                      "reaction.", ".last_reaction.", ".last_comment."];
+    for (const f of readdirSync(STATE_DIR)) {
+      if (patterns.some(p => f.startsWith(p))) {
+        rmSync(join(STATE_DIR, f), { force: true });
+      }
+    }
+  }
+  // Close any open popup
+  if (process.env.TMUX) {
+    const { execSync } = await import("child_process");
+    execSync("tmux display-popup -C 2>/dev/null", { stdio: "ignore" });
+  }
+  ok("Popup stopped");
+} catch { /* not in tmux or no popup */ }
+
+// Remove MCP server from ~/.claude.json
+try {
+  const claudeJsonPath = join(homedir(), ".claude.json");
+  const claudeJson = JSON.parse(readFileSync(claudeJsonPath, "utf8"));
+  if (claudeJson.mcpServers?.["claude-buddy"]) {
+    delete claudeJson.mcpServers["claude-buddy"];
+    if (Object.keys(claudeJson.mcpServers).length === 0) delete claudeJson.mcpServers;
+    writeFileSync(claudeJsonPath, JSON.stringify(claudeJson, null, 2));
+    ok("MCP server removed from ~/.claude.json");
+  }
+} catch {
+  warn("Could not update ~/.claude.json");
+}
+
+// Remove hooks and statusline from settings.json
+try {
+  const settings = JSON.parse(readFileSync(SETTINGS_FILE, "utf8"));
+  let changed = false;
+
+  if (settings.statusLine?.command?.includes("buddy")) {
+    delete settings.statusLine;
+    ok("Status line removed");
+    changed = true;
+  }
+
+  for (const hookType of ["PostToolUse", "Stop", "SessionStart", "SessionEnd"] as const) {
+    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")),
+      );
+      if (settings.hooks[hookType].length < before) {
+        ok(`${hookType} hooks removed`);
+        changed = true;
+      }
+      if (settings.hooks[hookType].length === 0) delete settings.hooks[hookType];
+    }
+  }
+  if (settings.hooks && Object.keys(settings.hooks).length === 0) delete settings.hooks;
+
+  if (changed) {
+    writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2) + "\n");
+  }
+} catch {
+  warn("Could not update settings.json");
+}
+
+// Remove skill
+if (existsSync(SKILL_DIR)) {
+  rmSync(SKILL_DIR, { recursive: true });
+  ok("Skill removed");
+} else {
+  warn("Skill not found (already removed)");
+}
+
+// Keep state dir (companion data) — user might want it back
+if (existsSync(STATE_DIR)) {
+  warn(`Companion data kept at ${STATE_DIR} — delete manually if not needed`);
+}
+
+console.log(`\n${GREEN}Done.${NC} Restart Claude Code to apply changes.\n`);

package/cli/verify.ts

@@ -0,0 +1,19 @@
+/**
+ * claude-buddy verify — show what buddy a user ID produces
+ */
+
+import { generateBones, renderBuddy, STAT_NAMES } from "../server/engine.ts";
+import { resolveUserId } from "../server/state.ts";
+
+const userId = process.argv[3] || resolveUserId();
+
+console.log(`\nUser ID: ${userId.slice(0, 16)}...`);
+console.log("");
+
+const bones = generateBones(userId);
+console.log(renderBuddy(bones));
+
+const statLine = STAT_NAMES.map((n) => `${n}:${bones.stats[n]}`).join(" | ");
+console.log(`\n  ${statLine}`);
+console.log(`  peak=${bones.peak}  dump=${bones.dump}`);
+console.log("");

package/hooks/buddy-comment.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+# buddy-comment Stop hook
+# Extracts hidden buddy comment from Claude's response.
+# Claude writes: <!-- buddy: *adjusts tophat* nice code -->
+# This hook extracts it and updates the status line bubble.
+# The HTML comment is invisible in rendered markdown output.
+
+STATE_DIR="$HOME/.claude-buddy"
+# Session ID: sanitized tmux pane number, or "default" outside tmux
+SID="${TMUX_PANE#%}"
+SID="${SID:-default}"
+STATUS_FILE="$STATE_DIR/status.json"
+COOLDOWN_FILE="$STATE_DIR/.last_comment.$SID"
+CONFIG_FILE="$STATE_DIR/config.json"
+EVENTS_FILE="$STATE_DIR/events.json"
+
+[ -f "$STATUS_FILE" ] || exit 0
+
+# Read cooldown from config (default 30s, 0 = disabled)
+COOLDOWN=30
+if [ -f "$CONFIG_FILE" ]; then
+  _cd=$(jq -r '.commentCooldown // 30' "$CONFIG_FILE" 2>/dev/null || echo 30)
+  # Accept any non-negative integer (including 0 to disable cooldown)
+  [[ "$_cd" =~ ^[0-9]+$ ]] && COOLDOWN=$_cd
+fi
+
+INPUT=$(cat)
+
+# Extract last_assistant_message from hook input
+MSG=$(echo "$INPUT" | jq -r '.last_assistant_message // ""' 2>/dev/null)
+[ -z "$MSG" ] && exit 0
+
+# Extract <!-- buddy: ... --> comment (portable, no grep -P)
+COMMENT=$(echo "$MSG" | sed -n 's/.*<!-- *buddy: *\(.*[^ ]\) *-->.*/\1/p' | tail -1)
+[ -z "$COMMENT" ] && exit 0
+
+# Cooldown: configurable (default 30s)
+if [ -f "$COOLDOWN_FILE" ]; then
+    LAST=$(cat "$COOLDOWN_FILE" 2>/dev/null)
+    NOW=$(date +%s)
+    [ $(( NOW - ${LAST:-0} )) -lt "$COOLDOWN" ] && exit 0
+fi
+
+mkdir -p "$STATE_DIR"
+date +%s > "$COOLDOWN_FILE"
+
+# Update status.json with the reaction
+TMP=$(mktemp)
+jq --arg r "$COMMENT" '.reaction = $r' "$STATUS_FILE" > "$TMP" 2>/dev/null && mv "$TMP" "$STATUS_FILE"
+
+# Also write reaction file (use jq for safe JSON encoding)
+jq -n --arg r "$COMMENT" --arg ts "$(date +%s)000" \
+  '{reaction: $r, timestamp: ($ts | tonumber), reason: "turn"}' \
+  > "$STATE_DIR/reaction.$SID.json"
+
+# Increment achievement event counters
+if command -v jq >/dev/null 2>&1; then
+    if [ ! -f "$EVENTS_FILE" ]; then
+        echo '{}' > "$EVENTS_FILE"
+    fi
+    TMP=$(mktemp)
+    jq '.turns = (.turns // 0 + 1)' "$EVENTS_FILE" > "$TMP" 2>/dev/null && mv "$TMP" "$EVENTS_FILE"
+fi
+
+exit 0

package/hooks/hooks.json

@@ -0,0 +1,35 @@
+{
+    "hooks": {
+        "PostToolUse": [
+            {
+                "matcher": "Bash",
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "./hooks/react.sh"
+                    }
+                ]
+            }
+        ],
+        "Stop": [
+            {
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "./hooks/buddy-comment.sh"
+                    }
+                ]
+            }
+        ],
+        "UserPromptSubmit": [
+            {
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "./hooks/name-react.sh"
+                    }
+                ]
+            }
+        ]
+    }
+}

package/hooks/name-react.sh

@@ -0,0 +1,176 @@
+#!/usr/bin/env bash
+# claude-buddy UserPromptSubmit hook
+# Detects the buddy's name in the user's message → status line reaction.
+# No cooldown — name mentions are intentional.
+
+STATE_DIR="$HOME/.claude-buddy"
+STATUS_FILE="$STATE_DIR/status.json"
+# Session ID: sanitized tmux pane number, or "default" outside tmux
+SID="${TMUX_PANE#%}"
+SID="${SID:-default}"
+
+[ -f "$STATUS_FILE" ] || exit 0
+
+INPUT=$(cat)
+
+# Claude Code sends the prompt in different fields depending on version
+PROMPT=$(echo "$INPUT" | jq -r '
+  .prompt // .message // .user_message //
+  (.messages[-1].content // "") | if type=="array" then .[0].text else . end
+  ' 2>/dev/null)
+[ -z "$PROMPT" ] && exit 0
+
+NAME=$(jq -r '.name // ""' "$STATUS_FILE" 2>/dev/null)
+[ -z "$NAME" ] && exit 0
+
+# Case-insensitive whole-word match
+echo "$PROMPT" | grep -qiE "(^|[^a-zA-Z])${NAME}([^a-zA-Z]|$)" 2>/dev/null || exit 0
+
+SPECIES=$(jq -r '.species // "blob"' "$STATUS_FILE" 2>/dev/null)
+MUTED=$(jq -r '.muted // false' "$STATUS_FILE" 2>/dev/null)
+[ "$MUTED" = "true" ] && exit 0
+
+# Species-specific name-call reactions
+case "$SPECIES" in
+  dragon)
+    REACTIONS=(
+      "*one eye opens slowly*"
+      "...you called?"
+      "*smoke curls from nostril* yes."
+      "*regards you from above*"
+    ) ;;
+  owl)
+    REACTIONS=(
+      "*swivels head 180°*"
+      "*blinks once, deliberately*"
+      "hm."
+      "*adjusts perch*"
+    ) ;;
+  cat)
+    REACTIONS=(
+      "*ear flicks*"
+      "...what."
+      "*ignores you, but heard*"
+      "*opens one eye*"
+    ) ;;
+  duck)
+    REACTIONS=(
+      "*quack*"
+      "*looks up mid-waddle*"
+      "*attentive duck noises*"
+    ) ;;
+  ghost)
+    REACTIONS=(
+      "*materialises*"
+      "...boo?"
+      "*phases closer*"
+    ) ;;
+  robot)
+    REACTIONS=(
+      "NAME DETECTED."
+      "*whirrs attentively*"
+      "STANDING BY."
+    ) ;;
+  capybara)
+    REACTIONS=(
+      "*barely moves*"
+      "*blinks slowly*"
+      "...yes, friend."
+    ) ;;
+  axolotl)
+    REACTIONS=(
+      "*gill flutter*"
+      "*smiles gently*"
+      "oh! hello."
+    ) ;;
+  blob)
+    REACTIONS=(
+      "*jiggles*"
+      "*oozes toward you*"
+      "*wobbles excitedly*"
+    ) ;;
+  turtle)
+    REACTIONS=(
+      "*slowly extends neck*"
+      "...you called?"
+      "*ancient eyes open*"
+      "*shell creaks thoughtfully*"
+      "*blinks once, patiently*"
+    ) ;;
+  goose)
+    REACTIONS=(
+      "HONK."
+      "*necks aggressively*"
+      "*wing flap*"
+      "*honks in recognition*"
+    ) ;;
+  octopus)
+    REACTIONS=(
+      "*eight eyes open*"
+      "*curls an arm toward you*"
+      "*changes color curiously*"
+      "...yes, friend?"
+    ) ;;
+  penguin)
+    REACTIONS=(
+      "*adjusts tie*"
+      "*dignified waddle*"
+      "*bows slightly*"
+      "...yes, quite?"
+    ) ;;
+  snail)
+    REACTIONS=(
+      "*slow head extension*"
+      "...mmm?"
+      "*trails slowly toward you*"
+      "*antenna twitches*"
+    ) ;;
+  cactus)
+    REACTIONS=(
+      "*stands silent*"
+      "...hm."
+      "*spine twitches*"
+      "*slowly rotates*"
+    ) ;;
+  rabbit)
+    REACTIONS=(
+      "*ears perk up*"
+      "*nose twitches*"
+      "yes?"
+      "*hops closer*"
+    ) ;;
+  mushroom)
+    REACTIONS=(
+      "*releases a tiny spore*"
+      "*cap tilts*"
+      "*stands mysterious*"
+      "...yes?"
+    ) ;;
+  chonk)
+    REACTIONS=(
+      "*barely opens one eye*"
+      "...mrrp?"
+      "*yawns heavily*"
+      "*rolls over toward you*"
+    ) ;;
+  *)
+    REACTIONS=(
+      "*perks up*"
+      "...yes?"
+      "*looks your way*"
+    ) ;;
+esac
+
+N=${#REACTIONS[@]}
+REACTION="${REACTIONS[$((RANDOM % N))]}"
+
+mkdir -p "$STATE_DIR"
+
+TMP=$(mktemp)
+jq --arg r "$REACTION" '.reaction = $r' "$STATUS_FILE" > "$TMP" 2>/dev/null && mv "$TMP" "$STATUS_FILE"
+
+jq -n --arg r "$REACTION" --arg ts "$(date +%s)000" \
+  '{reaction: $r, timestamp: ($ts | tonumber), reason: "name"}' \
+  > "$STATE_DIR/reaction.$SID.json"
+
+exit 0