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

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"
-  );
 }

package/core/engine.ts

@@ -1,5 +1,5 @@
 /**
- * claude-buddy engine — deterministic companion generation
+ * coding-buddy engine — deterministic companion generation
  * Matches Claude Code's exact algorithm: wyhash → mulberry32 → species/stats
  */
 
@@ -24,6 +24,8 @@ export const SPECIES = [
   "rabbit",
   "mushroom",
   "chonk",
+  "wyvern",
+  "pikachu",
 ] as const;
 
 export type Species = (typeof SPECIES)[number];
@@ -296,6 +298,84 @@ export function generateBones(userId: string, salt: string = SALT): BuddyBones {
   return { rarity, species, eye, hat, shiny, stats, peak, dump };
 }
 
+// ─── Personality ────────────────────────────────────────────────────────────
+
+const PEAK_PHRASES: Record<StatName, string[]> = {
+  DEBUGGING: [
+    "spots segfaults before the stack unwinds",
+    "can read a backtrace like a map",
+    "finds the off-by-one before the tests do",
+  ],
+  PATIENCE: [
+    "outlasts any flaky test suite",
+    "waits for the slow CI build without complaint",
+    "never merges before the green check",
+  ],
+  CHAOS: [
+    "treats breaking changes as a love language",
+    "rewrites the Makefile on a Tuesday for fun",
+    "thrives wherever the incident channel is loudest",
+  ],
+  WISDOM: [
+    "has seen this bug before — in three other repos",
+    "quotes the relevant RFC from memory",
+    "recognizes the abstraction that will outlive its author",
+  ],
+  SNARK: [
+    "leaves code review comments that linger",
+    "finds the edge case you forgot and mentions it twice",
+    "names things with uncomfortable accuracy",
+  ],
+};
+
+const DUMP_PHRASES: Record<StatName, string[]> = {
+  DEBUGGING: [
+    "occasionally ships the workaround instead of the fix",
+    "skips the repro step",
+    "trusts the logs a little too much",
+  ],
+  PATIENCE: [
+    "starts the rebase before the review is done",
+    "has been known to close slow issues as stale",
+    "has been known to force-push main",
+  ],
+  CHAOS: [
+    "prefers everything to stay exactly where it is",
+    "dislikes surprise refactors",
+    "writes very thorough migration guides",
+  ],
+  WISDOM: [
+    "sometimes reinvents the wheel with enthusiasm",
+    "skips the existing prior art",
+    "learns by doing, not by reading",
+  ],
+  SNARK: [
+    "only leaves encouraging comments",
+    "approves PRs with genuine warmth",
+    "never says what it actually thinks",
+  ],
+};
+
+const RARITY_CLOSER: Record<string, string[]> = {
+  common:    ["Gets the job done.", "Reliable, if unassuming."],
+  uncommon:  ["Has a few tricks up its sleeve.", "Worth keeping around."],
+  rare:      ["Not to be underestimated.", "Earns its keep."],
+  epic:      ["Commands quiet respect.", "The kind of companion repos are built around."],
+  legendary: ["The kind you find once, if you're lucky.", "Leaves every codebase better than it found it."],
+};
+
+export function generatePersonality(bones: BuddyBones, userId: string): string {
+  const seed = parseInt(userId.slice(0, 8), 16);
+  const pickPhrase = <T>(arr: T[], salt: number = 0): T => arr[(seed + salt) % arr.length];
+
+  const shiny  = bones.shiny ? " Shimmers faintly in dark mode." : "";
+  const peak   = pickPhrase(PEAK_PHRASES[bones.peak]);
+  const dump   = pickPhrase(DUMP_PHRASES[bones.dump], 1);
+  const closer = pickPhrase(RARITY_CLOSER[bones.rarity] ?? ["Gets the job done."], 2);
+
+  return `A ${bones.rarity} ${bones.species} that ${peak}.${shiny} ${closer} Though it ${dump}.`;
+}
+
 // ─── ASCII Art ──────────────────────────────────────────────────────────────
 
 const FACE_TEMPLATES: Record<Species, string> = {
@@ -317,6 +397,8 @@ const FACE_TEMPLATES: Record<Species, string> = {
   rabbit: "({E}..{E})",
   mushroom: "|{E}  {E}|",
   chonk: "({E}.{E})",
+  wyvern: "\\ {E}' '{E} /",
+  pikachu: "({E}ω{E})",
 };
 
 export function renderFace(species: Species, eye: Eye): string {

package/core/ports.ts

@@ -5,6 +5,7 @@ import type {
   ReactionState,
   UnlockedAchievement,
 } from "./model.ts";
+import type { Achievement } from "./achievements.ts";
 
 export interface IdentityProvider {
   getStableUserId(): string;
@@ -13,12 +14,17 @@ export interface IdentityProvider {
 export interface BuddyRepository {
   loadActive(): Companion | null;
   saveActive(companion: Companion): void;
+  updateActive(transform: (companion: Companion) => Companion): Companion;
   loadSlot(slot: string): Companion | null;
   saveSlot(slot: string, companion: Companion): void;
   deleteSlot(slot: string): void;
   listSlots(): Array<{ slot: string; companion: Companion }>;
   loadActiveSlot(): string | null;
   saveActiveSlot(slot: string): void;
+  ensureCompanion(
+    userId: string,
+    create: (existingSlots: string[]) => { companion: Companion; slot: string },
+  ): { companion: Companion; slot: string; created: boolean };
 }
 
 export interface ReactionRepository {
@@ -37,4 +43,8 @@ export interface BuddyEventRepository {
   loadUnlocked(): UnlockedAchievement[];
   saveUnlocked(unlocked: UnlockedAchievement[]): void;
   trackActiveDay(): void;
+  unlockAchievements(
+    slot: string | undefined,
+    evaluate: (counters: EventCounters, unlockedIds: Set<string>) => Achievement[],
+  ): Achievement[];
 }