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

package/adapters/omp/prompt.ts

@@ -0,0 +1,60 @@
+import type { Companion } from "../../core/model.ts";
+
+export function buildBuddyReactionSystemPrompt(companion: Companion): string {
+  return [
+    `A small ${companion.bones.rarity} ${companion.bones.species} named ${companion.name} watches from the status line. You are not ${companion.name} — it is a separate creature.`,
+    `Personality: ${companion.personality}`,
+    `Peak stat: ${companion.bones.peak} (${companion.bones.stats[companion.bones.peak]}). Dump stat: ${companion.bones.dump} (${companion.bones.stats[companion.bones.dump]}).`,
+    "",
+    `Write as ${companion.name} (a ${companion.bones.species}), not as the assistant.`,
+    "Reference something SPECIFIC from this turn — a pitfall, compliment, warning, pattern, file, test, or edge case.",
+    "Return exactly one short sentence, max 150 chars.",
+    "Use *asterisks* for physical actions when useful.",
+    "Do not explain yourself. Do not use markdown fences. Output only the buddy reaction line.",
+  ].join("\n");
+}
+
+export function buildBuddyReactionPrompt(
+  companion: Companion,
+  assistantText: string,
+  toolText: string,
+  userText: string,
+): string {
+  return [
+    `You are generating a single end-of-turn buddy reaction for ${companion.name}, a ${companion.bones.rarity} ${companion.bones.species}.`,
+    `Buddy personality: ${companion.personality}`,
+    `Peak stat: ${companion.bones.peak} (${companion.bones.stats[companion.bones.peak]}). Dump stat: ${companion.bones.dump} (${companion.bones.stats[companion.bones.dump]}).`,
+    "",
+    "Write exactly one short in-character reaction sentence as the buddy.",
+    "Rules:",
+    `- Write as ${companion.name}, not as the assistant.`,
+    "- Reference something specific from the turn.",
+    "- Max 150 characters.",
+    "- Use *asterisks* for physical actions when useful.",
+    "- Output only the reaction line, with no quotes, labels, markdown fences, or explanation.",
+    "",
+    "User prompt:",
+    userText || "(unknown)",
+    "",
+    "Assistant response:",
+    assistantText || "(empty)",
+    "",
+    "Tool result summary:",
+    toolText || "(none)",
+  ].join("\n");
+}
+
+export function stripBuddyComments(text: string): string {
+  return text.replace(/<!--\s*buddy:\s*[\s\S]*?-->/gi, "").trimEnd();
+}
+
+export function normalizeBuddyComment(text: string): string {
+  return text
+    .replace(/<!--\s*buddy:\s*([\s\S]*?)\s*-->/gi, "$1")
+    .replace(/^buddy\s*:\s*/i, "")
+    .replace(/^['"`]+|['"`]+$/g, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 150)
+    .trim();
+}

package/adapters/omp/renderers.ts

@@ -0,0 +1,73 @@
+import { RARITY_STARS } from "../../core/engine.ts";
+import { getArtFrame, HAT_ART } from "../../core/render-model.ts";
+import type { Companion, ReactionState } from "../../core/model.ts";
+import type { Achievement } from "../../core/achievements.ts";
+
+function trimArt(line: string): string {
+  return line.replace(/\s+$/g, "");
+}
+
+export function renderBuddyStatus(companion: Companion, reaction?: ReactionState | null): string {
+  const shiny = companion.bones.shiny ? " ✨" : "";
+  const stars = RARITY_STARS[companion.bones.rarity];
+  const suffix = reaction?.reaction ? ` — ${reaction.reaction}` : "";
+  return `${trimArt(getArtFrame(companion.bones.species, companion.bones.eye, Date.now())[0])} ${companion.name} ${stars}${shiny}${suffix}`;
+}
+
+export function renderBuddyWidget(
+  companion: Companion,
+  reaction?: ReactionState | null,
+  achievements: Achievement[] = [],
+): string[] {
+  const frame = Math.floor(Date.now() / 700);
+  const art = getArtFrame(companion.bones.species, companion.bones.eye, frame).map(trimArt);
+  const hat = companion.bones.hat === "none" ? [] : [trimArt(HAT_ART[companion.bones.hat])];
+  const stars = RARITY_STARS[companion.bones.rarity];
+  const shiny = companion.bones.shiny ? " ✨" : "";
+  const lines = [
+    `buddy · ${companion.name}`,
+    `${companion.bones.rarity} ${companion.bones.species} ${stars}${shiny}`,
+    "",
+    ...hat,
+    ...art,
+  ];
+
+  if (reaction?.reaction) {
+    lines.push("", `“${reaction.reaction}”`);
+  }
+
+  if (achievements.length > 0) {
+    lines.push("", ...achievements.map((achievement) => `🏆 ${achievement.name}`));
+  }
+
+  return lines;
+}
+
+export function renderBuddyStats(companion: Companion): string[] {
+  return [
+    `name: ${companion.name}`,
+    `species: ${companion.bones.species}`,
+    `rarity: ${companion.bones.rarity}`,
+    `peak: ${companion.bones.peak}`,
+    `dump: ${companion.bones.dump}`,
+    "",
+    ...Object.entries(companion.bones.stats).map(([stat, value]) => `${stat.padEnd(9)} ${String(value).padStart(3)}`),
+  ];
+}
+
+export function renderAchievementsSummary(
+  unlocked: Array<{ achievement: Achievement; unlockedAt: number; slot?: string }>,
+  remaining: Achievement[],
+): string[] {
+  const lines = [`achievements unlocked: ${unlocked.length}`];
+
+  if (unlocked.length > 0) {
+    lines.push("", ...unlocked.map(({ achievement }) => `${achievement.icon} ${achievement.name}`));
+  }
+
+  if (remaining.length > 0) {
+    lines.push("", `next up: ${remaining[0].icon} ${remaining[0].name}`);
+  }
+
+  return lines;
+}

package/adapters/omp/storage.ts

@@ -0,0 +1,25 @@
+import { getAgentDir } from "@oh-my-pi/pi-utils";
+import { join } from "node:path";
+import {
+  FileBuddyStorage,
+  slugifySlot,
+  type FileBuddyConfig,
+} from "../shared/file-storage.ts";
+
+export const DEFAULT_OMP_BUDDY_STATE_DIR = join(getAgentDir(), "buddy");
+
+export class OmpBuddyStorage extends FileBuddyStorage {
+  constructor(stateDir = DEFAULT_OMP_BUDDY_STATE_DIR) {
+    super(stateDir);
+  }
+
+  loadOmpConfig(): FileBuddyConfig {
+    return this.loadHostConfig();
+  }
+
+  saveOmpConfig(config: Partial<FileBuddyConfig>): FileBuddyConfig {
+    return this.saveHostConfig(config);
+  }
+}
+
+export { slugifySlot };

package/adapters/omp/ui.ts

@@ -0,0 +1,85 @@
+import type { OmpBuddyUiContext } from "./context.ts";
+import type { Achievement } from "../../core/achievements.ts";
+import type { Companion, ReactionState } from "../../core/model.ts";
+import { renderAchievementsSummary, renderBuddyStatus, renderBuddyWidget } from "./renderers.ts";
+import { OmpBuddyStorage } from "./storage.ts";
+
+export class OmpBuddyUI {
+  private readonly timers: Array<{ timer: Timer; clear: (timer: Timer) => void }> = [];
+
+  constructor(private readonly storage: OmpBuddyStorage) {}
+
+  cancelTimers(): void {
+    for (const { timer, clear } of this.timers.splice(0)) {
+      try {
+        clear(timer);
+      } catch {
+        // Ignore cleanup errors.
+      }
+    }
+  }
+
+  refresh(
+    ctx: OmpBuddyUiContext,
+    companion: Companion,
+    reaction?: ReactionState | null,
+    achievements: Achievement[] = [],
+  ): void {
+    const currentReaction = reaction ?? null;
+    const muted = this.storage.isMuted();
+    const status = renderBuddyStatus(companion, muted ? null : currentReaction);
+    ctx.ui.setStatus("buddy", muted ? `${status} [muted]` : status);
+    ctx.ui.setWidget(
+      "buddy",
+      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: OmpBuddyUiContext, achievements: Achievement[]): void {
+    for (const achievement of achievements) {
+      ctx.ui.notify(`Unlocked: ${achievement.icon} ${achievement.name}`, "info");
+    }
+  }
+
+  showAchievements(
+    ctx: OmpBuddyUiContext,
+    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");
+  }
+}
+
+function getScheduler(
+  ctx: OmpBuddyUiContext,
+): { 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;
+}

package/adapters/pi/commands.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
-import { BuddyCommandService } from "../../core/command-service.ts";
+import { BuddyCommandService, mergeAchievements } from "../../core/command-service.ts";
 import { renderBuddyStats } from "./renderers.ts";
 import { PiBuddyStorage, slugifySlot } from "./storage.ts";
 import { PiBuddyUI } from "./ui.ts";
@@ -12,7 +12,7 @@ interface RegisterBuddyCommandsDeps {
 
 export function registerBuddyCommands(pi: ExtensionAPI, deps: RegisterBuddyCommandsDeps): void {
   pi.registerCommand("buddy", {
-    description: "Manage your coding buddy",
+    description: "Manage your coding companion",
     handler: async (args: string, ctx: ExtensionCommandContext) => {
       const input = args.trim();
       const [command, ...rest] = input ? input.split(/\s+/) : [];
@@ -22,128 +22,154 @@ export function registerBuddyCommands(pi: ExtensionAPI, deps: RegisterBuddyComma
         switch (command) {
           case undefined:
           case "show": {
-            const result = deps.service.ensureCompanion();
-            deps.service.incrementCommandsRun();
+            const ensured = deps.service.ensureCompanion();
+            const commandAchievements = deps.service.incrementCommandsRun();
+            const achievements = mergeAchievements(ensured.achievements, commandAchievements);
             const reaction = deps.storage.loadLatest();
-            deps.ui.refresh(ctx, result.companion, reaction, result.achievements);
-            if (result.created) {
-              ctx.ui.notify(`Meet ${result.companion.name}!`, "info");
+            deps.ui.refresh(ctx, ensured.companion, reaction, achievements);
+            if (ensured.created) {
+              ctx.ui.notify(`Meet ${ensured.companion.name}!`, "info");
             } else {
-              ctx.ui.notify(deps.service.formatCompanionSummary(result.companion), "info");
+              ctx.ui.notify(deps.service.formatCompanionSummary(ensured.companion), "info");
             }
+            deps.ui.notifyAchievements(ctx, achievements);
             return;
           }
 
           case "pet": {
-            deps.service.incrementCommandsRun();
+            const commandAchievements = deps.service.incrementCommandsRun();
             const result = deps.service.petBuddy();
-            deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
+            const achievements = mergeAchievements(commandAchievements, result.achievements);
+            deps.ui.refresh(ctx, result.companion, result.state, achievements);
             ctx.ui.notify(`${result.companion.name} seems pleased.`, "info");
-            deps.ui.notifyAchievements(ctx, result.achievements);
+            deps.ui.notifyAchievements(ctx, achievements);
             return;
           }
 
           case "stats": {
-            deps.service.incrementCommandsRun();
-            const result = deps.service.ensureCompanion();
-            ctx.ui.setWidget("buddy", renderBuddyStats(result.companion));
-            ctx.ui.notify(`${result.companion.name}'s stats`, "info");
+            const ensured = deps.service.ensureCompanion();
+            const commandAchievements = deps.service.incrementCommandsRun();
+            const achievements = mergeAchievements(ensured.achievements, commandAchievements);
+            ctx.ui.setWidget("buddy", renderBuddyStats(ensured.companion));
+            ctx.ui.notify(`${ensured.companion.name}'s stats`, "info");
+            deps.ui.notifyAchievements(ctx, achievements);
             return;
           }
 
           case "rename": {
             if (!remainder) throw new Error("Usage: /buddy rename <name>");
-            deps.service.incrementCommandsRun();
+            const commandAchievements = deps.service.incrementCommandsRun();
             const companion = deps.service.renameBuddy(remainder);
-            deps.ui.refresh(ctx, companion, deps.storage.loadLatest());
+            const ensured = deps.service.ensureCompanion();
+            const achievements = mergeAchievements(commandAchievements, ensured.achievements);
+            deps.ui.refresh(ctx, companion, deps.storage.loadLatest(), achievements);
             ctx.ui.notify(`Buddy renamed to ${companion.name}.`, "info");
+            deps.ui.notifyAchievements(ctx, achievements);
             return;
           }
 
           case "personality": {
             if (!remainder) throw new Error("Usage: /buddy personality <text>");
-            deps.service.incrementCommandsRun();
+            const commandAchievements = deps.service.incrementCommandsRun();
             const companion = deps.service.setPersonality(remainder);
-            deps.ui.refresh(ctx, companion, deps.storage.loadLatest());
+            const ensured = deps.service.ensureCompanion();
+            const achievements = mergeAchievements(commandAchievements, ensured.achievements);
+            deps.ui.refresh(ctx, companion, deps.storage.loadLatest(), achievements);
             ctx.ui.notify(`${companion.name}'s personality was updated.`, "info");
+            deps.ui.notifyAchievements(ctx, achievements);
             return;
           }
 
           case "off": {
-            deps.service.incrementCommandsRun();
+            const commandAchievements = deps.service.incrementCommandsRun();
             deps.storage.setMuted(true);
-            const result = deps.service.ensureCompanion();
-            deps.ui.refresh(ctx, result.companion, null);
-            ctx.ui.notify(`${result.companion.name} goes quiet.`, "info");
+            const ensured = deps.service.ensureCompanion();
+            const achievements = mergeAchievements(commandAchievements, ensured.achievements);
+            deps.ui.refresh(ctx, ensured.companion, null, achievements);
+            ctx.ui.notify(`${ensured.companion.name} goes quiet.`, "info");
+            deps.ui.notifyAchievements(ctx, achievements);
             return;
           }
 
           case "on": {
-            deps.service.incrementCommandsRun();
+            const commandAchievements = deps.service.incrementCommandsRun();
             deps.storage.setMuted(false);
             const result = deps.service.recordComment("*stretches* I'm back!");
-            deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
+            const achievements = mergeAchievements(commandAchievements, result.achievements);
+            deps.ui.refresh(ctx, result.companion, result.state, achievements);
             ctx.ui.notify(`${result.companion.name} is back.`, "info");
-            deps.ui.notifyAchievements(ctx, result.achievements);
+            deps.ui.notifyAchievements(ctx, achievements);
             return;
           }
 
           case "save": {
-            deps.service.incrementCommandsRun();
+            const commandAchievements = deps.service.incrementCommandsRun();
             const result = deps.service.saveBuddy(remainder || undefined);
-            deps.ui.refresh(ctx, result.companion, deps.storage.loadLatest());
+            const ensured = deps.service.ensureCompanion();
+            const achievements = mergeAchievements(commandAchievements, ensured.achievements);
+            deps.ui.refresh(ctx, result.companion, deps.storage.loadLatest(), achievements);
             ctx.ui.notify(`Saved ${result.companion.name} to [${result.slot}].`, "info");
+            deps.ui.notifyAchievements(ctx, achievements);
             return;
           }
 
           case "summon": {
-            deps.service.incrementCommandsRun();
+            const commandAchievements = deps.service.incrementCommandsRun();
             const result = deps.service.summonBuddy(remainder || undefined);
             if (!result) throw new Error("No saved buddy found for that slot.");
-            deps.ui.refresh(ctx, result.companion, deps.storage.loadLatest());
+            const ensured = deps.service.ensureCompanion();
+            const achievements = mergeAchievements(commandAchievements, ensured.achievements);
+            deps.ui.refresh(ctx, result.companion, deps.storage.loadLatest(), achievements);
             ctx.ui.notify(`${result.companion.name} arrives from [${result.slot}].`, "info");
+            deps.ui.notifyAchievements(ctx, achievements);
             return;
           }
 
           case "list": {
-            deps.service.incrementCommandsRun();
+            const commandAchievements = deps.service.incrementCommandsRun();
             const active = deps.storage.loadActiveSlot();
             const companions = deps.service.listCompanions();
             if (companions.length === 0) {
               ctx.ui.notify("No saved buddies yet.", "info");
+              deps.ui.notifyAchievements(ctx, commandAchievements);
               return;
             }
             ctx.ui.setWidget(
               "buddy",
               companions.map(({ slot, companion }) => {
-                const marker = slot === active ? " ← active" : "";
-                return `${companion.name} [${slot}] — ${companion.bones.rarity} ${companion.bones.species}${marker}`;
+                const marker = slot === active ? " <- active" : "";
+                return `${companion.name} [${slot}] - ${companion.bones.rarity} ${companion.bones.species}${marker}`;
               }),
             );
             ctx.ui.notify(`Saved buddies: ${companions.length}`, "info");
+            deps.ui.notifyAchievements(ctx, commandAchievements);
             return;
           }
 
           case "dismiss": {
             if (!remainder) throw new Error("Usage: /buddy dismiss <slot>");
-            deps.service.incrementCommandsRun();
+            const commandAchievements = deps.service.incrementCommandsRun();
             const result = deps.service.dismissBuddy(remainder);
-            const active = deps.service.ensureCompanion();
-            deps.ui.refresh(ctx, active.companion, deps.storage.loadLatest());
+            const ensured = deps.service.ensureCompanion();
+            const achievements = mergeAchievements(commandAchievements, ensured.achievements);
+            deps.ui.refresh(ctx, ensured.companion, deps.storage.loadLatest(), achievements);
             ctx.ui.notify(`Dismissed ${result.companion.name} [${result.slot}].`, "info");
+            deps.ui.notifyAchievements(ctx, achievements);
             return;
           }
 
           case "achievements": {
-            deps.service.incrementCommandsRun();
+            const commandAchievements = deps.service.incrementCommandsRun();
             const activeSlot = deps.storage.loadActiveSlot() ?? undefined;
             const progress = deps.service.getAchievementProgress(activeSlot);
             deps.ui.showAchievements(ctx, progress.unlocked, progress.remaining);
+            deps.ui.notifyAchievements(ctx, commandAchievements);
             return;
           }
 
           case "help":
           default: {
+            const commandAchievements = deps.service.incrementCommandsRun();
             ctx.ui.setWidget("buddy", [
               "/buddy",
               "/buddy pet",
@@ -158,6 +184,7 @@ export function registerBuddyCommands(pi: ExtensionAPI, deps: RegisterBuddyComma
               "/buddy achievements",
             ]);
             ctx.ui.notify("Buddy commands ready.", "info");
+            deps.ui.notifyAchievements(ctx, commandAchievements);
             return;
           }
         }