@ramarivera/coding-buddy 0.6.0 → 0.7.1

package/hooks/suggest.sh

@@ -1,55 +1,11 @@
 #!/usr/bin/env bash
-# coding-buddy Stop hook — proactive suggestion detection
-# Detects coding patterns and offers suggestions when relevant.
-#
-# Combined with buddy-comment.sh to avoid running two separate Stop hooks.
-
-# shellcheck source=../scripts/paths.sh
-source "$(dirname "${BASH_SOURCE[0]}")/../scripts/paths.sh"
-
-STATE_DIR="$BUDDY_STATE_DIR"
-CONFIG_FILE="$STATE_DIR/config.json"
-LAST_SUGGESTION_FILE="$STATE_DIR/.last_suggestion"
-SUGGESTIONS_FILE="$STATE_DIR/suggestions.json"
-
-[ -f "$CONFIG_FILE" ] || exit 0
-
-# Check if suggestions are enabled (default: true)
-SUGGESTIONS_ENABLED="true"
-if [ -f "$CONFIG_FILE" ]; then
-    _enabled=$(jq -r '.suggestionsEnabled // true' "$CONFIG_FILE" 2>/dev/null)
-    [ "$_enabled" = "false" ] && exit 0
-fi
-
-# Check cooldown (default: 180s = 3 min)
-SUGGESTION_COOLDOWN=180
-if [ -f "$CONFIG_FILE" ]; then
-    _cd=$(jq -r '.suggestionCooldown // 180' "$CONFIG_FILE" 2>/dev/null || echo 180)
-    [[ "$_cd" =~ ^[0-9]+$ ]] && SUGGESTION_COOLDOWN=$_cd
-fi
-
-if [ -f "$LAST_SUGGESTION_FILE" ]; then
-    LAST=$(cat "$LAST_SUGGESTION_FILE" 2>/dev/null)
-    NOW=$(date +%s)
-    DIFF=$(( NOW - ${LAST:-0} ))
-    [ "$DIFF" -lt "$SUGGESTION_COOLDOWN" ] && exit 0
-fi
-
-INPUT=$(cat)
-
-# Extract messages
-ASSISTANT_MSG=$(echo "$INPUT" | jq -r '.last_assistant_message // ""' 2>/dev/null)
-[ -z "$ASSISTANT_MSG" ] && exit 0
-
-# Record turn and check patterns
-PLUGIN_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-
-# Check for patterns via the suggestions script
-if [ -x "$(command -v bun)" ]; then
-    # Run the suggestion check (async, non-blocking)
-    bun run "$PLUGIN_ROOT/server/check-suggestions.ts" \
-        "$(echo "$ASSISTANT_MSG" | jq -Rs .)" \
-        >/dev/null 2>&1 &
-fi
-
-exit 0
+set +e
+SCRIPT_DIR="${BASH_SOURCE[0]%/*}"
+ROOT="$(cd "$SCRIPT_DIR/.." 2>/dev/null && pwd)" || exit 0
+[ -n "$ROOT" ] || exit 0
+BUN="$(command -v bun 2>/dev/null || true)"
+[ -x "$BUN" ] || BUN="$HOME/.bun/bin/bun"
+[ -x "$BUN" ] || BUN="/opt/homebrew/bin/bun"
+[ -x "$BUN" ] || BUN="/usr/local/bin/bun"
+[ -x "$BUN" ] || exit 0
+exec "$BUN" run "$ROOT/server/hooks/suggest.ts" || exit 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ramarivera/coding-buddy",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Persistent coding companion for Claude Code, Pi, and Oh My Pi",
   "type": "module",
   "omp": {
@@ -66,9 +66,9 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/1270011/claude-buddy.git"
+    "url": "git+https://github.com/ramarivera/coding-buddy.git"
   },
-  "homepage": "https://github.com/1270011/claude-buddy#readme",
+  "homepage": "https://github.com/ramarivera/coding-buddy#readme",
   "license": "MIT",
   "dependencies": {
     "@homebridge/node-pty-prebuilt-multiarch": "^0.13.1",

package/scripts/paths.sh

@@ -37,7 +37,22 @@ else
   BUDDY_STATE_DIR="$HOME/.claude-buddy"
 fi
 
-export CLAUDE_CFG_DIR CLAUDE_SETTINGS_FILE CLAUDE_USER_CONFIG BUDDY_STATE_DIR
+# Per-session ID for namespacing transient buddy state files
+# (reaction.$SID.json, .last_reaction.$SID, etc.). Precedence:
+#   1. $CLAUDE_CODE_SESSION_ID — Claude Code sets a UUID per session and
+#      propagates it to every child process (hooks, MCP server, statusline).
+#      Shortened to first 8 chars for filename hygiene.
+#   2. $TMUX_PANE — legacy tmux-pane isolation, kept as a fallback.
+#   3. "default" — single-session world.
+if [[ -n "${CLAUDE_CODE_SESSION_ID:-}" ]]; then
+  BUDDY_SID="${CLAUDE_CODE_SESSION_ID:0:8}"
+elif [[ -n "${TMUX_PANE:-}" ]]; then
+  BUDDY_SID="${TMUX_PANE#%}"
+else
+  BUDDY_SID="default"
+fi
+
+export CLAUDE_CFG_DIR CLAUDE_SETTINGS_FILE CLAUDE_USER_CONFIG BUDDY_STATE_DIR BUDDY_SID
 
 # Windows: Chocolatey installs a PowerShell shim for jq that doesn't work in
 # Git Bash. If jq is not found on PATH, check the real Chocolatey binary path

package/server/art.ts

@@ -116,7 +116,7 @@ export const SPECIES_ART: Record<Species, string[][]> = {
      "\\ {E}' '{E} /", 
      " \\ } { /",
      " ≈(° °)≈",
-     "  \x1b[38;2;255;120;0m//|\\\\\x1b[0m"],
+     "  \x1b[38;2;255;120;0m/\x1b[0m'\x1b[38;2;255;120;0m|\x1b[0m'\x1b[38;2;255;120;0m\\\x1b[0m"],
     ["}       {", 
      "|\\^```^/|",
      "\\ {E}' '{E} /", 

package/server/hooks/buddy-comment.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env bun
+
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import {
+  defaultSpawnDetached,
+  fileExists,
+  isOnCooldown,
+  nonNegativeInteger,
+  parseHookInput,
+  readJsonFile,
+  readStdin,
+  resolveHookSessionId,
+  resolveHookStateDir,
+  stringField,
+  type HookRuntime,
+} from "./common.ts";
+
+interface BuddyConfig {
+  commentCooldown?: unknown;
+}
+
+interface Events {
+  turns?: number;
+  [key: string]: unknown;
+}
+
+const BUDDY_COMMENT_PATTERN = /<!--\s*buddy:\s*([\s\S]*?)\s*-->/g;
+
+export interface BuddyCommentResult {
+  comment?: string;
+  updated: boolean;
+}
+
+export function extractBuddyComment(message: string): string {
+  let comment = "";
+  for (const match of message.matchAll(BUDDY_COMMENT_PATTERN)) {
+    const candidate = match[1]?.trim();
+    if (candidate) comment = candidate;
+  }
+  return comment;
+}
+
+export function handleBuddyComment(rawInput: string, runtime: HookRuntime = {}): BuddyCommentResult {
+  const stateDir = resolveHookStateDir(runtime);
+  if (!fileExists(join(stateDir, "status.json"))) return { updated: false };
+
+  const input = parseHookInput(rawInput);
+  if (!input) return { updated: false };
+
+  const assistantMessage = stringField(input, "last_assistant_message");
+  if (!assistantMessage) return { updated: false };
+
+  const comment = extractBuddyComment(assistantMessage);
+  if (!comment) return { updated: false };
+
+  const now = runtime.now?.() ?? Date.now();
+  const sid = resolveHookSessionId(runtime);
+  const config = readJsonFile<BuddyConfig>(join(stateDir, "config.json")) ?? {};
+  const cooldown = nonNegativeInteger(config.commentCooldown, 30);
+  const cooldownFile = join(stateDir, `.last_comment.${sid}`);
+  if (isOnCooldown(cooldownFile, cooldown, now)) return { updated: false };
+
+  mkdirSync(stateDir, { recursive: true });
+  writeFileSync(cooldownFile, String(Math.floor(now / 1000)));
+  writeFileSync(
+    join(stateDir, `reaction.${sid}.json`),
+    JSON.stringify({ reaction: comment, timestamp: now, reason: "turn" }),
+  );
+
+  const eventsFile = join(stateDir, "events.json");
+  const events = readJsonFile<Events>(eventsFile) ?? {};
+  events.turns = (typeof events.turns === "number" ? events.turns : 0) + 1;
+  writeFileSync(eventsFile, JSON.stringify(events, null, 2));
+
+  const spawnDetached = runtime.spawnDetached ?? defaultSpawnDetached(runtime);
+  spawnDetached("server/award-xp.ts", ["turn"]);
+  spawnDetached("server/consolidate.ts", [
+    assistantMessage,
+    stringField(input, "last_user_message"),
+  ]);
+
+  return { comment, updated: true };
+}
+
+if (import.meta.main) {
+  try {
+    handleBuddyComment(await readStdin());
+  } catch {
+    // Claude Code hooks must never fail the turn.
+  }
+  process.exit(0);
+}

package/server/hooks/common.ts

@@ -0,0 +1,95 @@
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import { buddyStateDir } from "../path.ts";
+
+export type JsonObject = Record<string, unknown>;
+
+export interface HookRuntime {
+  now?: () => number;
+  packageRoot?: string;
+  sessionId?: string;
+  spawnDetached?: (script: string, args: string[]) => void;
+  stateDir?: string;
+}
+
+export function parseHookInput(raw: string): JsonObject | null {
+  try {
+    const value = JSON.parse(raw) as unknown;
+    return value && typeof value === "object" && !Array.isArray(value)
+      ? value as JsonObject
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+export function stringField(input: JsonObject, field: string): string {
+  const value = input[field];
+  return typeof value === "string" ? value : "";
+}
+
+export function resolveHookStateDir(runtime: HookRuntime = {}): string {
+  return runtime.stateDir ?? buddyStateDir();
+}
+
+export function resolveHookSessionId(runtime: HookRuntime = {}): string {
+  if (runtime.sessionId) return runtime.sessionId;
+  const ccSid = process.env.CLAUDE_CODE_SESSION_ID;
+  if (ccSid) return ccSid.slice(0, 8);
+  const pane = process.env.TMUX_PANE;
+  if (pane) return pane.replace(/^%/, "");
+  return "default";
+}
+
+export function readJsonFile<T>(path: string): T | null {
+  try {
+    return JSON.parse(readFileSync(path, "utf8")) as T;
+  } catch {
+    return null;
+  }
+}
+
+export function nonNegativeInteger(value: unknown, fallback: number): number {
+  if (Number.isInteger(value) && Number(value) >= 0) return Number(value);
+  if (typeof value === "string" && /^[0-9]+$/.test(value)) return Number(value);
+  return fallback;
+}
+
+export function isOnCooldown(path: string, cooldownSeconds: number, nowMs: number): boolean {
+  try {
+    const last = Number.parseInt(readFileSync(path, "utf8").trim(), 10);
+    if (!Number.isFinite(last)) return false;
+    return Math.floor(nowMs / 1000) - last < cooldownSeconds;
+  } catch {
+    return false;
+  }
+}
+
+export function packageRootFromHooks(): string {
+  return resolve(import.meta.dir, "..", "..");
+}
+
+export function defaultSpawnDetached(runtime: HookRuntime = {}): (script: string, args: string[]) => void {
+  return (script, args) => {
+    const root = runtime.packageRoot ?? packageRootFromHooks();
+    const child = spawn(process.execPath, ["run", join(root, script), ...args], {
+      cwd: root,
+      detached: true,
+      stdio: "ignore",
+    });
+    child.unref();
+  };
+}
+
+export function fileExists(path: string): boolean {
+  try {
+    return existsSync(path);
+  } catch {
+    return false;
+  }
+}
+
+export async function readStdin(): Promise<string> {
+  return await Bun.stdin.text();
+}

package/server/hooks/legacy-bash.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env bun
+
+import { spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+import { packageRootFromHooks, readStdin } from "./common.ts";
+
+const ALLOWED = new Set([
+  "react.sh",
+  "file-type-react.sh",
+  "name-react.sh",
+  "mood-react.sh",
+]);
+
+if (import.meta.main) {
+  try {
+    const script = process.argv[2] ?? "";
+    if (ALLOWED.has(script)) {
+      const root = packageRootFromHooks();
+      const hook = join(root, "hooks", "legacy", script);
+      if (existsSync(hook)) {
+        spawnSync("bash", [hook], {
+          cwd: root,
+          input: await readStdin(),
+          stdio: ["pipe", "ignore", "ignore"],
+          timeout: 14_000,
+        });
+      }
+    }
+  } catch {
+    // Claude Code hooks must never fail the turn.
+  }
+  process.exit(0);
+}

package/server/hooks/suggest.ts

@@ -0,0 +1,60 @@
+#!/usr/bin/env bun
+
+import { join } from "path";
+import {
+  defaultSpawnDetached,
+  fileExists,
+  isOnCooldown,
+  nonNegativeInteger,
+  parseHookInput,
+  readJsonFile,
+  readStdin,
+  resolveHookStateDir,
+  stringField,
+  type HookRuntime,
+} from "./common.ts";
+
+interface SuggestConfig {
+  suggestionCooldown?: unknown;
+  suggestionsEnabled?: unknown;
+}
+
+export interface SuggestHookResult {
+  checked: boolean;
+}
+
+export function handleSuggest(rawInput: string, runtime: HookRuntime = {}): SuggestHookResult {
+  const stateDir = resolveHookStateDir(runtime);
+  const configFile = join(stateDir, "config.json");
+  if (!fileExists(configFile)) return { checked: false };
+
+  const config = readJsonFile<SuggestConfig>(configFile) ?? {};
+  if (config.suggestionsEnabled === false || config.suggestionsEnabled === "false") {
+    return { checked: false };
+  }
+
+  const now = runtime.now?.() ?? Date.now();
+  const cooldown = nonNegativeInteger(config.suggestionCooldown, 180);
+  if (isOnCooldown(join(stateDir, ".last_suggestion"), cooldown, now)) {
+    return { checked: false };
+  }
+
+  const input = parseHookInput(rawInput);
+  if (!input) return { checked: false };
+
+  const assistantMessage = stringField(input, "last_assistant_message");
+  if (!assistantMessage) return { checked: false };
+
+  const spawnDetached = runtime.spawnDetached ?? defaultSpawnDetached(runtime);
+  spawnDetached("server/check-suggestions.ts", [JSON.stringify(assistantMessage)]);
+  return { checked: true };
+}
+
+if (import.meta.main) {
+  try {
+    handleSuggest(await readStdin());
+  } catch {
+    // Claude Code hooks must never fail the turn.
+  }
+  process.exit(0);
+}

package/server/state.ts

@@ -42,9 +42,20 @@ export const STATE_DIR = buddyStateDir();
 const MANIFEST_FILE = join(STATE_DIR, "menagerie.json");
 const CONFIG_FILE = join(STATE_DIR, "config.json");
 
-// ─── Session ID (PR #6: tmux session isolation) ─────────────────────────────
+// ─── Session ID (Claude Code session isolation, tmux pane fallback) ─────────
+//
+// Precedence:
+//   1. $CLAUDE_CODE_SESSION_ID — Claude Code sets a UUID per session and
+//      propagates it to the MCP server, hooks, and statusline. Shortened
+//      to first 8 chars to keep filenames readable.
+//   2. $TMUX_PANE — legacy tmux-pane isolation kept as a fallback.
+//   3. "default" — single-session world.
+//
+// Must match the bash equivalent in scripts/paths.sh.
 
 function sessionId(): string {
+  const ccSid = process.env.CLAUDE_CODE_SESSION_ID;
+  if (ccSid && ccSid.length > 0) return ccSid.slice(0, 8);
   const pane = process.env.TMUX_PANE;
   if (!pane) return "default";
   return pane.replace(/^%/, "");
@@ -416,7 +427,7 @@ export function writeStatusState(
     eye: companion.bones.eye,
     shiny: companion.bones.shiny,
     hat: companion.bones.hat,
-    reaction: reaction ?? "",
+    reaction: "",
     muted: muted ?? false,
     achievement: achievement ?? "",
     frames,
@@ -426,6 +437,7 @@ export function writeStatusState(
     mood: moodStr,
   };
   writeFileSync(join(STATE_DIR, "status.json"), JSON.stringify(state));
+  if (reaction) saveReaction(reaction, "mcp");
 }
 
 // ─── Claude Code settings.json patching (for buddy_statusline tool) ──────────

package/statusline/buddy-status.sh

@@ -19,9 +19,8 @@ source "$(dirname "${BASH_SOURCE[0]}")/../scripts/paths.sh"
 
 STATE="$BUDDY_STATE_DIR/status.json"
 CONFIG_FILE="$BUDDY_STATE_DIR/config.json"
-# Session ID: sanitized tmux pane number, or "default" outside tmux
-SID="${TMUX_PANE#%}"
-SID="${SID:-default}"
+# Per-session ID resolved by paths.sh (CLAUDE_CODE_SESSION_ID > TMUX_PANE > default)
+SID="$BUDDY_SID"
 
 [ -f "$STATE" ] || exit 0
 
@@ -32,8 +31,10 @@ NAME=$(jq -r '.name // ""' "$STATE" 2>/dev/null)
 [ -z "$NAME" ] && exit 0
 
 RARITY=$(jq -r '.rarity // "common"' "$STATE" 2>/dev/null)
+STARS=$(jq -r '.stars // ""' "$STATE" 2>/dev/null)
 SHINY=$(jq -r '.shiny // false' "$STATE" 2>/dev/null)
-REACTION=$(jq -r '.reaction // ""' "$STATE" 2>/dev/null)
+REACTION_FILE="$BUDDY_STATE_DIR/reaction.$SID.json"
+REACTION=$(jq -r '.reaction // ""' "$REACTION_FILE" 2>/dev/null)
 ACHIEVEMENT=$(jq -r '.achievement // ""' "$STATE" 2>/dev/null)
 LEVEL=$(jq -r '.level // 1' "$STATE" 2>/dev/null)
 MOOD=$(jq -r '.mood // "focused"' "$STATE" 2>/dev/null)
@@ -67,6 +68,7 @@ if [ -f "$CONFIG_FILE" ]; then
 fi
 
 NC=$'\033[0m'
+NEUTRAL=$'\033[39m'
 case "$RARITY" in
   common)
     [ "$_THEME" = "light" ] && C=$'\033[38;2;90;90;90m' || C=$'\033[38;2;153;153;153m' ;;
@@ -150,7 +152,6 @@ BUBBLE=""
 if [ -n "$ACHIEVEMENT" ] && [ "$ACHIEVEMENT" != "null" ] && [ "$ACHIEVEMENT" != "" ]; then
     BUBBLE=$'\xf0\x9f\x8f\x86'" $ACHIEVEMENT"
 fi
-REACTION_FILE="$BUDDY_STATE_DIR/reaction.$SID.json"
 REACTION_TTL=0
 INNER_W=44
 MARGIN=8
@@ -189,6 +190,7 @@ fi
 # so the geometric center sits at col 6.
 NAME_WITH_LEVEL="$NAME"
 [ "$LEVEL" -gt 1 ] 2>/dev/null && NAME_WITH_LEVEL="${NAME} [L${LEVEL}]"
+[ -n "$STARS" ] && NAME_WITH_LEVEL="${NAME_WITH_LEVEL} ${STARS}"
 case "$MOOD" in
     happy)       MOOD_EMOJI="" ;;
     focused)     MOOD_EMOJI="" ;;
@@ -215,13 +217,19 @@ for line in "${ART_LINES[@]}"; do
     if [ "$SHINY" = "true" ]; then
         ALL_COLORS+=("${RAINBOW[$(( (_arc + RAINBOW_OFFSET) % RAINBOW_LEN ))]}")
     else
-        ALL_COLORS+=("$C")
+        ALL_COLORS+=("$NEUTRAL")
     fi
     _arc=$(( _arc + 1 ))
 done
-ALL_LINES+=("$NAME_LINE"); ALL_COLORS+=("$DIM")
-
-ART_W=14
+ALL_LINES+=("$NAME_LINE"); ALL_COLORS+=("$C")
+
+case "$SPECIES" in
+  axolotl|capybara|rabbit|mushroom|chonk) ART_W=10 ;;
+  duck|blob|cat|dragon|robot|wyvern)      ART_W=9  ;;
+  octopus|owl|turtle|snail|ghost|cactus)  ART_W=8  ;;
+  goose|penguin)                          ART_W=7  ;;
+  *)                                      ART_W=10 ;;
+esac
 ART_COUNT=${#ALL_LINES[@]}
 
 # ─── Speech bubble (left of art, word-wrapped) ──────────────────────────────
@@ -372,18 +380,18 @@ for (( i=0; i<MAX_LINES; i++ )); do
 
             # Connector: "-- " on the middle text line, spaces otherwise
             if [ $bi -eq $CONNECTOR_BI ]; then
-                gap="${C}--${NC} "
+                gap="${NEUTRAL}--${NC} "
             else
                 gap="   "
             fi
 
             if [ "$btype" = "border" ]; then
-                echo "${SPACER}${C}${bline}${NC}${gap}${art_part}"
+                echo "${SPACER}${NEUTRAL}${bline}${NC}${gap}${art_part}"
             else
                 pipe_l="${bline:0:1}"
                 pipe_r="${bline: -1}"
                 inner="${bline:1:$(( ${#bline} - 2 ))}"
-                echo "${SPACER}${C}${pipe_l}${NC}${DIM}${inner}${NC}${C}${pipe_r}${NC}${gap}${art_part}"
+                echo "${SPACER}${NEUTRAL}${pipe_l}${NC}${DIM}${inner}${NC}${NEUTRAL}${pipe_r}${NC}${gap}${art_part}"
             fi
         else
             empty=$(printf '%*s' "$BOX_W" '')

package/statusline/combined-status.sh

@@ -99,9 +99,11 @@ def fmt_stat(label, pct, reset):
     c = color_for(pct)
     pct_str = f'{round(pct):3d}%' if pct is not None else '  -%'
     bar = build_bar(pct)
-    text = f'{DIM}{label}{NC} {c}{pct_str}{NC} {bar} {c}↻{reset}{NC}'
-    visual_width = 2 + 1 + 4 + 1 + 10 + 1 + 1 + len(reset)
-    return text, visual_width
+    bar_text = f'{DIM}{label}{NC} {c}{pct_str}{NC} {bar}'
+    bar_width = 2 + 1 + 4 + 1 + 10
+    timer_text = f'   {c}↻{reset}{NC}'
+    timer_width = 3 + 1 + len(reset)
+    return (bar_text, bar_width), (timer_text, timer_width)
 
 try:
     stats = json.loads(os.environ.get('STATS_JSON', '{}'))
@@ -112,14 +114,13 @@ lines = sys.stdin.read().splitlines()
 n = len(lines)
 center = 1 
 
-stat_items = [
-    fmt_stat('5h', stats.get('sess_pct'), stats.get('sess_reset', '--')),
-    fmt_stat('7d', stats.get('week_pct'), stats.get('week_reset', '--')),
-]
+sess = fmt_stat('5h', stats.get('sess_pct'), stats.get('sess_reset', '--'))
+week = fmt_stat('7d', stats.get('week_pct'), stats.get('week_reset', '--'))
+stat_items = [sess[0], sess[1], week[0], week[1]]
 
 for i, line in enumerate(lines):
     si = i - center
-    if 0 <= si < 2 and line.startswith(BRAILLE):
+    if 0 <= si < 4 and line.startswith(BRAILLE):
         stat_text, stat_width = stat_items[si]
         after_braille = line[1:]
         num_spaces = len(after_braille) - len(after_braille.lstrip(' '))