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

package/adapters/pi/storage.ts

@@ -1,296 +1,25 @@
-import { randomUUID } from "node:crypto";
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  writeFileSync,
-} from "node:fs";
-import { homedir } from "node:os";
+import { getAgentDir } from "@mariozechner/pi-coding-agent";
 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,
-  turnCommentModel: undefined,
-  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;
-}
+  FileBuddyStorage,
+  slugifySlot,
+  type FileBuddyConfig,
+} from "../shared/file-storage.ts";
 
-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);
-  }
+export const DEFAULT_PI_BUDDY_STATE_DIR = join(getAgentDir(), "buddy");
 
-  listSlots(): Array<{ slot: string; companion: Companion }> {
-    return Object.entries(loadManifest().companions).map(([slot, companion]) => ({
-      slot,
-      companion,
-    }));
+export class PiBuddyStorage extends FileBuddyStorage {
+  constructor(stateDir = DEFAULT_PI_BUDDY_STATE_DIR) {
+    super(stateDir);
   }
 
-  loadActiveSlot(): string | null {
-    const manifest = loadManifest();
-    if (manifest.active && manifest.companions[manifest.active]) return manifest.active;
-    return Object.keys(manifest.companions)[0] ?? null;
+  loadPiConfig(): FileBuddyConfig {
+    return this.loadHostConfig();
   }
 
-  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;
+  savePiConfig(config: Partial<FileBuddyConfig>): FileBuddyConfig {
+    return this.saveHostConfig(config);
   }
 }
 
-export function slugifySlot(name: string): string {
-  return (
-    name
-      .toLowerCase()
-      .replace(/[^a-z0-9-]/g, "-")
-      .replace(/-+/g, "-")
-      .replace(/^-|-$/g, "")
-      .slice(0, 14) || "buddy"
-  );
-}
+export { slugifySlot };

package/adapters/pi/ui.ts

@@ -4,32 +4,71 @@ import type { Companion, ReactionState } from "../../core/model.ts";
 import { renderAchievementsSummary, renderBuddyStatus, renderBuddyWidget } from "./renderers.ts";
 import { PiBuddyStorage } from "./storage.ts";
 
+type PiBuddyUiContext = ExtensionContext & {
+  setTimeout?: (callback: () => void, ms?: number) => Timer;
+  clearTimer?: (timer: Timer) => void;
+};
+
 export class PiBuddyUI {
+  private readonly timers: Array<{ timer: Timer; clear: (timer: Timer) => void }> = [];
+
   constructor(private readonly storage: PiBuddyStorage) {}
 
+  cancelTimers(): void {
+    for (const { timer, clear } of this.timers.splice(0)) {
+      try {
+        clear(timer);
+      } catch {
+        // Ignore cleanup errors.
+      }
+    }
+  }
+
   refresh(
-    ctx: ExtensionContext,
+    ctx: PiBuddyUiContext,
     companion: Companion,
     reaction?: ReactionState | null,
     achievements: Achievement[] = [],
   ): void {
+    const currentReaction = reaction ?? null;
     const muted = this.storage.isMuted();
-    const status = renderBuddyStatus(companion, muted ? null : reaction);
+    const status = renderBuddyStatus(companion, muted ? null : currentReaction);
     ctx.ui.setStatus("buddy", muted ? `${status} [muted]` : status);
     ctx.ui.setWidget(
       "buddy",
-      renderBuddyWidget(companion, muted ? null : reaction, achievements),
+      renderBuddyWidget(companion, muted ? null : currentReaction, achievements),
     );
+
+    this.cancelTimers();
+    if (!currentReaction) return;
+
+    const ttl = this.storage.loadConfig().reactionTTL;
+    if (ttl <= 0) return;
+
+    const scheduler = getScheduler(ctx);
+    if (!scheduler) return;
+
+    const reactionTimestamp = currentReaction.timestamp;
+    const delay = Math.max(0, reactionTimestamp + ttl * 1000 + 1 - Date.now());
+    const timer = scheduler.setTimeout(() => {
+      const latest = this.storage.loadLatest();
+      if (latest && latest.timestamp >= reactionTimestamp) {
+        this.refresh(ctx, companion, latest, []);
+      } else {
+        this.refresh(ctx, companion, null, []);
+      }
+    }, delay);
+    this.timers.push({ timer, clear: scheduler.clearTimer });
   }
 
-  notifyAchievements(ctx: ExtensionContext, achievements: Achievement[]): void {
+  notifyAchievements(ctx: PiBuddyUiContext, achievements: Achievement[]): void {
     for (const achievement of achievements) {
       ctx.ui.notify(`Unlocked: ${achievement.icon} ${achievement.name}`, "info");
     }
   }
 
   showAchievements(
-    ctx: ExtensionContext,
+    ctx: PiBuddyUiContext,
     unlocked: Array<{ achievement: Achievement; unlockedAt: number; slot?: string }>,
     remaining: Achievement[],
   ): void {
@@ -37,3 +76,15 @@ export class PiBuddyUI {
     ctx.ui.notify(`Achievements: ${unlocked.length} unlocked`, "info");
   }
 }
+
+function getScheduler(
+  ctx: PiBuddyUiContext,
+): { setTimeout: (callback: () => void, ms?: number) => Timer; clearTimer: (timer: Timer) => void } | null {
+  if (typeof ctx.setTimeout === "function" && typeof ctx.clearTimer === "function") {
+    return { setTimeout: ctx.setTimeout, clearTimer: ctx.clearTimer };
+  }
+  if (typeof globalThis.setTimeout === "function" && typeof globalThis.clearTimeout === "function") {
+    return { setTimeout: globalThis.setTimeout, clearTimer: globalThis.clearTimeout };
+  }
+  return null;
+}