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

package/adapters/pi/commands.ts

@@ -0,0 +1,173 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { BuddyCommandService } from "../../core/command-service.ts";
+import { renderBuddyStats } from "./renderers.ts";
+import { PiBuddyStorage, slugifySlot } from "./storage.ts";
+import { PiBuddyUI } from "./ui.ts";
+
+interface RegisterBuddyCommandsDeps {
+  service: BuddyCommandService;
+  storage: PiBuddyStorage;
+  ui: PiBuddyUI;
+}
+
+export function registerBuddyCommands(pi: ExtensionAPI, deps: RegisterBuddyCommandsDeps): void {
+  pi.registerCommand("buddy", {
+    description: "Manage your coding buddy",
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const input = args.trim();
+      const [command, ...rest] = input ? input.split(/\s+/) : [];
+      const remainder = rest.join(" ").trim();
+
+      try {
+        switch (command) {
+          case undefined:
+          case "show": {
+            const result = deps.service.ensureCompanion();
+            deps.service.incrementCommandsRun();
+            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");
+            } else {
+              ctx.ui.notify(deps.service.formatCompanionSummary(result.companion), "info");
+            }
+            return;
+          }
+
+          case "pet": {
+            deps.service.incrementCommandsRun();
+            const result = deps.service.petBuddy();
+            deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
+            ctx.ui.notify(`${result.companion.name} seems pleased.`, "info");
+            deps.ui.notifyAchievements(ctx, result.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");
+            return;
+          }
+
+          case "rename": {
+            if (!remainder) throw new Error("Usage: /buddy rename <name>");
+            deps.service.incrementCommandsRun();
+            const companion = deps.service.renameBuddy(remainder);
+            deps.ui.refresh(ctx, companion, deps.storage.loadLatest());
+            ctx.ui.notify(`Buddy renamed to ${companion.name}.`, "info");
+            return;
+          }
+
+          case "personality": {
+            if (!remainder) throw new Error("Usage: /buddy personality <text>");
+            deps.service.incrementCommandsRun();
+            const companion = deps.service.setPersonality(remainder);
+            deps.ui.refresh(ctx, companion, deps.storage.loadLatest());
+            ctx.ui.notify(`${companion.name}'s personality was updated.`, "info");
+            return;
+          }
+
+          case "off": {
+            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");
+            return;
+          }
+
+          case "on": {
+            deps.service.incrementCommandsRun();
+            deps.storage.setMuted(false);
+            const result = deps.service.recordTurn();
+            deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
+            ctx.ui.notify(`${result.companion.name} is back.`, "info");
+            deps.ui.notifyAchievements(ctx, result.achievements);
+            return;
+          }
+
+          case "save": {
+            deps.service.incrementCommandsRun();
+            const result = deps.service.saveBuddy(remainder || undefined);
+            deps.ui.refresh(ctx, result.companion, deps.storage.loadLatest());
+            ctx.ui.notify(`Saved ${result.companion.name} to [${result.slot}].`, "info");
+            return;
+          }
+
+          case "summon": {
+            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());
+            ctx.ui.notify(`${result.companion.name} arrives from [${result.slot}].`, "info");
+            return;
+          }
+
+          case "list": {
+            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");
+              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}`;
+              }),
+            );
+            ctx.ui.notify(`Saved buddies: ${companions.length}`, "info");
+            return;
+          }
+
+          case "dismiss": {
+            if (!remainder) throw new Error("Usage: /buddy dismiss <slot>");
+            deps.service.incrementCommandsRun();
+            const result = deps.service.dismissBuddy(remainder);
+            const active = deps.service.ensureCompanion();
+            deps.ui.refresh(ctx, active.companion, deps.storage.loadLatest());
+            ctx.ui.notify(`Dismissed ${result.companion.name} [${result.slot}].`, "info");
+            return;
+          }
+
+          case "achievements": {
+            deps.service.incrementCommandsRun();
+            const activeSlot = deps.storage.loadActiveSlot() ?? undefined;
+            const progress = deps.service.getAchievementProgress(activeSlot);
+            deps.ui.showAchievements(ctx, progress.unlocked, progress.remaining);
+            return;
+          }
+
+          case "help":
+          default: {
+            ctx.ui.setWidget("buddy", [
+              "/buddy",
+              "/buddy pet",
+              "/buddy stats",
+              "/buddy rename <name>",
+              "/buddy personality <text>",
+              "/buddy off | on",
+              "/buddy save [slot]",
+              "/buddy summon [slot]",
+              "/buddy list",
+              "/buddy dismiss <slot>",
+              "/buddy achievements",
+            ]);
+            ctx.ui.notify("Buddy commands ready.", "info");
+            return;
+          }
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.ui.notify(message, "error");
+        if (command === "save" && remainder) {
+          ctx.ui.notify(`Try a different slot, for example: ${slugifySlot(remainder)}-2`, "info");
+        }
+      }
+    },
+  });
+}

package/adapters/pi/events.ts

@@ -0,0 +1,150 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  InputEvent,
+  InputEventResult,
+  SessionStartEvent,
+  ToolResultEvent,
+  TurnEndEvent,
+} from "@mariozechner/pi-coding-agent";
+import { isBashToolResult } from "@mariozechner/pi-coding-agent";
+import { BuddyCommandService } from "../../core/command-service.ts";
+import { PiBuddyStorage } from "./storage.ts";
+import { PiBuddyUI } from "./ui.ts";
+
+interface RegisterBuddyEventsDeps {
+  service: BuddyCommandService;
+  storage: PiBuddyStorage;
+  ui: PiBuddyUI;
+}
+
+export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsDeps): void {
+  pi.on("session_start", async (_event: SessionStartEvent, ctx: ExtensionContext) => {
+    const result = deps.service.ensureCompanion();
+    deps.ui.refresh(ctx, result.companion, deps.storage.loadLatest(), result.achievements);
+    if (result.created) {
+      ctx.ui.notify(`A new buddy hatched: ${result.companion.name}`, "info");
+      deps.ui.notifyAchievements(ctx, result.achievements);
+    }
+  });
+
+  pi.on("input", async (event: InputEvent, ctx: ExtensionContext): Promise<InputEventResult> => {
+    if (event.source === "extension" || deps.storage.isMuted()) {
+      return { action: "continue" };
+    }
+
+    const companion = deps.service.ensureCompanion().companion;
+    const pattern = new RegExp(`\\b${escapeRegExp(companion.name)}\\b`, "i");
+    if (!pattern.test(event.text)) {
+      return { action: "continue" };
+    }
+
+    if (!shouldEmitPassiveReaction(deps.storage)) {
+      return { action: "continue" };
+    }
+
+    const result = deps.service.recordNameMention();
+    deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
+    deps.ui.notifyAchievements(ctx, result.achievements);
+    return { action: "continue" };
+  });
+
+  pi.on("tool_result", async (event: ToolResultEvent, ctx: ExtensionContext) => {
+    if (deps.storage.isMuted() || !shouldEmitPassiveReaction(deps.storage)) return;
+
+    const text = extractToolText(event);
+    let result:
+      | ReturnType<BuddyCommandService["recordToolError"]>
+      | ReturnType<BuddyCommandService["recordTestFailure"]>
+      | ReturnType<BuddyCommandService["recordLargeDiff"]>
+      | undefined;
+
+    if (event.isError) {
+      result = deps.service.recordToolError(undefined, firstLineNumber(text));
+    } else if (looksLikeTestFailure(text)) {
+      result = deps.service.recordTestFailure(undefined, extractFailureCount(text));
+    } else {
+      const diffLines = extractLargeDiffLines(text);
+      if (diffLines >= 80) {
+        result = deps.service.recordLargeDiff(diffLines);
+      }
+    }
+
+    if (!result) return;
+    deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
+    deps.ui.notifyAchievements(ctx, result.achievements);
+  });
+
+  pi.on("turn_end", async (_event: TurnEndEvent, ctx: ExtensionContext) => {
+    const result = deps.service.recordTurn();
+    if (deps.storage.isMuted()) {
+      deps.ui.refresh(ctx, result.companion, null, result.achievements);
+      return;
+    }
+
+    if (!shouldEmitPassiveReaction(deps.storage)) {
+      deps.ui.refresh(ctx, result.companion, deps.storage.loadLatest(), result.achievements);
+      return;
+    }
+
+    if (Math.random() < 0.35) {
+      deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
+      deps.ui.notifyAchievements(ctx, result.achievements);
+      return;
+    }
+
+    deps.ui.refresh(ctx, result.companion, deps.storage.loadLatest(), result.achievements);
+  });
+}
+
+function shouldEmitPassiveReaction(storage: PiBuddyStorage): boolean {
+  const cooldownSeconds = storage.loadPiConfig().commentCooldown;
+  if (cooldownSeconds <= 0) return true;
+  const latest = storage.loadLatest();
+  if (!latest?.timestamp) return true;
+  return Date.now() - latest.timestamp >= cooldownSeconds * 1000;
+}
+
+function extractToolText(event: ToolResultEvent): string {
+  const fromContent = event.content
+    .filter((item): item is Extract<(typeof event.content)[number], { type: "text" }> => item.type === "text")
+    .map((item) => item.text)
+    .join("\n");
+
+  if (fromContent.trim()) return fromContent;
+  if (isBashToolResult(event)) {
+    return "";
+  }
+  return "";
+}
+
+function looksLikeTestFailure(text: string): boolean {
+  return /(FAIL|failed|failing|test(s)? failed|not ok)/i.test(text);
+}
+
+function extractFailureCount(text: string): number | undefined {
+  const match = text.match(/(\d+)\s+(tests? )?(failed|failing)/i);
+  return match ? Number(match[1]) : undefined;
+}
+
+function extractLargeDiffLines(text: string): number {
+  const statMatch = text.match(/(\d+)\s+insertions?\(\+\).*?(\d+)\s+deletions?\(-\)/is);
+  if (statMatch) {
+    return Number(statMatch[1]) + Number(statMatch[2]);
+  }
+
+  const patchLines = text
+    .split(/\r?\n/)
+    .filter((line) => line.startsWith("+") || line.startsWith("-"))
+    .length;
+  return patchLines;
+}
+
+function firstLineNumber(text: string): number | undefined {
+  const match = text.match(/line\s+(\d+)/i);
+  return match ? Number(match[1]) : undefined;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/adapters/pi/identity.ts

@@ -0,0 +1,10 @@
+import type { IdentityProvider } from "../../core/ports.ts";
+import { PiBuddyStorage } from "./storage.ts";
+
+export class PiIdentityProvider implements IdentityProvider {
+  constructor(private readonly storage: PiBuddyStorage) {}
+
+  getStableUserId(): string {
+    return this.storage.ensureStableIdentity();
+  }
+}

package/adapters/pi/index.ts

@@ -0,0 +1,25 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { BuddyCommandService } from "../../core/command-service.ts";
+import { PiIdentityProvider } from "./identity.ts";
+import { registerBuddyCommands } from "./commands.ts";
+import { registerBuddyEvents } from "./events.ts";
+import { PiBuddyStorage } from "./storage.ts";
+import { registerBuddyTools } from "./tools.ts";
+import { PiBuddyUI } from "./ui.ts";
+
+export default function registerPiBuddyExtension(pi: ExtensionAPI): void {
+  const storage = new PiBuddyStorage();
+  const identity = new PiIdentityProvider(storage);
+  const service = new BuddyCommandService({
+    identity,
+    buddies: storage,
+    reactions: storage,
+    config: storage,
+    events: storage,
+  });
+  const ui = new PiBuddyUI(storage);
+
+  registerBuddyCommands(pi, { service, storage, ui });
+  registerBuddyEvents(pi, { service, storage, ui });
+  registerBuddyTools(pi);
+}

package/adapters/pi/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;
+}