@ramarivera/coding-buddy 0.4.0-alpha.9 → 0.7.0

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:     "   \\^^^/    ",

package/core/command-service.ts

@@ -1,10 +1,19 @@
+export 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()];
+}
+
 import {
   generateBones,
   RARITY_STARS,
   type Companion,
 } from "./engine.ts";
-import { getUnlockedAchievements, type Achievement } from "./achievements.ts";
+import { ACHIEVEMENTS, getCreationAchievements, getUnlockedAchievements, type Achievement } from "./achievements.ts";
 import { generateFallbackName, getReaction } from "./reactions.ts";
+import { slugifySlot } from "./slot-slug.ts";
 import type {
   BuddyConfig,
   ReactionState,
@@ -86,40 +95,27 @@ export class BuddyCommandService {
   }
 
   ensureCompanion(): EnsureCompanionResult {
-    const active = this.deps.buddies.loadActive();
-    if (active) {
-      return {
-        companion: active,
-        slot: this.getActiveSlot(),
-        created: false,
-        achievements: [],
-      };
-    }
-
-    const saved = this.deps.buddies.listSlots();
-    if (saved.length > 0) {
-      const rescued = saved[0];
-      this.deps.buddies.saveActiveSlot(rescued.slot);
-      return {
-        companion: rescued.companion,
-        slot: rescued.slot,
-        created: false,
-        achievements: [],
-      };
-    }
-
     const userId = this.getStableUserId();
-    const companion = this.createCompanion(userId);
-    const slot = slugify(companion.name);
-    this.deps.buddies.saveSlot(slot, companion);
-    this.deps.buddies.saveActiveSlot(slot);
+    const { companion, slot, created } = this.deps.buddies.ensureCompanion(
+      userId,
+      (existingSlots) => this.createCompanion(userId, existingSlots),
+    );
+    const achievements = created
+      ? this.deps.events.unlockAchievements(slot, getCreationAchievements)
+      : [];
+    return { companion, slot, created, achievements };
+  }
+
+  startSession(): EnsureCompanionResult {
+    const result = this.ensureCompanion();
     this.deps.events.trackActiveDay();
     this.deps.events.increment("sessions", 1);
-    const achievements = this.unlockAchievements(slot);
+    const sessionAchievements = this.unlockNewAchievements(result.slot);
 
-    return { companion, slot, created: true, achievements };
+    return { ...result, achievements: mergeAchievements(result.achievements, sessionAchievements) };
   }
 
+
   petBuddy(scope?: string): ReactionResult {
     const { companion, slot } = this.ensureCompanion();
     this.deps.events.increment("pets", 1, slot);
@@ -129,31 +125,45 @@ export class BuddyCommandService {
   renameBuddy(name: string): Companion {
     const trimmed = name.trim();
     if (!trimmed) throw new Error("Buddy name cannot be empty.");
-    const { companion } = this.ensureCompanion();
-    const updated: Companion = { ...companion, name: trimmed.slice(0, 14) };
-    this.deps.buddies.saveActive(updated);
-    return updated;
+    this.ensureCompanion();
+    return this.deps.buddies.updateActive((companion) => ({
+      ...companion,
+      name: trimmed.slice(0, 14),
+    }));
   }
 
   setPersonality(personality: string): Companion {
     const trimmed = personality.trim();
     if (!trimmed) throw new Error("Buddy personality cannot be empty.");
-    const { companion } = this.ensureCompanion();
-    const updated: Companion = { ...companion, personality: trimmed };
-    this.deps.buddies.saveActive(updated);
-    return updated;
+    this.ensureCompanion();
+    return this.deps.buddies.updateActive((companion) => ({
+      ...companion,
+      personality: trimmed,
+    }));
   }
 
   saveBuddy(slot?: string): SaveBuddyResult {
-    const { companion } = this.ensureCompanion();
-    const targetSlot = slugify(slot?.trim() || companion.name);
-    this.deps.buddies.saveSlot(targetSlot, companion);
-    this.deps.buddies.saveActiveSlot(targetSlot);
-    return { companion, slot: targetSlot };
+    const { companion, slot: activeSlot } = this.ensureCompanion();
+    if (slot?.trim()) {
+      const targetSlot = slugifySlot(slot.trim());
+      if (targetSlot !== activeSlot && this.deps.buddies.loadSlot(targetSlot)) {
+        throw new Error(`Slot "${targetSlot}" already exists.`);
+      }
+      if (targetSlot === activeSlot) {
+        this.deps.buddies.saveActive(companion);
+      } else {
+        this.deps.buddies.saveSlot(targetSlot, companion);
+      }
+      this.deps.buddies.saveActiveSlot(targetSlot);
+      return { companion, slot: targetSlot };
+    }
+
+    this.deps.buddies.saveActive(companion);
+    return { companion, slot: activeSlot };
   }
 
   summonBuddy(slot?: string): SummonBuddyResult | null {
-    const targetSlot = slot ? slugify(slot) : undefined;
+    const targetSlot = slot ? slugifySlot(slot) : undefined;
 
     if (!targetSlot) {
       const companions = this.deps.buddies.listSlots();
@@ -171,7 +181,7 @@ export class BuddyCommandService {
   }
 
   dismissBuddy(slot: string): SaveBuddyResult {
-    const targetSlot = slugify(slot);
+    const targetSlot = slugifySlot(slot);
     const activeSlot = this.getActiveSlot();
     if (targetSlot === activeSlot) {
       throw new Error("Cannot dismiss the active buddy.");
@@ -208,6 +218,23 @@ export class BuddyCommandService {
     this.deps.events.increment("large_diffs", 1);
     return this.saveReaction("large-diff", companion, slot, scope, { lines });
   }
+  trackToolError(scope?: string, line?: number): Achievement[] {
+    const { slot } = this.ensureCompanion();
+    this.deps.events.increment("errors_seen", 1, slot);
+    return this.unlockNewAchievements(slot);
+  }
+
+  trackTestFailure(scope?: string, count?: number): Achievement[] {
+    const { slot } = this.ensureCompanion();
+    this.deps.events.increment("tests_failed", 1, slot);
+    return this.unlockNewAchievements(slot);
+  }
+
+  trackLargeDiff(lines: number, scope?: string): Achievement[] {
+    const { slot } = this.ensureCompanion();
+    this.deps.events.increment("large_diffs", 1, slot);
+    return this.unlockNewAchievements(slot);
+  }
 
   recordTurn(scope?: string): ReactionResult {
     const { companion, slot } = this.ensureCompanion();
@@ -218,7 +245,7 @@ export class BuddyCommandService {
   recordTurnOnly(): ProgressResult {
     const { companion, slot } = this.ensureCompanion();
     this.deps.events.increment("turns", 1);
-    const achievements = this.unlockAchievements(slot);
+    const achievements = this.unlockNewAchievements(slot);
     return { companion, slot, achievements };
   }
 
@@ -232,10 +259,10 @@ export class BuddyCommandService {
     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());
+    const slot = this.getActiveSlotOrUndefined();
+    this.deps.events.increment("commands_run", 1, slot);
+    return this.unlockNewAchievements(slot);
   }
 
   getAchievementProgress(slot?: string): {
@@ -245,15 +272,10 @@ export class BuddyCommandService {
     const unlocked = this.deps.events.loadUnlocked();
     const unlockedMap = new Map(unlocked.map((entry) => [entry.id, entry]));
 
-    const unlockedAchievements = getUnlockedAchievements(
-      this.deps.events.loadCounters(slot),
-      new Set<string>(),
-    ).filter((achievement) => unlockedMap.has(achievement.id));
-
-    const remaining = getUnlockedAchievements(
-      this.deps.events.loadCounters(slot),
-      new Set(unlocked.map((entry) => entry.id)),
+    const unlockedAchievements = ACHIEVEMENTS.filter((achievement) =>
+      unlockedMap.has(achievement.id)
     );
+    const remaining = ACHIEVEMENTS.filter((achievement) => !unlockedMap.has(achievement.id));
 
     return {
       unlocked: unlockedAchievements.map((achievement) => ({
@@ -279,23 +301,30 @@ export class BuddyCommandService {
     return slot || undefined;
   }
 
-  private createCompanion(userId: string): Companion {
+  private createCompanion(
+    userId: string,
+    existingSlots: string[],
+  ): { companion: Companion; slot: string } {
     const bones = generateBones(userId);
-    const name = this.generateUnusedName();
+    const name = this.generateUnusedName(existingSlots);
+    const slot = slugifySlot(name);
     return {
-      bones,
-      name,
-      personality: `A ${bones.rarity} ${bones.species} who watches code with quiet intensity.`,
-      hatchedAt: Date.now(),
-      userId,
+      companion: {
+        bones,
+        name,
+        personality: `A ${bones.rarity} ${bones.species} who watches code with quiet intensity.`,
+        hatchedAt: Date.now(),
+        userId,
+      },
+      slot,
     };
   }
 
-  private generateUnusedName(): string {
-    const taken = new Set(this.deps.buddies.listSlots().map(({ slot }) => slot));
+  private generateUnusedName(existingSlots: string[]): string {
+    const taken = new Set(existingSlots);
     for (let i = 0; i < 50; i++) {
       const candidate = generateFallbackName();
-      if (!taken.has(slugify(candidate))) return candidate;
+      if (!taken.has(slugifySlot(candidate))) return candidate;
     }
 
     let suffix = 0;
@@ -314,6 +343,7 @@ export class BuddyCommandService {
       reason,
       companion.bones.species,
       companion.bones.rarity,
+      companion.bones.stats,
       context,
     );
     return this.saveCustomReaction(reaction, reason, companion, slot, scope);
@@ -333,40 +363,12 @@ export class BuddyCommandService {
     };
     this.deps.reactions.saveLatest(state, scope);
     this.deps.events.increment("reactions_given", 1, slot);
-    const achievements = this.unlockAchievements(slot);
+    const achievements = this.unlockNewAchievements(slot);
     return { companion, slot, reaction, state, achievements };
   }
 
-  private unlockAchievements(slot?: string): Achievement[] {
-    const unlocked = this.deps.events.loadUnlocked();
-    const unlockedIds = new Set(unlocked.map((entry) => entry.id));
-    const newlyUnlocked = getUnlockedAchievements(
-      this.deps.events.loadCounters(slot),
-      unlockedIds,
-    );
-
-    if (newlyUnlocked.length === 0) return [];
-
-    this.deps.events.saveUnlocked([
-      ...unlocked,
-      ...newlyUnlocked.map((achievement) => ({
-        id: achievement.id,
-        unlockedAt: Date.now(),
-        slot,
-      })),
-    ]);
-
-    return newlyUnlocked;
+  private unlockNewAchievements(slot?: string): Achievement[] {
+    return this.deps.events.unlockAchievements(slot, getUnlockedAchievements);
   }
-}
 
-function slugify(name: string): string {
-  return (
-    name
-      .toLowerCase()
-      .replace(/[^a-z0-9-]/g, "-")
-      .replace(/-+/g, "-")
-      .replace(/^-|-$/g, "")
-      .slice(0, 14) || "buddy"
-  );
 }