@ramarivera/coding-buddy 0.7.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.7.0",
+  "version": "0.7.1",
   "description": "Persistent coding companion for Claude Code, Pi, and Oh My Pi",
   "type": "module",
   "omp": {

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/statusline/buddy-status.sh

@@ -31,6 +31,7 @@ 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_FILE="$BUDDY_STATE_DIR/reaction.$SID.json"
 REACTION=$(jq -r '.reaction // ""' "$REACTION_FILE" 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' ;;
@@ -188,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="" ;;
@@ -214,11 +217,11 @@ 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")
+ALL_LINES+=("$NAME_LINE"); ALL_COLORS+=("$C")
 
 case "$SPECIES" in
   axolotl|capybara|rabbit|mushroom|chonk) ART_W=10 ;;
@@ -377,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" '')