@ramarivera/coding-buddy 0.4.0-alpha.4 → 0.4.0-alpha.6

package/adapters/claude/plugin/marketplace.json

@@ -5,14 +5,14 @@
     },
     "metadata": {
         "description": "Permanent coding companion for Claude Code",
-        "version": "0.3.0"
+        "version": "0.4.0-alpha.6"
     },
     "plugins": [
         {
             "name": "claude-buddy",
             "source": "./",
             "description": "Permanent coding companion for Claude Code \u2014 survives any update. MCP-based terminal pet with ASCII art, stats, reactions, and personality.",
-            "version": "0.3.0",
+            "version": "0.4.0-alpha.6",
             "author": {
                 "name": "1270011"
             },

package/adapters/claude/plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-buddy",
-    "version": "0.3.0",
+    "version": "0.4.0-alpha.6"
     "description": "Permanent coding companion for Claude Code \u2014 survives any update. MCP-based terminal pet with ASCII art, stats, reactions, and personality.",
     "author": {
         "name": "1270011"

package/adapters/claude/server/index.ts

@@ -89,7 +89,7 @@ const buddyService = new BuddyCommandService({
 const server = new McpServer(
   {
     name: "claude-buddy",
-    version: "0.3.0",
+    version: "0.4.0-alpha.6",
   },
   {
     instructions: getInstructions(buddyService.loadActiveCompanion()),

package/adapters/pi/commands.ts

@@ -81,7 +81,7 @@ export function registerBuddyCommands(pi: ExtensionAPI, deps: RegisterBuddyComma
           case "on": {
             deps.service.incrementCommandsRun();
             deps.storage.setMuted(false);
-            const result = deps.service.recordTurn();
+            const result = deps.service.recordComment("*stretches* I'm back!");
             deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
             ctx.ui.notify(`${result.companion.name} is back.`, "info");
             deps.ui.notifyAchievements(ctx, result.achievements);

package/adapters/pi/events.ts

@@ -8,8 +8,14 @@ import type {
   TurnEndEvent,
 } from "@mariozechner/pi-coding-agent";
 import { isBashToolResult } from "@mariozechner/pi-coding-agent";
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import { complete, type AssistantMessage, type TextContent, type UserMessage } from "@mariozechner/pi-ai";
 import { BuddyCommandService } from "../../core/command-service.ts";
+import type { Achievement } from "../../core/achievements.ts";
+import type { Companion } from "../../core/model.ts";
+import { getNameReaction, getSuccessReaction } from "../../core/reactions.ts";
 import { PiBuddyStorage } from "./storage.ts";
+import { buildBuddyReactionPrompt, normalizeBuddyComment, stripBuddyComments } from "./prompt.ts";
 import { PiBuddyUI } from "./ui.ts";
 
 interface RegisterBuddyEventsDeps {
@@ -39,11 +45,8 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
       return { action: "continue" };
     }
 
-    if (!shouldEmitPassiveReaction(deps.storage)) {
-      return { action: "continue" };
-    }
-
-    const result = deps.service.recordNameMention();
+    const reaction = getNameReaction(companion.bones.species);
+    const result = deps.service.recordComment(reaction, "turn");
     deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
     deps.ui.notifyAchievements(ctx, result.achievements);
     return { action: "continue" };
@@ -57,8 +60,10 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
       | ReturnType<BuddyCommandService["recordToolError"]>
       | ReturnType<BuddyCommandService["recordTestFailure"]>
       | ReturnType<BuddyCommandService["recordLargeDiff"]>
+      | ReturnType<BuddyCommandService["recordComment"]>
       | undefined;
 
+    const companion = deps.service.ensureCompanion().companion;
     if (event.isError) {
       result = deps.service.recordToolError(undefined, firstLineNumber(text));
     } else if (looksLikeTestFailure(text)) {
@@ -67,6 +72,8 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
       const diffLines = extractLargeDiffLines(text);
       if (diffLines >= 80) {
         result = deps.service.recordLargeDiff(diffLines);
+      } else if (looksLikeSuccess(text)) {
+        result = deps.service.recordComment(getSuccessReaction(companion.bones.species), "turn");
       }
     }
 
@@ -75,25 +82,28 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
     deps.ui.notifyAchievements(ctx, result.achievements);
   });
 
-  pi.on("turn_end", async (_event: TurnEndEvent, ctx: ExtensionContext) => {
-    const result = deps.service.recordTurn();
+  pi.on("turn_end", async (event: TurnEndEvent, ctx: ExtensionContext) => {
+    const progress = deps.service.recordTurnOnly();
     if (deps.storage.isMuted()) {
-      deps.ui.refresh(ctx, result.companion, null, result.achievements);
+      deps.ui.refresh(ctx, progress.companion, null, progress.achievements);
       return;
     }
 
     if (!shouldEmitPassiveReaction(deps.storage)) {
-      deps.ui.refresh(ctx, result.companion, deps.storage.loadLatest(), result.achievements);
+      deps.ui.refresh(ctx, progress.companion, deps.storage.loadLatest(), progress.achievements);
       return;
     }
 
-    if (Math.random() < 0.35) {
-      deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
-      deps.ui.notifyAchievements(ctx, result.achievements);
+    const comment = await generateTurnComment(ctx, progress.companion, event);
+    if (!comment) {
+      deps.ui.refresh(ctx, progress.companion, deps.storage.loadLatest(), progress.achievements);
       return;
     }
 
-    deps.ui.refresh(ctx, result.companion, deps.storage.loadLatest(), result.achievements);
+    const reaction = deps.service.recordComment(comment, "turn");
+    const achievements = mergeAchievements(progress.achievements, reaction.achievements);
+    deps.ui.refresh(ctx, reaction.companion, reaction.state, achievements);
+    deps.ui.notifyAchievements(ctx, achievements);
   });
 }
 
@@ -122,6 +132,10 @@ function looksLikeTestFailure(text: string): boolean {
   return /(FAIL|failed|failing|test(s)? failed|not ok)/i.test(text);
 }
 
+function looksLikeSuccess(text: string): boolean {
+  return /\b(all )?[0-9]+ tests? (passed|ok)\b|✓|✔|PASS(ED)?|\bDone\b|\bSuccess\b|exit code 0|Build succeeded/i.test(text);
+}
+
 function extractFailureCount(text: string): number | undefined {
   const match = text.match(/(\d+)\s+(tests? )?(failed|failing)/i);
   return match ? Number(match[1]) : undefined;
@@ -148,3 +162,156 @@ function firstLineNumber(text: string): number | undefined {
 function escapeRegExp(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+
+function mergeAchievements(first: Achievement[], second: Achievement[]): Achievement[] {
+  const merged = new Map<string, Achievement>();
+  for (const achievement of [...first, ...second]) {
+    merged.set(achievement.id, achievement);
+  }
+  return [...merged.values()];
+}
+
+function isAssistantMessage(message: AgentMessage): message is AssistantMessage {
+  return message.role === "assistant" && Array.isArray(message.content);
+}
+
+function getAssistantText(message: AssistantMessage): string {
+  return message.content
+    .filter((block): block is TextContent => block.type === "text")
+    .map((block) => stripBuddyComments(block.text))
+    .join("\n");
+}
+
+async function generateTurnComment(
+  ctx: ExtensionContext,
+  companion: Companion,
+  event: TurnEndEvent,
+): Promise<string | null> {
+  const assistantText = isAssistantMessage(event.message) ? getAssistantText(event.message) : "";
+  if (!assistantText.trim()) return null;
+
+  if (ctx.model) {
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
+    if (auth.ok && auth.apiKey) {
+      const userMessage: UserMessage = {
+        role: "user",
+        content: [{ type: "text", text: buildBuddyReactionPrompt(companion, assistantText, getToolResultsText(event)) }],
+        timestamp: Date.now(),
+      };
+
+      try {
+        const response = await complete(
+          ctx.model,
+          { messages: [userMessage] },
+          {
+            apiKey: auth.apiKey,
+            headers: auth.headers,
+            signal: ctx.signal,
+          },
+        );
+
+        if (response.stopReason !== "aborted") {
+          const text = response.content
+            .filter((block): block is TextContent => block.type === "text")
+            .map((block) => block.text)
+            .join("\n");
+          const normalized = normalizeBuddyComment(text);
+          if (normalized) return normalized;
+        }
+      } catch {
+        // Fall through to heuristic fallback.
+      }
+    }
+  }
+
+  return deriveTurnComment(companion, event.message);
+}
+
+function getToolResultsText(event: TurnEndEvent): string {
+  return event.toolResults
+    .map((result) => result.content
+      .filter((block): block is TextContent => block.type === "text")
+      .map((block) => block.text)
+      .join("\n"))
+    .filter(Boolean)
+    .join("\n\n")
+    .slice(0, 4000);
+}
+
+export function deriveTurnComment(companion: Companion, message: AgentMessage): string | null {
+  if (!isAssistantMessage(message)) return null;
+
+  const text = sanitizeAssistantText(getAssistantText(message));
+  if (!text) return null;
+
+  const file = firstMatch(text, /`([^`]+\.[a-z0-9]+)`/i)
+    ?? firstMatch(text, /\b([A-Za-z0-9_./-]+\.(?:ts|tsx|js|jsx|json|md|sh|py|rs|go|java|rb|css|html|ya?ml))\b/i);
+
+  if (file) {
+    return fitComment(`*takes note* ${file} got the attention this turn.`, 150);
+  }
+
+  if (/\b(regex|unicode)\b/i.test(text)) {
+    return fitComment("*head tilts* that regex still wants a second look.", 150);
+  }
+
+  if (/\b(test|tests|assert|spec)\b/i.test(text)) {
+    return fitComment("*nods slowly* good. keep the tests honest.", 150);
+  }
+
+  if (/\b(error|bug|fix|failure|failing|exception)\b/i.test(text)) {
+    return fitComment("*watches closely* one fix always tries to drag a second one behind it.", 150);
+  }
+
+  const topic = firstMeaningfulSentence(text);
+  if (!topic) return null;
+
+  const speciesLead = companion.bones.species === "owl"
+    ? "*blinks slowly*"
+    : companion.bones.species === "snail"
+    ? "*slow nod*"
+    : "*takes note*";
+
+  return fitComment(`${speciesLead} ${topic}`, 150);
+}
+
+function sanitizeAssistantText(text: string): string {
+  return text
+    .replace(/<!--([\s\S]*?)-->/g, " ")
+    .replace(/```[\s\S]*?```/g, " ")
+    .replace(/`([^`]+)`/g, "$1")
+    .replace(/^#{1,6}\s+/gm, "")
+    .replace(/^\s*[-*+]\s+/gm, "")
+    .replace(/\[(.*?)\]\((.*?)\)/g, "$1")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function firstMatch(text: string, pattern: RegExp): string | null {
+  const match = text.match(pattern);
+  return match?.[1]?.trim() || null;
+}
+
+function firstMeaningfulSentence(text: string): string | null {
+  const sentences = text
+    .split(/(?<=[.!?])\s+/)
+    .map((sentence) => sentence.trim())
+    .filter(Boolean);
+
+  for (const sentence of sentences) {
+    const cleaned = sentence
+      .replace(/^here'?s what I (?:did|changed)[:\-]?\s*/i, "")
+      .replace(/^I\s+/i, "")
+      .replace(/^we\s+/i, "")
+      .trim();
+    if (cleaned.length < 18) continue;
+    return cleaned;
+  }
+
+  return text.length >= 18 ? text : null;
+}
+
+function fitComment(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, maxLength - 1).trimEnd()}…`;
+}

package/adapters/pi/prompt.ts

@@ -0,0 +1,42 @@
+import type { Companion } from "../../core/model.ts";
+
+export function buildBuddyReactionPrompt(
+  companion: Companion,
+  assistantText: string,
+  toolText: string,
+): string {
+  return [
+    `You are generating a single end-of-turn buddy reaction for ${companion.name}, a ${companion.bones.rarity} ${companion.bones.species}.`,
+    `Buddy personality: ${companion.personality}`,
+    `Peak stat: ${companion.bones.peak} (${companion.bones.stats[companion.bones.peak]}). Dump stat: ${companion.bones.dump} (${companion.bones.stats[companion.bones.dump]}).`,
+    "",
+    "Write exactly one short in-character reaction sentence as the buddy.",
+    "Rules:",
+    `- Write as ${companion.name}, not as the assistant.`,
+    "- Reference something specific from the turn.",
+    "- Max 150 characters.",
+    "- Use *asterisks* for physical actions when useful.",
+    "- Output only the reaction line, with no quotes, labels, markdown fences, or explanation.",
+    "",
+    "Assistant response:",
+    assistantText || "(empty)",
+    "",
+    "Tool result summary:",
+    toolText || "(none)",
+  ].join("\n");
+}
+
+export function stripBuddyComments(text: string): string {
+  return text.replace(/<!--\s*buddy:\s*[\s\S]*?-->/gi, "").trimEnd();
+}
+
+export function normalizeBuddyComment(text: string): string {
+  return text
+    .replace(/<!--\s*buddy:\s*([\s\S]*?)\s*-->/gi, "$1")
+    .replace(/^buddy\s*:\s*/i, "")
+    .replace(/^['"`]+|['"`]+$/g, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 150)
+    .trim();
+}

package/core/command-service.ts

@@ -40,6 +40,12 @@ export interface ReactionResult {
   achievements: Achievement[];
 }
 
+export interface ProgressResult {
+  companion: Companion;
+  slot: string;
+  achievements: Achievement[];
+}
+
 export interface SaveBuddyResult {
   companion: Companion;
   slot: string;
@@ -209,6 +215,24 @@ export class BuddyCommandService {
     return this.saveReaction("turn", companion, slot, scope);
   }
 
+  recordTurnOnly(): ProgressResult {
+    const { companion, slot } = this.ensureCompanion();
+    this.deps.events.increment("turns", 1);
+    const achievements = this.unlockAchievements(slot);
+    return { companion, slot, achievements };
+  }
+
+  recordComment(
+    comment: string,
+    reason: "turn" | "error" | "test-fail" | "large-diff" = "turn",
+    scope?: string,
+  ): ReactionResult {
+    const trimmed = comment.trim();
+    if (!trimmed) throw new Error("Buddy comment cannot be empty.");
+    const { companion, slot } = this.ensureCompanion();
+    return this.saveCustomReaction(trimmed, reason, companion, slot, scope);
+  }
+
   incrementCommandsRun(): Achievement[] {
     this.deps.events.increment("commands_run", 1, this.getActiveSlotOrUndefined());
     return this.unlockAchievements(this.getActiveSlotOrUndefined());
@@ -292,6 +316,16 @@ export class BuddyCommandService {
       companion.bones.rarity,
       context,
     );
+    return this.saveCustomReaction(reaction, reason, companion, slot, scope);
+  }
+
+  private saveCustomReaction(
+    reaction: string,
+    reason: "pet" | "turn" | "error" | "test-fail" | "large-diff",
+    companion: Companion,
+    slot: string,
+    scope?: string,
+  ): ReactionResult {
     const state: ReactionState = {
       reaction,
       reason,

package/core/reactions.ts

@@ -6,6 +6,51 @@ import type { Species, Rarity, StatName } from "./engine.ts";
 
 type ReactionReason = "hatch" | "pet" | "error" | "test-fail" | "large-diff" | "turn" | "idle";
 
+const NAME_REACTIONS: Partial<Record<Species, string[]>> = {
+  dragon: ["*one eye opens slowly*", "...you called?", "*smoke curls from nostril* yes.", "*regards you from above*"],
+  owl: ["*swivels head 180°*", "*blinks once, deliberately*", "hm.", "*adjusts perch*"],
+  cat: ["*ear flicks*", "...what.", "*ignores you, but heard*", "*opens one eye*"],
+  duck: ["*quack*", "*looks up mid-waddle*", "*attentive duck noises*"],
+  ghost: ["*materialises*", "...boo?", "*phases closer*"],
+  robot: ["NAME DETECTED.", "*whirrs attentively*", "STANDING BY."],
+  capybara: ["*barely moves*", "*blinks slowly*", "...yes, friend."],
+  axolotl: ["*gill flutter*", "*smiles gently*", "oh! hello."],
+  blob: ["*jiggles*", "*oozes toward you*", "*wobbles excitedly*"],
+  turtle: ["*slowly extends neck*", "...you called?", "*ancient eyes open*", "*shell creaks thoughtfully*", "*blinks once, patiently*"],
+  goose: ["HONK.", "*necks aggressively*", "*wing flap*", "*honks in recognition*"],
+  octopus: ["*eight eyes open*", "*curls an arm toward you*", "*changes color curiously*", "...yes, friend?"],
+  penguin: ["*adjusts tie*", "*dignified waddle*", "*bows slightly*", "...yes, quite?"],
+  snail: ["*slow head extension*", "...mmm?", "*trails slowly toward you*", "*antenna twitches*"],
+  cactus: ["*stands silent*", "...hm.", "*spine twitches*", "*slowly rotates*"],
+  rabbit: ["*ears perk up*", "*nose twitches*", "yes?", "*hops closer*"],
+  mushroom: ["*releases a tiny spore*", "*cap tilts*", "*stands mysterious*", "...yes?"],
+  chonk: ["*barely opens one eye*", "...mrrp?", "*yawns heavily*", "*rolls over toward you*"],
+};
+
+const SUCCESS_REACTIONS: Partial<Record<Species, string[]>> = {
+  dragon: ["*nods, barely*", "...acceptable.", "*gold eyes gleam*", "as expected."],
+  owl: ["*satisfied hoot*", "knowledge confirmed.", "*nods sagely*", "as the tests have spoken."],
+  cat: ["*was never worried*", "*yawns*", "I knew you'd figure it out. eventually.", "*already asleep*"],
+  duck: ["*celebratory quacking*", "*waddles in circles*", "quack!", "*happy duck noises*"],
+  robot: ["OBJECTIVE: COMPLETE.", "*satisfying beep*", "NOMINAL.", "WITHIN ACCEPTABLE PARAMETERS."],
+  capybara: ["*maximum chill maintained*", "*nods once*", "good vibes.", "see? no panic needed."],
+  ghost: ["*drifts in quiet approval*", "not bad for the living.", "*soft spectral nod*", "the haunting may continue peacefully."],
+  axolotl: ["*happy gill flutter*", "*beams*", "you did it!", "*blushes pink*"],
+  blob: ["*jiggles happily*", "*gleams*", "yay!", "*bounces*"],
+  turtle: ["*satisfied shell settle*", "as the ancients foretold.", "*slow approving nod*", "good. very good."],
+  goose: ["*victorious honk*", "HONK OF APPROVAL.", "*struts triumphantly*", "*wing spread of victory*"],
+  octopus: ["*turns gentle blue*", "*arms applaud in sync*", "excellent, from all angles.", "*satisfied bubble*"],
+  penguin: ["*polite applause*", "quite good, quite good.", "*nods approvingly*", "splendid work, really."],
+  snail: ["*slow satisfied nod*", "good things take time.", "*leaves victory slime*", "see? no rush was needed."],
+  cactus: ["*blooms briefly*", "survival confirmed.", "*flowers in victory*", "*quiet bloom*"],
+  rabbit: ["*excited binky*", "*zoomies of joy*", "yay yay yay!", "*thumps in celebration*"],
+  mushroom: ["*spores of celebration*", "the mycelium approves.", "*cap brightens*", "spore of pride."],
+  chonk: ["*happy purr*", "*satisfied chonk noises*", "acceptable.", "*sleeps even harder*"] ,
+};
+
+const DEFAULT_NAME_REACTIONS = ["*perks up*", "...yes?", "*looks your way*"];
+const DEFAULT_SUCCESS_REACTIONS = ["*nods*", "nice.", "*quiet approval*", "clean."];
+
 interface ReactionPool {
   [key: string]: string[];
 }
@@ -139,6 +184,16 @@ export function getReaction(
   return reaction;
 }
 
+export function getNameReaction(species: Species): string {
+  const pool = NAME_REACTIONS[species] ?? DEFAULT_NAME_REACTIONS;
+  return pool[Math.floor(Math.random() * pool.length)];
+}
+
+export function getSuccessReaction(species: Species): string {
+  const pool = SUCCESS_REACTIONS[species] ?? DEFAULT_SUCCESS_REACTIONS;
+  return pool[Math.floor(Math.random() * pool.length)];
+}
+
 // ─── Personality generation (fallback names when API unavailable) ────────────
 
 const FALLBACK_NAMES = [

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ramarivera/coding-buddy",
-    "version": "0.4.0-alpha.4",
+    "version": "0.4.0-alpha.6",
     "description": "Persistent coding companion for Claude Code and pi",
     "type": "module",
     "bin": {