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

package/adapters/pi/storage.ts

@@ -0,0 +1,295 @@
+import { randomUUID } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  EMPTY_GLOBAL,
+  EMPTY_SLOT,
+  GLOBAL_KEYS,
+  SLOT_KEYS,
+  type GlobalCounters,
+  type SlotCounters,
+} from "../../core/achievements.ts";
+import type {
+  BuddyConfig,
+  Companion,
+  EventCounters,
+  ReactionState,
+  UnlockedAchievement,
+} from "../../core/model.ts";
+import type {
+  BuddyConfigRepository,
+  BuddyEventRepository,
+  BuddyRepository,
+  ReactionRepository,
+} from "../../core/ports.ts";
+
+const STATE_DIR = join(homedir(), ".pi", "agent", "buddy");
+const MENAGERIE_FILE = join(STATE_DIR, "menagerie.json");
+const CONFIG_FILE = join(STATE_DIR, "config.json");
+const REACTION_FILE = join(STATE_DIR, "reaction.json");
+const EVENTS_FILE = join(STATE_DIR, "events.json");
+const UNLOCKED_FILE = join(STATE_DIR, "unlocked.json");
+const ACTIVE_DAYS_FILE = join(STATE_DIR, "active_days.json");
+const IDENTITY_FILE = join(STATE_DIR, "identity.json");
+
+interface PiBuddyConfig extends BuddyConfig {
+  muted: boolean;
+}
+
+interface MenagerieManifest {
+  active: string;
+  companions: Record<string, Companion>;
+}
+
+interface ActiveDayState {
+  lastDate: string;
+  totalDays: number;
+}
+
+const DEFAULT_CONFIG: PiBuddyConfig = {
+  commentCooldown: 30,
+  reactionTTL: 0,
+  bubbleStyle: "classic",
+  bubblePosition: "top",
+  showRarity: true,
+  statusLineEnabled: true,
+  muted: false,
+};
+
+function ensureDir(): void {
+  if (!existsSync(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true });
+}
+
+function atomicWrite(path: string, value: string): void {
+  ensureDir();
+  const tmp = `${path}.tmp`;
+  writeFileSync(tmp, value, "utf8");
+  renameSync(tmp, path);
+}
+
+function readJson<T>(path: string, fallback: T): T {
+  try {
+    return { ...fallback, ...JSON.parse(readFileSync(path, "utf8")) };
+  } catch {
+    return fallback;
+  }
+}
+
+function loadManifest(): MenagerieManifest {
+  const manifest = readJson<MenagerieManifest>(MENAGERIE_FILE, {
+    active: "buddy",
+    companions: {},
+  });
+  if (!manifest.companions) manifest.companions = {};
+  if (!manifest.active) manifest.active = Object.keys(manifest.companions)[0] ?? "buddy";
+  return manifest;
+}
+
+function saveManifest(manifest: MenagerieManifest): void {
+  atomicWrite(MENAGERIE_FILE, JSON.stringify(manifest, null, 2));
+}
+
+function slotEventsFile(slot: string): string {
+  return join(STATE_DIR, `events.${slot}.json`);
+}
+
+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 class PiBuddyStorage
+  implements
+    BuddyRepository,
+    ReactionRepository,
+    BuddyConfigRepository,
+    BuddyEventRepository
+{
+  readonly stateDir = STATE_DIR;
+
+  loadActive(): Companion | null {
+    const manifest = loadManifest();
+    return manifest.companions[manifest.active] ?? null;
+  }
+
+  saveActive(companion: Companion): void {
+    const manifest = loadManifest();
+    manifest.companions[manifest.active] = companion;
+    saveManifest(manifest);
+  }
+
+  loadSlot(slot: string): Companion | null {
+    return loadManifest().companions[slot] ?? null;
+  }
+
+  saveSlot(slot: string, companion: Companion): void {
+    const manifest = loadManifest();
+    if (manifest.companions[slot]) {
+      throw new Error(`Slot \"${slot}\" already exists.`);
+    }
+    manifest.companions[slot] = companion;
+    saveManifest(manifest);
+  }
+
+  deleteSlot(slot: string): void {
+    const manifest = loadManifest();
+    delete manifest.companions[slot];
+    if (manifest.active === slot) {
+      manifest.active = Object.keys(manifest.companions)[0] ?? "buddy";
+    }
+    saveManifest(manifest);
+  }
+
+  listSlots(): Array<{ slot: string; companion: Companion }> {
+    return Object.entries(loadManifest().companions).map(([slot, companion]) => ({
+      slot,
+      companion,
+    }));
+  }
+
+  loadActiveSlot(): string | null {
+    const manifest = loadManifest();
+    if (manifest.active && manifest.companions[manifest.active]) return manifest.active;
+    return Object.keys(manifest.companions)[0] ?? null;
+  }
+
+  saveActiveSlot(slot: string): void {
+    const manifest = loadManifest();
+    manifest.active = slot;
+    saveManifest(manifest);
+  }
+
+  loadLatest(): ReactionState | null {
+    try {
+      const reaction = JSON.parse(readFileSync(REACTION_FILE, "utf8")) as ReactionState;
+      const ttl = this.loadPiConfig().reactionTTL;
+      if (ttl > 0 && Date.now() - reaction.timestamp > ttl * 1000) return null;
+      return reaction;
+    } catch {
+      return null;
+    }
+  }
+
+  saveLatest(reaction: ReactionState): void {
+    atomicWrite(REACTION_FILE, JSON.stringify(reaction, null, 2));
+  }
+
+  clearLatestReaction(): void {
+    atomicWrite(
+      REACTION_FILE,
+      JSON.stringify({ reaction: "", reason: "clear", timestamp: Date.now() }, null, 2),
+    );
+  }
+
+  loadConfig(): BuddyConfig {
+    return this.loadPiConfig();
+  }
+
+  saveConfig(config: Partial<BuddyConfig>): BuddyConfig {
+    return this.savePiConfig(config);
+  }
+
+  loadPiConfig(): PiBuddyConfig {
+    return readJson<PiBuddyConfig>(CONFIG_FILE, DEFAULT_CONFIG);
+  }
+
+  savePiConfig(config: Partial<PiBuddyConfig>): PiBuddyConfig {
+    const merged = { ...this.loadPiConfig(), ...config };
+    atomicWrite(CONFIG_FILE, JSON.stringify(merged, null, 2));
+    return merged;
+  }
+
+  isMuted(): boolean {
+    return this.loadPiConfig().muted;
+  }
+
+  setMuted(muted: boolean): PiBuddyConfig {
+    return this.savePiConfig({ muted });
+  }
+
+  loadCounters(slot?: string): EventCounters {
+    const global = readJson<GlobalCounters>(EVENTS_FILE, EMPTY_GLOBAL);
+    if (!slot) {
+      return { ...global, ...EMPTY_SLOT };
+    }
+    const slotCounters = readJson<SlotCounters>(slotEventsFile(slot), EMPTY_SLOT);
+    return { ...global, ...slotCounters };
+  }
+
+  increment(key: keyof EventCounters, amount: number = 1, slot?: string): EventCounters {
+    if (isSlotKey(key) && slot) {
+      const slotCounters = readJson<SlotCounters>(slotEventsFile(slot), EMPTY_SLOT);
+      slotCounters[key] += amount;
+      atomicWrite(slotEventsFile(slot), JSON.stringify(slotCounters, null, 2));
+    } else if (isGlobalKey(key)) {
+      const global = readJson<GlobalCounters>(EVENTS_FILE, EMPTY_GLOBAL);
+      global[key] += amount;
+      atomicWrite(EVENTS_FILE, JSON.stringify(global, null, 2));
+    }
+
+    return this.loadCounters(slot);
+  }
+
+  loadUnlocked(): UnlockedAchievement[] {
+    try {
+      return JSON.parse(readFileSync(UNLOCKED_FILE, "utf8")) as UnlockedAchievement[];
+    } catch {
+      return [];
+    }
+  }
+
+  saveUnlocked(unlocked: UnlockedAchievement[]): void {
+    atomicWrite(UNLOCKED_FILE, JSON.stringify(unlocked, null, 2));
+  }
+
+  trackActiveDay(): void {
+    const today = new Date().toISOString().slice(0, 10);
+    const current = readJson<ActiveDayState>(ACTIVE_DAYS_FILE, {
+      lastDate: "",
+      totalDays: 0,
+    });
+    if (current.lastDate === today) return;
+
+    const next = { lastDate: today, totalDays: current.totalDays + 1 };
+    atomicWrite(ACTIVE_DAYS_FILE, JSON.stringify(next, null, 2));
+
+    const global = readJson<GlobalCounters>(EVENTS_FILE, EMPTY_GLOBAL);
+    global.days_active = next.totalDays;
+    atomicWrite(EVENTS_FILE, JSON.stringify(global, null, 2));
+  }
+
+  ensureStableIdentity(): string {
+    ensureDir();
+    try {
+      const parsed = JSON.parse(readFileSync(IDENTITY_FILE, "utf8")) as { userId?: string };
+      if (parsed.userId) return parsed.userId;
+    } catch {
+      // ignore and create below
+    }
+
+    const userId = randomUUID();
+    atomicWrite(IDENTITY_FILE, JSON.stringify({ userId }, null, 2));
+    return userId;
+  }
+}
+
+export function slugifySlot(name: string): string {
+  return (
+    name
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, "-")
+      .replace(/-+/g, "-")
+      .replace(/^-|-$/g, "")
+      .slice(0, 14) || "buddy"
+  );
+}

package/adapters/pi/tools.ts

@@ -0,0 +1,6 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+export function registerBuddyTools(_pi: ExtensionAPI): void {
+  // Intentionally empty for the Phase 2 MVP.
+  // Pi gets its native buddy experience through commands, events, and UI first.
+}

package/adapters/pi/ui.ts

@@ -0,0 +1,39 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { Achievement } from "../../core/achievements.ts";
+import type { Companion, ReactionState } from "../../core/model.ts";
+import { renderAchievementsSummary, renderBuddyStatus, renderBuddyWidget } from "./renderers.ts";
+import { PiBuddyStorage } from "./storage.ts";
+
+export class PiBuddyUI {
+  constructor(private readonly storage: PiBuddyStorage) {}
+
+  refresh(
+    ctx: ExtensionContext,
+    companion: Companion,
+    reaction?: ReactionState | null,
+    achievements: Achievement[] = [],
+  ): void {
+    const muted = this.storage.isMuted();
+    const status = renderBuddyStatus(companion, muted ? null : reaction);
+    ctx.ui.setStatus("buddy", muted ? `${status} [muted]` : status);
+    ctx.ui.setWidget(
+      "buddy",
+      renderBuddyWidget(companion, muted ? null : reaction, achievements),
+    );
+  }
+
+  notifyAchievements(ctx: ExtensionContext, achievements: Achievement[]): void {
+    for (const achievement of achievements) {
+      ctx.ui.notify(`Unlocked: ${achievement.icon} ${achievement.name}`, "info");
+    }
+  }
+
+  showAchievements(
+    ctx: ExtensionContext,
+    unlocked: Array<{ achievement: Achievement; unlockedAt: number; slot?: string }>,
+    remaining: Achievement[],
+  ): void {
+    ctx.ui.setWidget("buddy", renderAchievementsSummary(unlocked, remaining));
+    ctx.ui.notify(`Achievements: ${unlocked.length} unlocked`, "info");
+  }
+}

package/cli/index.ts

@@ -17,40 +17,40 @@ const command = args[0] || "install";
 
 switch (command) {
   case "install":
-    await import("./install.ts");
+    await import("../adapters/claude/install/install.ts");
     break;
   case "show":
-    await import("./show.ts");
+    await import("../adapters/claude/install/show.ts");
     break;
   case "pick":
-    await import("./pick.ts");
+    await import("../adapters/claude/install/pick.ts");
     break;
   case "hunt":
-    await import("./hunt.ts");
+    await import("../adapters/claude/install/hunt.ts");
     break;
   case "uninstall":
-    await import("./uninstall.ts");
+    await import("../adapters/claude/install/uninstall.ts");
     break;
   case "verify":
     await import("./verify.ts");
     break;
   case "doctor":
-    await import("./doctor.ts");
+    await import("../adapters/claude/install/doctor.ts");
     break;
   case "test-statusline":
-    await import("./test-statusline.ts");
+    await import("../adapters/claude/install/test-statusline.ts");
     break;
   case "backup":
-    await import("./backup.ts");
+    await import("../adapters/claude/install/backup.ts");
     break;
   case "settings":
-    await import("./settings.ts");
+    await import("../adapters/claude/install/settings.ts");
     break;
   case "disable":
-    await import("./disable.ts");
+    await import("../adapters/claude/install/disable.ts");
     break;
   case "enable":
-    await import("./install.ts");
+    await import("../adapters/claude/install/install.ts");
     break;
   case "help":
   case "--help":

package/cli/verify.ts

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

package/core/achievements.ts

@@ -0,0 +1,203 @@
+import type { UnlockedAchievement } from "./model.ts";
+
+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",
+  "sessions", "commands_run", "days_active", "turns",
+];
+
+export const SLOT_KEYS: (keyof SlotCounters)[] = [
+  "pets", "reactions_given",
+];
+
+export const COUNTER_KEYS: (keyof EventCounters)[] = [
+  "errors_seen", "tests_failed", "large_diffs", "turns", "pets",
+  "sessions", "reactions_given", "commands_run", "days_active",
+];
+
+export const EMPTY_GLOBAL: GlobalCounters = {
+  errors_seen: 0, tests_failed: 0, large_diffs: 0,
+  sessions: 0, commands_run: 0, days_active: 0, turns: 0,
+};
+
+export const EMPTY_SLOT: SlotCounters = {
+  pets: 0, reactions_given: 0,
+};
+
+export interface Achievement {
+  id: string;
+  name: string;
+  description: string;
+  icon: string;
+  check: (events: EventCounters) => boolean;
+  secret: boolean;
+}
+
+export const ACHIEVEMENTS: Achievement[] = [
+  {
+    id: "first_steps",
+    name: "First Steps",
+    description: "Hatch your buddy for the first time",
+    icon: "🌟",
+    check: () => true,
+    secret: false,
+  },
+  {
+    id: "good_boy",
+    name: "Good Buddy",
+    description: "Pet your companion 10 times",
+    icon: "🧹",
+    check: (e) => e.pets >= 10,
+    secret: false,
+  },
+  {
+    id: "best_friend",
+    name: "Best Friend",
+    description: "Pet your companion 50 times",
+    icon: "❤️",
+    check: (e) => e.pets >= 50,
+    secret: false,
+  },
+  {
+    id: "bug_spotter",
+    name: "Bug Spotter",
+    description: "Witness your first error together",
+    icon: "🐛",
+    check: (e) => e.errors_seen >= 1,
+    secret: false,
+  },
+  {
+    id: "error_whisperer",
+    name: "Error Whisperer",
+    description: "Survive 25 errors as a team",
+    icon: "🔧",
+    check: (e) => e.errors_seen >= 25,
+    secret: false,
+  },
+  {
+    id: "battle_scarred",
+    name: "Battle-Scarred",
+    description: "Survive 100 errors together",
+    icon: "💀",
+    check: (e) => e.errors_seen >= 100,
+    secret: true,
+  },
+  {
+    id: "test_witness",
+    name: "Test Witness",
+    description: "See your first test failure",
+    icon: "❌",
+    check: (e) => e.tests_failed >= 1,
+    secret: false,
+  },
+  {
+    id: "test_veteran",
+    name: "Test Veteran",
+    description: "Witness 50 test failures",
+    icon: "📊",
+    check: (e) => e.tests_failed >= 50,
+    secret: false,
+  },
+  {
+    id: "big_mover",
+    name: "Big Mover",
+    description: "Make a diff with 80+ lines",
+    icon: "📦",
+    check: (e) => e.large_diffs >= 1,
+    secret: false,
+  },
+  {
+    id: "refactor_machine",
+    name: "Refactor Machine",
+    description: "Make 10 large diffs",
+    icon: "🔨",
+    check: (e) => e.large_diffs >= 10,
+    secret: false,
+  },
+  {
+    id: "chatterbox",
+    name: "Chatterbox",
+    description: "Your buddy reacts 100 times",
+    icon: "💬",
+    check: (e) => e.reactions_given >= 100,
+    secret: false,
+  },
+  {
+    id: "week_streak",
+    name: "Week Streak",
+    description: "Code with your buddy for 7 days",
+    icon: "🔥",
+    check: (e) => e.days_active >= 7,
+    secret: false,
+  },
+  {
+    id: "month_streak",
+    name: "Month Streak",
+    description: "Code with your buddy for 30 days",
+    icon: "👑",
+    check: (e) => e.days_active >= 30,
+    secret: true,
+  },
+  {
+    id: "power_user",
+    name: "Power User",
+    description: "Run 50 buddy commands",
+    icon: "⚡",
+    check: (e) => e.commands_run >= 50,
+    secret: false,
+  },
+  {
+    id: "dedicated",
+    name: "Dedicated Companion",
+    description: "Complete 200 turns together",
+    icon: "🏅",
+    check: (e) => e.turns >= 200,
+    secret: false,
+  },
+  {
+    id: "thousand_turns",
+    name: "Thousand Turns",
+    description: "Reach 1000 turns together",
+    icon: "🎖",
+    check: (e) => e.turns >= 1000,
+    secret: true,
+  },
+];
+
+export function getUnlockedAchievements(
+  events: EventCounters,
+  unlockedIds: Set<string>,
+): Achievement[] {
+  const newlyUnlocked: Achievement[] = [];
+  for (const ach of ACHIEVEMENTS) {
+    if (unlockedIds.has(ach.id)) continue;
+    if (ach.check(events)) newlyUnlocked.push(ach);
+  }
+  return newlyUnlocked;
+}
+
+export function isAchievementUnlocked(
+  id: string,
+  unlocked: UnlockedAchievement[],
+): boolean {
+  return unlocked.some((a) => a.id === id);
+}