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

package/core/art-data.ts

@@ -0,0 +1,105 @@
+import type { Species, Hat } from "./engine.ts";
+
+export const SPECIES_ART: Record<Species, string[][]> = {
+  duck: [
+    ["            ", "    __      ", "  <({E} )___  ", "   (  ._>   ", "    `--'    "],
+    ["            ", "    __      ", "  <({E} )___  ", "   (  ._>   ", "    `--'~   "],
+    ["            ", "    __      ", "  <({E} )___  ", "   (  .__>  ", "    `--'    "],
+  ],
+  goose: [
+    ["            ", "     ({E}>    ", "     ||     ", "   _(__)_   ", "    ^^^^    "],
+    ["            ", "    ({E}>     ", "     ||     ", "   _(__)_   ", "    ^^^^    "],
+    ["            ", "     ({E}>>   ", "     ||     ", "   _(__)_   ", "    ^^^^    "],
+  ],
+  blob: [
+    ["            ", "   .----.   ", "  ( {E}  {E} )  ", "  (      )  ", "   `----'   "],
+    ["            ", "  .------.  ", " (  {E}  {E}  ) ", " (        ) ", "  `------'  "],
+    ["            ", "    .--.    ", "   ({E}  {E})   ", "   (    )   ", "    `--'    "],
+  ],
+  cat: [
+    ["            ", "   /\\_/\\    ", "  ( {E}   {E})  ", "  (  \u03c9  )   ", "  (\")_(\")   "],
+    ["            ", "   /\\_/\\    ", "  ( {E}   {E})  ", "  (  \u03c9  )   ", "  (\")_(\")~  "],
+    ["            ", "   /\\-/\\    ", "  ( {E}   {E})  ", "  (  \u03c9  )   ", "  (\")_(\")   "],
+  ],
+  dragon: [
+    ["            ", "  /^\\  /^\\  ", " <  {E}  {E}  > ", " (   ~~   ) ", "  `-vvvv-'  "],
+    ["            ", "  /^\\  /^\\  ", " <  {E}  {E}  > ", " (        ) ", "  `-vvvv-'  "],
+    ["   ~    ~   ", "  /^\\  /^\\  ", " <  {E}  {E}  > ", " (   ~~   ) ", "  `-vvvv-'  "],
+  ],
+  octopus: [
+    ["            ", "   .----.   ", "  ( {E}  {E} )  ", "  (______)  ", "  /\\/\\/\\/\\  "],
+    ["            ", "   .----.   ", "  ( {E}  {E} )  ", "  (______)  ", "  \\/\\/\\/\\/  "],
+    ["     o      ", "   .----.   ", "  ( {E}  {E} )  ", "  (______)  ", "  /\\/\\/\\/\\  "],
+  ],
+  owl: [
+    ["            ", "   /\\  /\\   ", "  (({E})({E}))  ", "  (  ><  )  ", "   `----'   "],
+    ["            ", "   /\\  /\\   ", "  (({E})({E}))  ", "  (  ><  )  ", "   .----.   "],
+    ["            ", "   /\\  /\\   ", "  (({E})(-))  ", "  (  ><  )  ", "   `----'   "],
+  ],
+  penguin: [
+    ["            ", "  .---.     ", "  ({E}>{E})     ", " /(   )\\    ", "  `---'     "],
+    ["            ", "  .---.     ", "  ({E}>{E})     ", " |(   )|    ", "  `---'     "],
+    ["  .---.     ", "  ({E}>{E})     ", " /(   )\\    ", "  `---'     ", "   ~ ~      "],
+  ],
+  turtle: [
+    ["            ", "   _,--._   ", "  ( {E}  {E} )  ", " /[______]\\ ", "  ``    ``  "],
+    ["            ", "   _,--._   ", "  ( {E}  {E} )  ", " /[______]\\ ", "   ``  ``   "],
+    ["            ", "   _,--._   ", "  ( {E}  {E} )  ", " /[======]\\ ", "  ``    ``  "],
+  ],
+  snail: [
+    ["            ", " {E}    .--.  ", "  \\  ( @ )  ", "   \\_`--'   ", "  ~~~~~~~   "],
+    ["            ", "  {E}   .--.  ", "  |  ( @ )  ", "   \\_`--'   ", "  ~~~~~~~   "],
+    ["            ", " {E}    .--.  ", "  \\  ( @  ) ", "   \\_`--'   ", "   ~~~~~~   "],
+  ],
+  ghost: [
+    ["            ", "   .----.   ", "  / {E}  {E} \\  ", "  |      |  ", "  ~`~``~`~  "],
+    ["            ", "   .----.   ", "  / {E}  {E} \\  ", "  |      |  ", "  `~`~~`~`  "],
+    ["    ~  ~    ", "   .----.   ", "  / {E}  {E} \\  ", "  |      |  ", "  ~~`~~`~~  "],
+  ],
+  axolotl: [
+    ["            ", "}~(______)~{", "}~({E} .. {E})~{", "  ( .--. )  ", "  (_/  \\_)  "],
+    ["            ", "~}(______){~", "~}({E} .. {E}){~", "  ( .--. )  ", "  (_/  \\_)  "],
+    ["            ", "}~(______)~{", "}~({E} .. {E})~{", "  (  --  )  ", "  ~_/  \\_~  "],
+  ],
+  capybara: [
+    ["            ", "  n______n  ", " ( {E}    {E} ) ", " (   oo   ) ", "  `------'  "],
+    ["            ", "  n______n  ", " ( {E}    {E} ) ", " (   Oo   ) ", "  `------'  "],
+    ["    ~  ~    ", "  u______n  ", " ( {E}    {E} ) ", " (   oo   ) ", "  `------'  "],
+  ],
+  cactus: [
+    ["            ", " n  ____  n ", " | |{E}  {E}| | ", " |_|    |_| ", "   |    |   "],
+    ["            ", "    ____    ", " n |{E}  {E}| n ", " |_|    |_| ", "   |    |   "],
+    [" n        n ", " |  ____  | ", " | |{E}  {E}| | ", " |_|    |_| ", "   |    |   "],
+  ],
+  robot: [
+    ["            ", "   .[||].   ", "  [ {E}  {E} ]  ", "  [ ==== ]  ", "  `------'  "],
+    ["            ", "   .[||].   ", "  [ {E}  {E} ]  ", "  [ -==- ]  ", "  `------'  "],
+    ["     *      ", "   .[||].   ", "  [ {E}  {E} ]  ", "  [ ==== ]  ", "  `------'  "],
+  ],
+  rabbit: [
+    ["            ", "   (\\__/)   ", "  ( {E}  {E} )  ", " =(  ..  )= ", "  (\")__(\")" ],
+    ["            ", "   (|__/)   ", "  ( {E}  {E} )  ", " =(  ..  )= ", "  (\")__(\")" ],
+    ["            ", "   (\\__/)   ", "  ( {E}  {E} )  ", " =( .  . )= ", "  (\")__(\")" ],
+  ],
+  mushroom: [
+    ["            ", " .-o-OO-o-. ", "(__________)","   |{E}  {E}|   ", "   |____|   "],
+    ["            ", " .-O-oo-O-. ", "(__________)","   |{E}  {E}|   ", "   |____|   "],
+    ["   . o  .   ", " .-o-OO-o-. ", "(__________)","   |{E}  {E}|   ", "   |____|   "],
+  ],
+  chonk: [
+    ["            ", "  /\\    /\\  ", " ( {E}    {E} ) ", " (   ..   ) ", "  `------'  "],
+    ["            ", "  /\\    /|  ", " ( {E}    {E} ) ", " (   ..   ) ", "  `------'  "],
+    ["            ", "  /\\    /\\  ", " ( {E}    {E} ) ", " (   ..   ) ", "  `------'~ "],
+  ],
+};
+
+export const HAT_ART: Record<Hat, string> = {
+  none:      "",
+  crown:     "   \\^^^/    ",
+  tophat:    "   [___]    ",
+  propeller: "    -+-     ",
+  halo:      "   (   )    ",
+  wizard:    "    /^\\     ",
+  beanie:    "   (___)    ",
+  tinyduck:  "    ,>      ",
+};

package/core/command-service.ts

@@ -0,0 +1,338 @@
+import {
+  generateBones,
+  RARITY_STARS,
+  type Companion,
+} from "./engine.ts";
+import { getUnlockedAchievements, type Achievement } from "./achievements.ts";
+import { generateFallbackName, getReaction } from "./reactions.ts";
+import type {
+  BuddyConfig,
+  ReactionState,
+} from "./model.ts";
+import type {
+  BuddyConfigRepository,
+  BuddyEventRepository,
+  BuddyRepository,
+  IdentityProvider,
+  ReactionRepository,
+} from "./ports.ts";
+
+export interface BuddyCommandServiceDeps {
+  identity: IdentityProvider;
+  buddies: BuddyRepository;
+  reactions: ReactionRepository;
+  config: BuddyConfigRepository;
+  events: BuddyEventRepository;
+}
+
+export interface EnsureCompanionResult {
+  companion: Companion;
+  slot: string;
+  created: boolean;
+  achievements: Achievement[];
+}
+
+export interface ReactionResult {
+  companion: Companion;
+  slot: string;
+  reaction: string;
+  state: ReactionState;
+  achievements: Achievement[];
+}
+
+export interface SaveBuddyResult {
+  companion: Companion;
+  slot: string;
+}
+
+export interface SummonBuddyResult {
+  companion: Companion;
+  slot: string;
+}
+
+/**
+ * Shared application-service seam for buddy operations.
+ *
+ * Host adapters should depend on this service for buddy domain behavior,
+ * while keeping transport, UI, and host-specific persistence concerns outside.
+ */
+export class BuddyCommandService {
+  constructor(private readonly deps: BuddyCommandServiceDeps) {}
+
+  getStableUserId(): string {
+    return this.deps.identity.getStableUserId();
+  }
+
+  loadActiveCompanion(): Companion | null {
+    return this.deps.buddies.loadActive();
+  }
+
+  loadLatestReaction(scope?: string): ReactionState | null {
+    return this.deps.reactions.loadLatest(scope);
+  }
+
+  loadConfig(): BuddyConfig {
+    return this.deps.config.loadConfig();
+  }
+
+  listCompanions(): Array<{ slot: string; companion: Companion }> {
+    return this.deps.buddies.listSlots();
+  }
+
+  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);
+    this.deps.events.trackActiveDay();
+    this.deps.events.increment("sessions", 1);
+    const achievements = this.unlockAchievements(slot);
+
+    return { companion, slot, created: true, achievements };
+  }
+
+  petBuddy(scope?: string): ReactionResult {
+    const { companion, slot } = this.ensureCompanion();
+    this.deps.events.increment("pets", 1, slot);
+    return this.saveReaction("pet", companion, slot, scope);
+  }
+
+  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;
+  }
+
+  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;
+  }
+
+  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 };
+  }
+
+  summonBuddy(slot?: string): SummonBuddyResult | null {
+    const targetSlot = slot ? slugify(slot) : undefined;
+
+    if (!targetSlot) {
+      const companions = this.deps.buddies.listSlots();
+      if (companions.length === 0) return null;
+      const pick = companions[Math.floor(Math.random() * companions.length)];
+      this.deps.buddies.saveActiveSlot(pick.slot);
+      return { companion: pick.companion, slot: pick.slot };
+    }
+
+    const companion = this.deps.buddies.loadSlot(targetSlot);
+    if (!companion) return null;
+
+    this.deps.buddies.saveActiveSlot(targetSlot);
+    return { companion, slot: targetSlot };
+  }
+
+  dismissBuddy(slot: string): SaveBuddyResult {
+    const targetSlot = slugify(slot);
+    const activeSlot = this.getActiveSlot();
+    if (targetSlot === activeSlot) {
+      throw new Error("Cannot dismiss the active buddy.");
+    }
+
+    const companion = this.deps.buddies.loadSlot(targetSlot);
+    if (!companion) {
+      throw new Error(`No buddy found in slot \"${targetSlot}\".`);
+    }
+
+    this.deps.buddies.deleteSlot(targetSlot);
+    return { companion, slot: targetSlot };
+  }
+
+  recordNameMention(scope?: string): ReactionResult {
+    const { companion, slot } = this.ensureCompanion();
+    return this.saveReaction("turn", companion, slot, scope);
+  }
+
+  recordToolError(scope?: string, line?: number): ReactionResult {
+    const { companion, slot } = this.ensureCompanion();
+    this.deps.events.increment("errors_seen", 1);
+    return this.saveReaction("error", companion, slot, scope, { line });
+  }
+
+  recordTestFailure(scope?: string, count?: number): ReactionResult {
+    const { companion, slot } = this.ensureCompanion();
+    this.deps.events.increment("tests_failed", 1);
+    return this.saveReaction("test-fail", companion, slot, scope, { count });
+  }
+
+  recordLargeDiff(lines: number, scope?: string): ReactionResult {
+    const { companion, slot } = this.ensureCompanion();
+    this.deps.events.increment("large_diffs", 1);
+    return this.saveReaction("large-diff", companion, slot, scope, { lines });
+  }
+
+  recordTurn(scope?: string): ReactionResult {
+    const { companion, slot } = this.ensureCompanion();
+    this.deps.events.increment("turns", 1);
+    return this.saveReaction("turn", companion, slot, scope);
+  }
+
+  incrementCommandsRun(): Achievement[] {
+    this.deps.events.increment("commands_run", 1, this.getActiveSlotOrUndefined());
+    return this.unlockAchievements(this.getActiveSlotOrUndefined());
+  }
+
+  getAchievementProgress(slot?: string): {
+    unlocked: Array<{ achievement: Achievement; unlockedAt: number; slot?: string }>;
+    remaining: Achievement[];
+  } {
+    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)),
+    );
+
+    return {
+      unlocked: unlockedAchievements.map((achievement) => ({
+        achievement,
+        unlockedAt: unlockedMap.get(achievement.id)?.unlockedAt ?? 0,
+        slot: unlockedMap.get(achievement.id)?.slot,
+      })),
+      remaining,
+    };
+  }
+
+  formatCompanionSummary(companion: Companion): string {
+    const shiny = companion.bones.shiny ? " ✨" : "";
+    return `${companion.name} — ${companion.bones.rarity} ${companion.bones.species} ${RARITY_STARS[companion.bones.rarity]}${shiny}`;
+  }
+
+  private getActiveSlot(): string {
+    return this.deps.buddies.loadActiveSlot() || "buddy";
+  }
+
+  private getActiveSlotOrUndefined(): string | undefined {
+    const slot = this.deps.buddies.loadActiveSlot();
+    return slot || undefined;
+  }
+
+  private createCompanion(userId: string): Companion {
+    const bones = generateBones(userId);
+    const name = this.generateUnusedName();
+    return {
+      bones,
+      name,
+      personality: `A ${bones.rarity} ${bones.species} who watches code with quiet intensity.`,
+      hatchedAt: Date.now(),
+      userId,
+    };
+  }
+
+  private generateUnusedName(): string {
+    const taken = new Set(this.deps.buddies.listSlots().map(({ slot }) => slot));
+    for (let i = 0; i < 50; i++) {
+      const candidate = generateFallbackName();
+      if (!taken.has(slugify(candidate))) return candidate;
+    }
+
+    let suffix = 0;
+    while (taken.has(`buddy-${suffix}`)) suffix++;
+    return `buddy-${suffix}`;
+  }
+
+  private saveReaction(
+    reason: "pet" | "turn" | "error" | "test-fail" | "large-diff",
+    companion: Companion,
+    slot: string,
+    scope?: string,
+    context?: { line?: number; count?: number; lines?: number },
+  ): ReactionResult {
+    const reaction = getReaction(
+      reason,
+      companion.bones.species,
+      companion.bones.rarity,
+      context,
+    );
+    const state: ReactionState = {
+      reaction,
+      reason,
+      timestamp: Date.now(),
+    };
+    this.deps.reactions.saveLatest(state, scope);
+    this.deps.events.increment("reactions_given", 1, slot);
+    const achievements = this.unlockAchievements(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;
+  }
+}
+
+function slugify(name: string): string {
+  return (
+    name
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, "-")
+      .replace(/-+/g, "-")
+      .replace(/^-|-$/g, "")
+      .slice(0, 14) || "buddy"
+  );
+}

package/core/model.ts

@@ -0,0 +1,59 @@
+import type {
+  BuddyBones,
+  BuddyStats,
+  Companion,
+  Species,
+  Rarity,
+  Eye,
+  Hat,
+  StatName,
+} from "./engine.ts";
+
+export type {
+  BuddyBones,
+  BuddyStats,
+  Companion,
+  Species,
+  Rarity,
+  Eye,
+  Hat,
+  StatName,
+};
+
+export interface ReactionState {
+  reaction: string;
+  timestamp: number;
+  reason: string;
+}
+
+export interface BuddyConfig {
+  commentCooldown: number;
+  reactionTTL: number;
+  bubbleStyle: "classic" | "round";
+  bubblePosition: "top" | "left";
+  showRarity: boolean;
+  statusLineEnabled: boolean;
+}
+
+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, SlotCounters {}
+
+export interface UnlockedAchievement {
+  id: string;
+  unlockedAt: number;
+  slot?: string;
+}

package/core/ports.ts

@@ -0,0 +1,40 @@
+import type {
+  BuddyConfig,
+  Companion,
+  EventCounters,
+  ReactionState,
+  UnlockedAchievement,
+} from "./model.ts";
+
+export interface IdentityProvider {
+  getStableUserId(): string;
+}
+
+export interface BuddyRepository {
+  loadActive(): Companion | null;
+  saveActive(companion: Companion): void;
+  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;
+}
+
+export interface ReactionRepository {
+  loadLatest(scope?: string): ReactionState | null;
+  saveLatest(reaction: ReactionState, scope?: string): void;
+}
+
+export interface BuddyConfigRepository {
+  loadConfig(): BuddyConfig;
+  saveConfig(config: Partial<BuddyConfig>): BuddyConfig;
+}
+
+export interface BuddyEventRepository {
+  loadCounters(scope?: string): EventCounters;
+  increment(key: keyof EventCounters, amount?: number, scope?: string): EventCounters;
+  loadUnlocked(): UnlockedAchievement[];
+  saveUnlocked(unlocked: UnlockedAchievement[]): void;
+  trackActiveDay(): void;
+}

package/core/render-model.ts

@@ -0,0 +1,10 @@
+import type { Eye, Species } from "./engine.ts";
+import { HAT_ART, SPECIES_ART } from "./art-data.ts";
+
+export function getArtFrame(species: Species, eye: Eye, frame: number = 0): string[] {
+  const frames = SPECIES_ART[species];
+  const f = frames[frame % frames.length];
+  return f.map((line) => line.replace(/\{E\}/g, eye));
+}
+
+export { HAT_ART, SPECIES_ART };

package/package.json

@@ -1,35 +1,32 @@
 {
     "name": "@ramarivera/coding-buddy",
-    "version": "0.4.0-alpha.2",
+    "version": "0.4.0-alpha.4",
     "description": "Persistent coding companion for Claude Code and pi",
     "type": "module",
     "bin": {
         "coding-buddy": "./cli/index.ts"
     },
     "scripts": {
-        "server": "bun run server/index.ts",
-        "pick": "bun run cli/pick.ts",
-        "hunt": "bun run cli/hunt.ts",
-        "install-buddy": "bun run cli/install.ts",
-        "show": "bun run cli/show.ts",
-        "doctor": "bun run cli/doctor.ts",
-        "test-statusline": "bun run cli/test-statusline.ts",
-        "backup": "bun run cli/backup.ts",
-        "settings": "bun run cli/settings.ts",
-        "disable": "bun run cli/disable.ts",
-        "enable": "bun run cli/install.ts",
-        "uninstall": "bun run cli/uninstall.ts",
+        "server": "bun run adapters/claude/server/index.ts",
+        "pick": "bun run adapters/claude/install/pick.ts",
+        "hunt": "bun run adapters/claude/install/hunt.ts",
+        "install-buddy": "bun run adapters/claude/install/install.ts",
+        "show": "bun run adapters/claude/install/show.ts",
+        "doctor": "bun run adapters/claude/install/doctor.ts",
+        "test-statusline": "bun run adapters/claude/install/test-statusline.ts",
+        "backup": "bun run adapters/claude/install/backup.ts",
+        "settings": "bun run adapters/claude/install/settings.ts",
+        "disable": "bun run adapters/claude/install/disable.ts",
+        "enable": "bun run adapters/claude/install/install.ts",
+        "uninstall": "bun run adapters/claude/install/uninstall.ts",
         "help": "bun run cli/index.ts help",
         "test": "bun test",
         "typecheck": "tsc --noEmit"
     },
     "files": [
-        "server/",
+        "core/",
+        "adapters/",
         "cli/",
-        "skills/",
-        "hooks/",
-        "statusline/",
-        ".claude-plugin/",
         "!**/*.test.ts"
     ],
     "keywords": [
@@ -38,7 +35,8 @@
         "companion",
         "mcp",
         "terminal-pet",
-        "tamagotchi"
+        "tamagotchi",
+        "pi-package"
     ],
     "repository": {
         "type": "git",
@@ -50,7 +48,13 @@
         "access": "public",
         "registry": "https://registry.npmjs.org/"
     },
+    "pi": {
+        "extensions": [
+            "./adapters/pi/index.ts"
+        ]
+    },
     "dependencies": {
+        "@mariozechner/pi-coding-agent": "0.66.1",
         "@modelcontextprotocol/sdk": "^1.12.1"
     },
     "devDependencies": {