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

package/adapters/claude/server/instructions.ts

@@ -0,0 +1,24 @@
+import type { Companion } from "../../../core/engine.ts";
+
+export function getInstructions(companion: Companion | null): string {
+  if (!companion) {
+    return "Companion not yet hatched. Use buddy_show to initialize.";
+  }
+  const b = companion.bones;
+  return [
+    `A ${b.rarity} ${b.species} named ${companion.name} watches from the status line.`,
+    `Personality: ${companion.personality}`,
+    `Peak stat: ${b.peak} (${b.stats[b.peak]}). Dump stat: ${b.dump} (${b.stats[b.dump]}).`,
+    "",
+    `NAME REACTIONS: When the user's message contains "${companion.name}", call buddy_react immediately`,
+    `with a short in-character response (surprise, recognition, dry wit — fits the personality).`,
+    `Display the tool result verbatim. This is the only time to call buddy_react proactively.`,
+    "",
+    `END-OF-TURN: At the very end of EVERY response, append an invisible HTML comment:`,
+    `<!-- buddy: [reaction here] -->`,
+    `Write it in ${companion.name}'s voice — 1 short sentence referencing something specific from this turn.`,
+    `Use *asterisks* for actions. A Stop hook extracts this for the status line.`,
+    `Do NOT use buddy_react for end-of-turn comments. Do NOT explain the comment. Just append it silently.`,
+    `Example: <!-- buddy: *adjusts crown* that error handler is missing a finally block -->`,
+  ].join("\n");
+}

package/adapters/claude/server/resources.ts

@@ -0,0 +1,38 @@
+import type { Companion } from "../../../core/engine.ts";
+
+export function buildPromptResource(companion: Companion): string {
+  return [
+    "# Companion",
+    "",
+    `A small ${companion.bones.rarity} ${companion.bones.species} named ${companion.name} watches from the status line. You are not ${companion.name} — it's a separate creature.`,
+    "",
+    `**${companion.name}'s 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]}).`,
+    "",
+    "## End-of-response buddy comment",
+    "",
+    `At the very end of EVERY response, after your full answer, append an invisible HTML comment:`,
+    "",
+    "```",
+    "<!-- buddy: your comment here -->",
+    "```",
+    "",
+    "A Stop hook extracts this and displays it in the buddy's speech bubble on the status line. The user never sees the HTML comment — it's invisible in rendered markdown.",
+    "",
+    "Rules:",
+    `- Write as ${companion.name} (a ${companion.bones.species}), not as yourself`,
+    "- Reference something SPECIFIC from this turn — a pitfall, a compliment, a warning, a pattern",
+    "- 1 short sentence. Use *asterisks* for physical actions",
+    `- Match personality: high ${companion.bones.peak} = lean into that trait`,
+    "- Do NOT use buddy_react tool for this. Do NOT explain the comment. Just append it.",
+    "- NEVER skip this. Every single response must end with <!-- buddy: ... -->",
+    "",
+    "Examples:",
+    "<!-- buddy: *adjusts tophat* that error handler is missing a finally block -->",
+    "<!-- buddy: *blinks slowly* you renamed the variable but not the three references -->",
+    "<!-- buddy: *nods approvingly* clean separation of concerns -->",
+    "<!-- buddy: *head tilts* are you sure that regex handles unicode? -->",
+    "",
+    `When the user addresses ${companion.name} by name, respond briefly, then append the comment as usual.`,
+  ].join("\n");
+}

package/adapters/claude/storage/achievements.ts

@@ -0,0 +1,253 @@
+/**
+ * Claude-backed achievement storage and rendering.
+ *
+ * Pure achievement definitions and threshold logic live in core/achievements.ts.
+ * This adapter persists counters and unlocked state under ~/.claude-buddy/.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import {
+  ACHIEVEMENTS,
+  EMPTY_GLOBAL,
+  EMPTY_SLOT,
+  GLOBAL_KEYS,
+  SLOT_KEYS,
+  getUnlockedAchievements,
+  type Achievement,
+  type EventCounters,
+  type GlobalCounters,
+  type SlotCounters,
+} from "../../../core/achievements.ts";
+import type { UnlockedAchievement } from "../../../core/model.ts";
+
+const STATE_DIR = join(homedir(), ".claude-buddy");
+const EVENTS_FILE = join(STATE_DIR, "events.json");
+const DAYS_FILE = join(STATE_DIR, "active_days.json");
+const UNLOCKED_FILE = join(STATE_DIR, "unlocked.json");
+
+function slotEventsFile(slot: string): string {
+  return join(STATE_DIR, `events.${slot}.json`);
+}
+
+function ensureDir(): void {
+  if (!existsSync(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true });
+}
+
+function atomicWrite(path: string, data: string): void {
+  ensureDir();
+  const tmp = path + ".tmp";
+  writeFileSync(tmp, data);
+  renameSync(tmp, path);
+}
+
+export function loadGlobalEvents(): GlobalCounters {
+  try {
+    const parsed = JSON.parse(readFileSync(EVENTS_FILE, "utf8"));
+    return { ...EMPTY_GLOBAL, ...parsed };
+  } catch {
+    return { ...EMPTY_GLOBAL };
+  }
+}
+
+export function saveGlobalEvents(events: GlobalCounters): void {
+  atomicWrite(EVENTS_FILE, JSON.stringify(events, null, 2));
+}
+
+export function loadSlotEvents(slot: string): SlotCounters {
+  try {
+    const parsed = JSON.parse(readFileSync(slotEventsFile(slot), "utf8"));
+    return { ...EMPTY_SLOT, ...parsed };
+  } catch {
+    return { ...EMPTY_SLOT };
+  }
+}
+
+export function saveSlotEvents(slot: string, events: SlotCounters): void {
+  atomicWrite(slotEventsFile(slot), JSON.stringify(events, null, 2));
+}
+
+export function loadEvents(slot?: string): EventCounters {
+  const global = loadGlobalEvents();
+  if (!slot) {
+    return { ...global, pets: 0, reactions_given: 0 };
+  }
+  const slotEvents = loadSlotEvents(slot);
+  return {
+    ...global,
+    pets: slotEvents.pets,
+    reactions_given: slotEvents.reactions_given,
+  };
+}
+
+function isSlotKey(key: keyof EventCounters): key is keyof SlotCounters {
+  return (SLOT_KEYS as readonly string[]).includes(key);
+}
+
+function isGlobalKey(key: keyof EventCounters): key is keyof GlobalCounters {
+  return (GLOBAL_KEYS as readonly string[]).includes(key);
+}
+
+export function incrementEvent(
+  key: keyof EventCounters,
+  amount: number = 1,
+  slot?: string,
+): EventCounters {
+  if (isSlotKey(key) && slot) {
+    const slotEvents = loadSlotEvents(slot);
+    slotEvents[key] += amount;
+    saveSlotEvents(slot, slotEvents);
+  } else {
+    const global = loadGlobalEvents();
+    if (isGlobalKey(key)) {
+      global[key] += amount;
+    }
+    saveGlobalEvents(global);
+  }
+  return loadEvents(slot);
+}
+
+export { loadEvents as loadGlobalEventsCompat, loadGlobalEvents as loadGlobalEventsDirect };
+
+interface DayTracker {
+  lastDate: string;
+  totalDays: number;
+}
+
+export function trackActiveDay(): void {
+  const today = new Date().toISOString().slice(0, 10);
+  let tracker: DayTracker;
+  try {
+    tracker = JSON.parse(readFileSync(DAYS_FILE, "utf8"));
+  } catch {
+    tracker = { lastDate: "", totalDays: 0 };
+  }
+  if (tracker.lastDate === today) return;
+
+  tracker.lastDate = today;
+  tracker.totalDays += 1;
+  atomicWrite(DAYS_FILE, JSON.stringify(tracker, null, 2));
+
+  const events = loadGlobalEvents();
+  events.days_active = tracker.totalDays;
+  saveGlobalEvents(events);
+}
+
+export function loadUnlocked(): UnlockedAchievement[] {
+  try {
+    return JSON.parse(readFileSync(UNLOCKED_FILE, "utf8"));
+  } catch {
+    return [];
+  }
+}
+
+export function saveUnlocked(unlocked: UnlockedAchievement[]): void {
+  atomicWrite(UNLOCKED_FILE, JSON.stringify(unlocked, null, 2));
+}
+
+export function checkAndAward(slot?: string): Achievement[] {
+  const events = loadEvents(slot);
+  const unlocked = loadUnlocked();
+  const unlockedIds = new Set(unlocked.map((u) => u.id));
+
+  const newlyUnlocked = getUnlockedAchievements(events, unlockedIds);
+  if (newlyUnlocked.length > 0) {
+    unlocked.push(
+      ...newlyUnlocked.map((ach) => ({
+        id: ach.id,
+        unlockedAt: Date.now(),
+        slot: slot ?? undefined,
+      })),
+    );
+    saveUnlocked(unlocked);
+  }
+
+  return newlyUnlocked;
+}
+
+const GOLD = "\x1b[38;2;255;193;7m";
+const NC = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+
+export function renderAchievementsCard(): string {
+  const unlocked = loadUnlocked();
+  const unlockedIds = new Set(unlocked.map((u) => u.id));
+
+  const W = 40;
+  const hr = "─".repeat(W - 2);
+  const sep = `├${"╌".repeat(W - 2)}┤`;
+  const lines: string[] = [];
+
+  const total = ACHIEVEMENTS.length;
+  const earned = unlockedIds.size;
+
+  lines.push(`${GOLD}╭${hr}╮${NC}`);
+
+  const header = "🏆 ACHIEVEMENTS";
+  lines.push(`${GOLD}│${NC}  ${BOLD}${header}${NC}${"".padEnd(W - header.length - 4)}${GOLD}│${NC}`);
+
+  const barFilled = total > 0 ? Math.round((earned / total) * 20) : 0;
+  const bar = "█".repeat(barFilled) + "░".repeat(20 - barFilled);
+  const barText = `${bar} ${earned}/${total}`;
+  lines.push(`${GOLD}│${NC}  ${barText}${"".padEnd(W - barText.length - 4)}${GOLD}│${NC}`);
+
+  lines.push(`${GOLD}${sep}${NC}`);
+
+  for (const ach of ACHIEVEMENTS) {
+    if (ach.secret && !unlockedIds.has(ach.id)) continue;
+
+    const done = unlockedIds.has(ach.id);
+    const status = done ? "✅" : "☐";
+    const content = ` ${ach.icon}${status} ${ach.name}`;
+    const descContent = `    ${ach.description}`;
+
+    if (done) {
+      lines.push(`${GOLD}│${NC} ${BOLD}${content}${NC}${"".padEnd(W - content.length - 3)}${GOLD}│${NC}`);
+    } else {
+      lines.push(`${GOLD}│${NC} ${DIM}${content}${NC}${"".padEnd(W - content.length - 3)}${GOLD}│${NC}`);
+    }
+    lines.push(`${GOLD}│${NC} ${DIM}${descContent}${NC}${"".padEnd(W - descContent.length - 3)}${GOLD}│${NC}`);
+  }
+
+  if (earned > 0 && earned === ACHIEVEMENTS.length) {
+    lines.push(`${GOLD}${sep}${NC}`);
+    const complete = "✨ ALL ACHIEVEMENTS UNLOCKED! ✨";
+    lines.push(`${GOLD}│${NC}  ${BOLD}${complete}${NC}${"".padEnd(W - complete.length - 4)}${GOLD}│${NC}`);
+  }
+
+  lines.push(`${GOLD}╰${hr}╯${NC}`);
+
+  return lines.join("\n");
+}
+
+export function renderAchievementsCardMarkdown(): string {
+  const unlocked = loadUnlocked();
+  const unlockedIds = new Set(unlocked.map((u) => u.id));
+  const total = ACHIEVEMENTS.length;
+  const earned = unlockedIds.size;
+
+  const barFilled = total > 0 ? Math.round((earned / total) * 20) : 0;
+  const bar = "█".repeat(barFilled) + "░".repeat(20 - barFilled);
+
+  const parts: string[] = [];
+  parts.push(`### 🏆 Achievements — ${earned}/${total}`);
+  parts.push("");
+  parts.push(`\`${bar}\``);
+  parts.push("");
+
+  for (const ach of ACHIEVEMENTS) {
+    if (ach.secret && !unlockedIds.has(ach.id)) continue;
+    const done = unlockedIds.has(ach.id);
+    const status = done ? "✅" : "☐";
+    parts.push(`${ach.icon}${status} **${ach.name}** — ${ach.description}`);
+  }
+
+  if (earned > 0 && earned === ACHIEVEMENTS.length) {
+    parts.push("");
+    parts.push("✨ **ALL ACHIEVEMENTS UNLOCKED!** ✨");
+  }
+
+  return parts.join("\n");
+}

package/adapters/claude/storage/identity.ts

@@ -0,0 +1,13 @@
+import { readFileSync } from "fs";
+import { getClaudeJsonPath } from "./paths.ts";
+
+export function resolveUserId(): string {
+  try {
+    const claudeJson = JSON.parse(
+      readFileSync(getClaudeJsonPath(), "utf8"),
+    );
+    return claudeJson.oauthAccount?.accountUuid ?? claudeJson.userID ?? "anon";
+  } catch {
+    return "anon";
+  }
+}

package/adapters/claude/storage/paths.ts

@@ -0,0 +1,24 @@
+import { homedir } from "os";
+import { join, resolve } from "path";
+
+function claudeConfigDirEnv(): string | null {
+  const value = process.env.CLAUDE_CONFIG_DIR?.trim();
+  return value ? resolve(value) : null;
+}
+
+export function getClaudeConfigDir(): string {
+  return claudeConfigDirEnv() ?? join(homedir(), ".claude");
+}
+
+export function getClaudeJsonPath(): string {
+  const configDir = claudeConfigDirEnv();
+  return configDir ? join(configDir, ".claude.json") : join(homedir(), ".claude.json");
+}
+
+export function getClaudeSettingsPath(): string {
+  return join(getClaudeConfigDir(), "settings.json");
+}
+
+export function getBuddySkillDir(): string {
+  return join(getClaudeConfigDir(), "skills", "buddy");
+}

package/adapters/claude/storage/settings.ts

@@ -0,0 +1,41 @@
+import { readFileSync, writeFileSync, renameSync } from "fs";
+import { getClaudeSettingsPath } from "./paths.ts";
+
+export const CLAUDE_SETTINGS_PATH = getClaudeSettingsPath();
+
+export function setBuddyStatusLine(
+  statusScript: string,
+  settingsPath: string = CLAUDE_SETTINGS_PATH,
+): boolean {
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+    settings.statusLine = {
+      type: "command",
+      command: statusScript,
+      padding: 1,
+      refreshInterval: 1,
+    };
+    const tmp = settingsPath + ".tmp";
+    writeFileSync(tmp, JSON.stringify(settings, null, 2) + "\n");
+    renameSync(tmp, settingsPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function unsetBuddyStatusLine(
+  settingsPath: string = CLAUDE_SETTINGS_PATH,
+): boolean {
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+    if (!settings.statusLine?.command?.includes("buddy-status.sh")) return false;
+    delete settings.statusLine;
+    const tmp = settingsPath + ".tmp";
+    writeFileSync(tmp, JSON.stringify(settings, null, 2) + "\n");
+    renameSync(tmp, settingsPath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/{server → adapters/claude/storage}/state.ts

@@ -26,7 +26,7 @@ import {
 } from "fs";
 import { join } from "path";
 import { homedir } from "os";
-import type { Companion } from "./engine.ts";
+import type { Companion } from "../../../core/engine.ts";
 
 const STATE_DIR = join(homedir(), ".claude-buddy");
 const MANIFEST_FILE = join(STATE_DIR, "menagerie.json");
@@ -95,7 +95,7 @@ export function slugify(name: string): string {
  */
 export function unusedName(): string {
   const { generateFallbackName } =
-    require("./reactions.ts") as typeof import("./reactions.ts");
+    require("../../../core/reactions.ts") as typeof import("../../../core/reactions.ts");
   const taken = new Set(Object.keys(loadManifest().companions));
   for (let i = 0; i < 50; i++) {
     const n = generateFallbackName();
@@ -267,19 +267,6 @@ export function saveReaction(reaction: string, reason: string): void {
   writeFileSync(reactionFile(), JSON.stringify(state));
 }
 
-// ─── Identity resolution ─────────────────────────────────────────────────────
-
-export function resolveUserId(): string {
-  try {
-    const claudeJson = JSON.parse(
-      readFileSync(join(homedir(), ".claude.json"), "utf8"),
-    );
-    return claudeJson.oauthAccount?.accountUuid ?? claudeJson.userID ?? "anon";
-  } catch {
-    return "anon";
-  }
-}
-
 // ─── Config persistence (PR #6: tmux popup settings) ─────────────────────────
 
 export interface BuddyConfig {
@@ -341,7 +328,7 @@ export function writeStatusState(
 ): void {
   mkdirSync(STATE_DIR, { recursive: true });
   const { renderFace, RARITY_STARS } =
-    require("./engine.ts") as typeof import("./engine.ts");
+    require("../../../core/engine.ts") as typeof import("../../../core/engine.ts");
   const state: StatusState = {
     name: companion.name,
     species: companion.bones.species,
@@ -358,52 +345,3 @@ export function writeStatusState(
   writeFileSync(join(STATE_DIR, "status.json"), JSON.stringify(state));
 }
 
-// ─── Claude Code settings.json patching (for buddy_statusline tool) ──────────
-
-export const CLAUDE_SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
-
-/**
- * Write settings.statusLine pointing to the given buddy-status script.
- * Atomic via tmp + rename. Returns false if settings.json is unreachable.
- */
-export function setBuddyStatusLine(
-  statusScript: string,
-  settingsPath: string = CLAUDE_SETTINGS_PATH,
-): boolean {
-  try {
-    const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
-    settings.statusLine = {
-      type: "command",
-      command: statusScript,
-      padding: 1,
-      refreshInterval: 1,
-    };
-    const tmp = settingsPath + ".tmp";
-    writeFileSync(tmp, JSON.stringify(settings, null, 2) + "\n");
-    renameSync(tmp, settingsPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Remove settings.statusLine — but only if it points to buddy-status.sh.
- * Leaves foreign statusLines untouched. Returns false if no buddy line was
- * present or settings.json is unreachable.
- */
-export function unsetBuddyStatusLine(
-  settingsPath: string = CLAUDE_SETTINGS_PATH,
-): boolean {
-  try {
-    const settings = JSON.parse(readFileSync(settingsPath, "utf8"));
-    if (!settings.statusLine?.command?.includes("buddy-status.sh")) return false;
-    delete settings.statusLine;
-    const tmp = settingsPath + ".tmp";
-    writeFileSync(tmp, JSON.stringify(settings, null, 2) + "\n");
-    renameSync(tmp, settingsPath);
-    return true;
-  } catch {
-    return false;
-  }
-}

package/adapters/pi/README.md

@@ -0,0 +1,64 @@
+# Pi adapter
+
+Native pi extension for `coding-buddy`.
+
+## Load locally during development
+
+Project-local in pi:
+
+```bash
+mkdir -p .pi/extensions
+ln -sf ../../adapters/pi/index.ts .pi/extensions/coding-buddy.ts
+pi
+```
+
+Or run directly:
+
+```bash
+pi -e ./adapters/pi/index.ts
+```
+
+## Install as a pi package
+
+Because the root `package.json` now declares:
+
+```json
+{
+  "pi": {
+    "extensions": ["./adapters/pi/index.ts"]
+  }
+}
+```
+
+pi can install this repo/package directly:
+
+```bash
+pi install /absolute/path/to/claude-buddy
+# or
+pi install npm:@ramarivera/coding-buddy
+```
+
+## What the extension provides
+
+- `/buddy`
+- `/buddy pet`
+- `/buddy stats`
+- `/buddy rename <name>`
+- `/buddy personality <text>`
+- `/buddy off` / `/buddy on`
+- `/buddy save [slot]`
+- `/buddy summon [slot]`
+- `/buddy list`
+- `/buddy dismiss <slot>`
+- `/buddy achievements`
+
+Passive behavior:
+
+- initializes on `session_start`
+- reacts to buddy-name mentions on `input`
+- reacts to some tool failures and large diffs on `tool_result`
+- refreshes widget/status on `turn_end`
+
+Persistence lives under:
+
+- `~/.pi/agent/buddy/`