@ramarivera/coding-buddy 0.4.0-alpha.8 → 0.6.0

package/{adapters/claude/install → cli}/uninstall.ts

@@ -1,31 +1,15 @@
 /**
- * claude-buddy uninstall — remove all integrations
+ * coding-buddy uninstall — remove all integrations
  */
 
 import { readFileSync, writeFileSync, existsSync, rmSync, readdirSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
-import { getBuddySkillDir, getClaudeConfigDir, getClaudeJsonPath, getClaudeSettingsPath } from "../storage/paths.ts";
-
-interface HookCommand {
-  type: "command";
-  command: string;
-}
-
-interface HookMatcherEntry {
-  matcher?: string;
-  hooks?: HookCommand[];
-}
-
-interface ClaudeSettings {
-  statusLine?: { command?: string };
-  hooks?: Record<string, HookMatcherEntry[]>;
-  [key: string]: unknown;
-}
-
-function hasBuddyHook(entry: HookMatcherEntry): boolean {
-  return (entry.hooks ?? []).some((hook) => hook.command.includes("claude-buddy"));
-}
+import {
+  buddyStateDir,
+  claudeSettingsPath,
+  claudeSkillDir,
+  claudeUserConfigPath,
+} from "../server/path.ts";
 
 const GREEN = "\x1b[32m";
 const YELLOW = "\x1b[33m";
@@ -34,13 +18,12 @@ 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 = getClaudeConfigDir();
-const SETTINGS_FILE = getClaudeSettingsPath();
-const SKILL_DIR = getBuddySkillDir();
-const CLAUDE_JSON = getClaudeJsonPath();
-const STATE_DIR = join(homedir(), ".claude-buddy");
+const SETTINGS_FILE = claudeSettingsPath();
+const SKILL_DIR = claudeSkillDir("buddy");
+const STATE_DIR = buddyStateDir();
+const CLAUDE_JSON_PATH = claudeUserConfigPath();
 
-console.log("\nclaude-buddy uninstall\n");
+console.log("\ncoding-buddy uninstall\n");
 
 // Stop all popup reopen loops and close any running popup
 try {
@@ -69,22 +52,22 @@ try {
   ok("Popup stopped");
 } catch { /* not in tmux or no popup */ }
 
-// Remove MCP server from ~/.claude.json
+// Remove MCP server from Claude's user config
 try {
-  const claudeJson = JSON.parse(readFileSync(CLAUDE_JSON, "utf8"));
+  const claudeJson = JSON.parse(readFileSync(CLAUDE_JSON_PATH, "utf8"));
   if (claudeJson.mcpServers?.["claude-buddy"]) {
     delete claudeJson.mcpServers["claude-buddy"];
     if (Object.keys(claudeJson.mcpServers).length === 0) delete claudeJson.mcpServers;
-    writeFileSync(CLAUDE_JSON, JSON.stringify(claudeJson, null, 2));
-    ok(`MCP server removed from ${CLAUDE_JSON}`);
+    writeFileSync(CLAUDE_JSON_PATH, JSON.stringify(claudeJson, null, 2));
+    ok(`MCP server removed from ${CLAUDE_JSON_PATH}`);
   }
 } catch {
-  warn(`Could not update ${CLAUDE_JSON}`);
+  warn(`Could not update ${CLAUDE_JSON_PATH}`);
 }
 
 // Remove hooks and statusline from settings.json
 try {
-  const settings = JSON.parse(readFileSync(SETTINGS_FILE, "utf8")) as ClaudeSettings;
+  const settings = JSON.parse(readFileSync(SETTINGS_FILE, "utf8"));
   let changed = false;
 
   if (settings.statusLine?.command?.includes("buddy")) {
@@ -93,11 +76,11 @@ try {
     changed = true;
   }
 
-  for (const hookType of ["PostToolUse", "Stop", "SessionStart", "SessionEnd"] as const) {
+  for (const hookType of ["PostToolUse", "Stop", "SessionStart", "SessionEnd", "UserPromptSubmit"] as const) {
     if (settings.hooks?.[hookType]) {
       const before = settings.hooks[hookType].length;
       settings.hooks[hookType] = settings.hooks[hookType].filter(
-        (h) => !hasBuddyHook(h),
+        (h: any) => !h.hooks?.some((hh: any) => hh.command?.includes("coding-buddy") || hh.command?.includes("claude-buddy")),
       );
       if (settings.hooks[hookType].length < before) {
         ok(`${hookType} hooks removed`);
@@ -123,7 +106,9 @@ if (existsSync(SKILL_DIR)) {
   warn("Skill not found (already removed)");
 }
 
-// Keep state dir (companion data) — user might want it back
+// Keep state dir (companion data) — user might want it back.
+// This is profile-scoped when CLAUDE_CONFIG_DIR is set, so other
+// profiles' buddies are unaffected.
 if (existsSync(STATE_DIR)) {
   warn(`Companion data kept at ${STATE_DIR} — delete manually if not needed`);
 }

package/cli/upgrade.ts

@@ -0,0 +1,213 @@
+#!/usr/bin/env bun
+
+import { readFileSync } from "fs";
+import { execSync } from "child_process";
+import { join, resolve, dirname } from "path";
+import { homedir } from "os";
+
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const NC = "\x1b[0m";
+
+const PROJECT_ROOT = resolve(dirname(import.meta.dir));
+
+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}`); }
+
+function tryExec(cmd: string, fallback = ""): string {
+  try {
+    return execSync(cmd, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return fallback;
+  }
+}
+
+function getCurrentVersion(): string {
+  try {
+    const pkg = JSON.parse(readFileSync(join(PROJECT_ROOT, "package.json"), "utf8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+function banner() {
+  console.log(`
+${CYAN}╔══════════════════════════════════════════════════════════╗${NC}
+${CYAN}║${NC}  ${BOLD}coding-buddy upgrade${NC}                                    ${CYAN}║${NC}
+${CYAN}╚══════════════════════════════════════════════════════════╝${NC}
+`);
+}
+
+function checkGitRepo(): boolean {
+  const isRepo = tryExec("git rev-parse --is-inside-work-tree 2>/dev/null");
+  if (isRepo !== "true") {
+    err("Not inside a git repository. Upgrade requires a git clone of coding-buddy.");
+    return false;
+  }
+  return true;
+}
+
+function getRemoteBranch(): string {
+  const branch = tryExec("git rev-parse --abbrev-ref HEAD 2>/dev/null", "main");
+  return branch === "HEAD" ? "main" : branch;
+}
+
+function checkForUpdates(branch: string): { hasUpdate: boolean; local: string; remote: string; commits: string[] } {
+  info("Fetching latest from remote...\n");
+  try {
+    execSync("git fetch --quiet 2>/dev/null", { cwd: PROJECT_ROOT, stdio: "ignore" });
+  } catch {
+    warn("git fetch failed — proceeding with cached remote state");
+  }
+
+  const local = tryExec("git rev-parse HEAD 2>/dev/null");
+  const upstream = tryExec(`git rev-parse '@{upstream}' 2>/dev/null`);
+  const remote = upstream || tryExec(`git rev-parse origin/${branch} 2>/dev/null`);
+
+  if (!local || !remote) {
+    warn("Could not determine remote HEAD — no tracking branch configured");
+    info(`To set one: git branch --set-upstream-to=origin/${branch} ${branch}`);
+    return { hasUpdate: false, local, remote, commits: [] };
+  }
+
+  if (local === remote) {
+    return { hasUpdate: false, local, remote, commits: [] };
+  }
+
+  const commits = tryExec(
+    `git log --oneline ${local}..origin/${branch} 2>/dev/null`,
+  ).split("\n").filter(Boolean);
+
+  return { hasUpdate: true, local, remote, commits };
+}
+
+function pullLatest(branch: string): boolean {
+  info(`Pulling latest from origin/${branch}...`);
+  try {
+    const output = execSync(`git pull --ff-only origin ${branch} 2>&1`, {
+      cwd: PROJECT_ROOT,
+      encoding: "utf8",
+    });
+    ok("Git pull successful");
+    return true;
+  } catch (e: any) {
+    err("git pull failed — you may have local changes that conflict");
+    err(e.message?.split("\n")[0] || "unknown error");
+    info("Stash or commit your local changes, then re-run upgrade");
+    return false;
+  }
+}
+
+function installDeps(): boolean {
+  info("Installing dependencies...");
+  try {
+    execSync("bun install 2>&1", { cwd: PROJECT_ROOT, stdio: "ignore" });
+    ok("Dependencies installed");
+    return true;
+  } catch {
+    err("bun install failed");
+    return false;
+  }
+}
+
+function reinstallBuddy(): boolean {
+  info("Re-running install-buddy to update integrations...\n");
+  try {
+    execSync("bun run install-buddy 2>&1", { cwd: PROJECT_ROOT, stdio: "inherit" });
+    return true;
+  } catch {
+    err("install-buddy failed");
+    return false;
+  }
+}
+
+function printSummary(oldVersion: string, commits: string[]) {
+  const newVersion = getCurrentVersion();
+
+  console.log("");
+  console.log(`${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}`);
+  console.log(`${GREEN}  Upgrade complete!${NC}`);
+  console.log(`${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}`);
+  console.log("");
+  console.log(`  ${BOLD}Version:${NC}  ${oldVersion} → ${BOLD}${newVersion}${NC}`);
+
+  if (commits.length > 0) {
+    console.log(`  ${BOLD}Changes:${NC}`);
+    const display = commits.slice(0, 15);
+    for (const c of display) {
+      console.log(`    ${DIM}${c}${NC}`);
+    }
+    if (commits.length > 15) {
+      console.log(`    ${DIM}... and ${commits.length - 15} more${NC}`);
+    }
+  }
+
+  console.log("");
+  console.log(`${DIM}  Restart Claude Code for changes to take effect.${NC}`);
+  console.log("");
+}
+
+const args = process.argv.slice(2);
+const checkOnly = args.includes("--check");
+
+banner();
+
+const oldVersion = getCurrentVersion();
+info(`Current version: ${oldVersion}\n`);
+
+if (!checkGitRepo()) {
+  process.exit(1);
+}
+
+const branch = getRemoteBranch();
+const { hasUpdate, commits } = checkForUpdates(branch);
+
+if (!hasUpdate) {
+  ok(`Already up to date (v${oldVersion})`);
+  console.log("");
+  process.exit(0);
+}
+
+if (checkOnly) {
+  warn(`Update available! ${commits.length} new commit${commits.length === 1 ? "" : "s"}:`);
+  for (const c of commits.slice(0, 10)) {
+    console.log(`  ${DIM}${c}${NC}`);
+  }
+  if (commits.length > 10) {
+    console.log(`  ${DIM}... and ${commits.length - 10} more${NC}`);
+  }
+  console.log("");
+  info("Run without --check to apply the update");
+  console.log("");
+  process.exit(0);
+}
+
+info(`${commits.length} new commit${commits.length === 1 ? "" : ""} available:`);
+for (const c of commits.slice(0, 10)) {
+  console.log(`  ${DIM}${c}${NC}`);
+}
+if (commits.length > 10) {
+  console.log(`  ${DIM}... and ${commits.length - 10} more${NC}`);
+}
+console.log("");
+
+if (!pullLatest(branch)) {
+  process.exit(1);
+}
+
+if (!installDeps()) {
+  process.exit(1);
+}
+
+if (!reinstallBuddy()) {
+  process.exit(1);
+}
+
+printSummary(oldVersion, commits);

package/cli/validate-species.ts

@@ -0,0 +1,209 @@
+#!/usr/bin/env bun
+/**
+ * Validate species art format.
+ *
+ * Usage:
+ *   bun run cli/validate-species.ts <path>
+ *   bun run cli/validate-species.ts --check-species <name>
+ *
+ * Exits 0 if valid, 1 if invalid (with error messages to stderr).
+ */
+
+import { readFileSync } from "fs";
+import { join } from "path";
+
+interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+
+const EYE_PLACEHOLDER = "{E}";
+
+/** Check a string for ANSI escape sequences */
+function hasAnsiCodes(s: string): boolean {
+  return s.includes("\x1b[");
+}
+
+/** Strip ANSI codes from a string */
+function stripAnsi(s: string): string {
+  return s.replace(/\x1b\[[^m]*m/g, "");
+}
+
+/** Validate a single art frame (must be exactly 5 lines) */
+function validateFrame(
+  species: string,
+  frameIndex: number,
+  lines: string[],
+): ValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  if (lines.length !== 5) {
+    errors.push(
+      `  Species "${species}" frame ${frameIndex}: expected 5 lines, got ${lines.length}`,
+    );
+  }
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const rawLen = line.length;
+    const displayLen = stripAnsi(line).length;
+
+    if (hasAnsiCodes(line)) {
+      errors.push(
+        `  Species "${species}" frame ${frameIndex} line ${i + 1}: contains ANSI escape sequences (not allowed)`,
+      );
+    }
+
+    if (displayLen > 14) {
+      errors.push(
+        `  Species "${species}" frame ${frameIndex} line ${i + 1}: display width ${displayLen} exceeds max 14 chars`,
+      );
+    }
+
+    // Each species art should have the eye placeholder in at least one line
+    // (not strictly required but warn if missing)
+    if (!line.includes(EYE_PLACEHOLDER) && i === 1) {
+      warnings.push(
+        `  Species "${species}" frame ${frameIndex} line ${i + 1}: missing ${EYE_PLACEHOLDER} eye placeholder (recommended for line 2)`,
+      );
+    }
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+/** Validate art structure from parsed JSON */
+function validateSpeciesArt(
+  species: string,
+  art: string[][],
+): ValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  if (!Array.isArray(art)) {
+    errors.push(`Species "${species}": art must be an array of frames`);
+    return { valid: false, errors, warnings };
+  }
+
+  if (art.length !== 3) {
+    errors.push(
+      `Species "${species}": expected 3 animation frames, got ${art.length}`,
+    );
+  }
+
+  for (let i = 0; i < art.length; i++) {
+    const frame = art[i];
+    const result = validateFrame(species, i, frame);
+    errors.push(...result.errors);
+    warnings.push(...result.warnings);
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+/** Validate a face template — must contain at least one eye placeholder */
+function validateFaceTemplate(
+  species: string,
+  face: string,
+): ValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  if (face.length > 20) {
+    errors.push(
+      `Species "${species}" face template: display width ${face.length} exceeds max 20 chars`,
+    );
+  }
+
+  if (!face.includes(EYE_PLACEHOLDER)) {
+    errors.push(
+      `Species "${species}" face template: missing ${EYE_PLACEHOLDER} eye placeholder`,
+    );
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+/**
+ * Main validation function — validates a species JSON file or inline art.
+ * Returns exit code (0 = valid, 1 = invalid).
+ */
+export function validateSpeciesFile(filePath: string): ValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  let data: Record<string, unknown>;
+  try {
+    const raw = readFileSync(filePath, "utf8");
+    data = JSON.parse(raw);
+  } catch (e) {
+    return {
+      valid: false,
+      errors: [`Failed to read or parse JSON file: ${filePath}`],
+      warnings: [],
+    };
+  }
+
+  const species = data.name as string | undefined;
+  if (!species || typeof species !== "string") {
+    errors.push("Species must have a 'name' field (string)");
+  }
+
+  const art = data.art as string[][] | undefined;
+  if (!art) {
+    errors.push("Species must have an 'art' field (string[][] — 3 frames × 5 lines)");
+  } else {
+    const artResult = validateSpeciesArt(species ?? "unknown", art);
+    errors.push(...artResult.errors);
+    warnings.push(...artResult.warnings);
+  }
+
+  const face = data.face as string | undefined;
+  if (face) {
+    const faceResult = validateFaceTemplate(species ?? "unknown", face);
+    errors.push(...faceResult.errors);
+    warnings.push(...faceResult.warnings);
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+/** Print results and exit with appropriate code */
+function main(): never {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.error("Usage: bun run cli/validate-species.ts <path-to-species-json>");
+    console.error("  Validates art format, ANSI codes, and eye placeholder.");
+    console.error("");
+    console.error("Example:");
+    console.error("  bun run cli/validate-species.ts ./my-species.json");
+    process.exit(1);
+  }
+
+  const filePath = args[0].startsWith("/") ? args[0] : join(process.cwd(), args[0]);
+  const result = validateSpeciesFile(filePath);
+
+  if (result.warnings.length > 0) {
+    console.warn("Warnings:");
+    for (const w of result.warnings) {
+      console.warn(w);
+    }
+    console.warn("");
+  }
+
+  if (result.valid) {
+    console.log(`✓ ${args[0]}: valid`);
+    process.exit(0);
+  } else {
+    console.error("Errors:");
+    for (const e of result.errors) {
+      console.error(e);
+    }
+    process.exit(1);
+  }
+}
+
+main();

package/cli/verify.ts

@@ -1,9 +1,9 @@
 /**
- * claude-buddy verify — show what buddy a user ID produces
+ * coding-buddy verify — show what buddy a user ID produces
  */
 
-import { generateBones, renderBuddy, STAT_NAMES } from "../core/engine.ts";
-import { resolveUserId } from "../adapters/claude/storage/identity.ts";
+import { generateBones, renderBuddy, STAT_NAMES } from "../core/engine.ts"
+import { resolveUserId } from "../server/state.ts";
 
 const userId = process.argv[3] || resolveUserId();
 

package/core/achievements.ts

@@ -1,24 +1,6 @@
-import type { UnlockedAchievement } from "./model.ts";
+import type { UnlockedAchievement, GlobalCounters, SlotCounters, EventCounters } from "./model.ts";
+export type { GlobalCounters, SlotCounters, EventCounters };
 
-export interface GlobalCounters {
-  errors_seen: number;
-  tests_failed: number;
-  large_diffs: number;
-  sessions: number;
-  commands_run: number;
-  days_active: number;
-  turns: number;
-}
-
-export interface SlotCounters {
-  pets: number;
-  reactions_given: number;
-}
-
-export interface EventCounters extends GlobalCounters {
-  pets: number;
-  reactions_given: number;
-}
 
 export const GLOBAL_KEYS: (keyof GlobalCounters)[] = [
   "errors_seen", "tests_failed", "large_diffs",
@@ -189,12 +171,22 @@ export function getUnlockedAchievements(
 ): Achievement[] {
   const newlyUnlocked: Achievement[] = [];
   for (const ach of ACHIEVEMENTS) {
+    if (ach.id === "first_steps") continue;
     if (unlockedIds.has(ach.id)) continue;
     if (ach.check(events)) newlyUnlocked.push(ach);
   }
   return newlyUnlocked;
 }
 
+export function getCreationAchievements(
+  _events: EventCounters,
+  unlockedIds: Set<string>,
+): Achievement[] {
+  if (unlockedIds.has("first_steps")) return [];
+  const first = ACHIEVEMENTS.find((ach) => ach.id === "first_steps");
+  return first ? [first] : [];
+}
+
 export function isAchievementUnlocked(
   id: string,
   unlocked: UnlockedAchievement[],

package/core/art-data.ts

@@ -1,5 +1,7 @@
 import type { Species, Hat } from "./engine.ts";
 
+// ─── Species art: 3 frames × 5 lines each ──────────────────────────────────
+
 export const SPECIES_ART: Record<Species, string[][]> = {
   duck: [
     ["            ", "    __      ", "  <({E} )___  ", "   (  ._>   ", "    `--'    "],
@@ -91,8 +93,32 @@ export const SPECIES_ART: Record<Species, string[][]> = {
     ["            ", "  /\\    /|  ", " ( {E}    {E} ) ", " (   ..   ) ", "  `------'  "],
     ["            ", "  /\\    /\\  ", " ( {E}    {E} ) ", " (   ..   ) ", "  `------'~ "],
   ],
+  wyvern: [
+    ["}       {",
+     "|\\^```^/|",
+     "\\ {E}' '{E} /",
+     " ≈(° °)≈",
+     "   '-'"],
+    ["}       {",
+     "|\\^```^/|",
+     "\\ {E}' '{E} /",
+     " ≈(° °)≈",
+     "   '~'"],
+    ["}       {",
+     "|\\^```^/|",
+     "\\ {E}' '{E} /",
+     " ≈(° °)≈",
+     "   'v'"],
+  ],
+  pikachu: [
+    ["            ", "   /\\_/\\   ", "  ({E} {E})  ", "   (  ω )   ", "   (__)    "],
+    ["            ", "   /\\_/\\   ", "   (- -)   ", "   (  ω )   ", "   (__)    "],
+    ["            ", "   /\\_/\\   ", "  ({E} {E})  ", "   (  ~ )   ", "   (__)    "],
+  ],
 };
 
+// ─── Hat art ────────────────────────────────────────────────────────────────
+
 export const HAT_ART: Record<Hat, string> = {
   none:      "",
   crown:     "   \\^^^/    ",