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

package/adapters/pi/events.ts

@@ -12,21 +12,28 @@ import type { AgentMessage } from "@mariozechner/pi-agent-core";
 import { complete, type AssistantMessage, type TextContent, type UserMessage } from "@mariozechner/pi-ai";
 import { BuddyCommandService } from "../../core/command-service.ts";
 import type { Achievement } from "../../core/achievements.ts";
-import type { Companion } from "../../core/model.ts";
+import type { BuddyTurnCommentModelConfig, Companion } from "../../core/model.ts";
 import { getNameReaction, getSuccessReaction } from "../../core/reactions.ts";
 import { PiBuddyStorage } from "./storage.ts";
-import { buildBuddyReactionPrompt, normalizeBuddyComment, stripBuddyComments } from "./prompt.ts";
+import { buildBuddyReactionPrompt, buildBuddyReactionSystemPrompt, normalizeBuddyComment, stripBuddyComments } from "./prompt.ts";
 import { PiBuddyUI } from "./ui.ts";
+import { PiBuddyLogger } from "./logger.ts";
 
 interface RegisterBuddyEventsDeps {
   service: BuddyCommandService;
   storage: PiBuddyStorage;
   ui: PiBuddyUI;
+  logger: PiBuddyLogger;
 }
 
 export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsDeps): void {
   pi.on("session_start", async (_event: SessionStartEvent, ctx: ExtensionContext) => {
     const result = deps.service.ensureCompanion();
+    deps.logger.info("session_start", {
+      companion: result.companion.name,
+      species: result.companion.bones.species,
+      created: result.created,
+    });
     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");
@@ -36,6 +43,10 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
 
   pi.on("input", async (event: InputEvent, ctx: ExtensionContext): Promise<InputEventResult> => {
     if (event.source === "extension" || deps.storage.isMuted()) {
+      deps.logger.debug("input_skipped", {
+        source: event.source,
+        muted: deps.storage.isMuted(),
+      });
       return { action: "continue" };
     }
 
@@ -45,6 +56,12 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
       return { action: "continue" };
     }
 
+    deps.logger.info("name_mention_detected", {
+      companion: companion.name,
+      species: companion.bones.species,
+      textPreview: event.text.slice(0, 160),
+    });
+
     const reaction = getNameReaction(companion.bones.species);
     const result = deps.service.recordComment(reaction, "turn");
     deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
@@ -53,7 +70,14 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
   });
 
   pi.on("tool_result", async (event: ToolResultEvent, ctx: ExtensionContext) => {
-    if (deps.storage.isMuted() || !shouldEmitPassiveReaction(deps.storage)) return;
+    if (deps.storage.isMuted()) {
+      deps.logger.debug("tool_result_skipped", { reason: "muted" });
+      return;
+    }
+    if (!shouldEmitPassiveReaction(deps.storage)) {
+      deps.logger.debug("tool_result_skipped", { reason: "cooldown" });
+      return;
+    }
 
     const text = extractToolText(event);
     let result:
@@ -77,7 +101,18 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
       }
     }
 
-    if (!result) return;
+    if (!result) {
+      deps.logger.debug("tool_result_ignored", {
+        isError: event.isError,
+        textPreview: text.slice(0, 200),
+      });
+      return;
+    }
+    deps.logger.info("tool_result_reaction", {
+      reason: result.state.reason,
+      reaction: result.state.reaction,
+      textPreview: text.slice(0, 200),
+    });
     deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
     deps.ui.notifyAchievements(ctx, result.achievements);
   });
@@ -85,17 +120,26 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
   pi.on("turn_end", async (event: TurnEndEvent, ctx: ExtensionContext) => {
     const progress = deps.service.recordTurnOnly();
     if (deps.storage.isMuted()) {
+      deps.logger.debug("turn_end_skipped", { reason: "muted" });
       deps.ui.refresh(ctx, progress.companion, null, progress.achievements);
       return;
     }
 
-    const comment = await generateTurnComment(ctx, progress.companion, event);
-    if (!comment) {
+    const generated = await generateTurnComment(ctx, progress.companion, event, deps.logger);
+    if (!generated.comment) {
+      deps.logger.warn("turn_end_comment_missing", {
+        assistantPreview: isAssistantMessage(event.message) ? getAssistantText(event.message).slice(0, 200) : "",
+      });
       deps.ui.refresh(ctx, progress.companion, deps.storage.loadLatest(), progress.achievements);
       return;
     }
 
-    const reaction = deps.service.recordComment(comment, "turn");
+    deps.logger.info("turn_end_reaction", {
+      source: generated.source,
+      reaction: generated.comment,
+    });
+
+    const reaction = deps.service.recordComment(generated.comment, "turn");
     const achievements = mergeAchievements(progress.achievements, reaction.achievements);
     deps.ui.refresh(ctx, reaction.companion, reaction.state, achievements);
     deps.ui.notifyAchievements(ctx, achievements);
@@ -181,27 +225,61 @@ async function generateTurnComment(
   ctx: ExtensionContext,
   companion: Companion,
   event: TurnEndEvent,
-): Promise<string | null> {
+  logger: PiBuddyLogger,
+): Promise<{ comment: string | null; source: "llm" | "fallback" | "none" }> {
   const assistantText = isAssistantMessage(event.message) ? getAssistantText(event.message) : "";
-  if (!assistantText.trim()) return null;
+  if (!assistantText.trim()) {
+    logger.warn("turn_comment_skipped", { reason: "empty_assistant_text" });
+    return { comment: null, source: "none" };
+  }
 
-  if (ctx.model) {
-    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
+  const turnCommentModel = resolveTurnCommentModel(ctx, logger);
+  if (turnCommentModel) {
+    const toolResultsText = getToolResultsText(event);
+    const userText = getUserPromptText(ctx);
+    const systemPrompt = buildBuddyReactionSystemPrompt(companion);
+    const promptText = buildBuddyReactionPrompt(companion, assistantText, toolResultsText, userText);
+    logger.info("turn_comment_llm_attempt", {
+      modelProvider: turnCommentModel.provider,
+      modelId: turnCommentModel.id,
+      assistantPreview: assistantText.slice(0, 200),
+      toolPreview: toolResultsText.slice(0, 200),
+      assistantLength: assistantText.length,
+      toolLength: toolResultsText.length,
+      promptLength: promptText.length,
+      systemPromptLength: systemPrompt.length,
+      toolResultCount: event.toolResults.length,
+    });
+    logger.debug("turn_comment_llm_prompt", {
+      systemPromptPreview: systemPrompt.slice(0, 800),
+      promptPreview: promptText.slice(0, 1200),
+      userText,
+      assistantText,
+      toolResultsText,
+    });
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(turnCommentModel);
+    logger.debug("turn_comment_auth", {
+      ok: auth.ok,
+      hasApiKey: auth.ok ? !!auth.apiKey : false,
+      headerKeys: auth.ok ? Object.keys(auth.headers ?? {}) : [],
+    });
     if (auth.ok && auth.apiKey) {
       const userMessage: UserMessage = {
         role: "user",
-        content: [{ type: "text", text: buildBuddyReactionPrompt(companion, assistantText, getToolResultsText(event)) }],
+        content: [{ type: "text", text: promptText }],
         timestamp: Date.now(),
       };
 
       try {
         const response = await complete(
-          ctx.model,
-          { messages: [userMessage] },
+          turnCommentModel,
+          {
+            systemPrompt,
+            messages: [userMessage],
+          },
           {
             apiKey: auth.apiKey,
             headers: auth.headers,
-            signal: ctx.signal,
           },
         );
 
@@ -211,15 +289,78 @@ async function generateTurnComment(
             .map((block) => block.text)
             .join("\n");
           const normalized = normalizeBuddyComment(text);
-          if (normalized) return normalized;
+          logger.info("turn_comment_llm_result", {
+            stopReason: response.stopReason,
+            errorMessage: "errorMessage" in response ? (response as { errorMessage?: string }).errorMessage : undefined,
+            contentTypes: response.content.map((block) => block.type),
+            contentCount: response.content.length,
+            rawPreview: text.slice(0, 200),
+            rawLength: text.length,
+            normalized,
+          });
+          if (normalized) return { comment: normalized, source: "llm" };
+          logger.warn("turn_comment_llm_empty", {
+            rawPreview: text.slice(0, 200),
+          });
         }
-      } catch {
-        // Fall through to heuristic fallback.
+      } catch (error) {
+        logger.error("turn_comment_llm_error", {
+          message: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined,
+        });
       }
+    } else {
+      logger.warn("turn_comment_auth_unavailable", {
+        ok: auth.ok,
+        message: auth.ok ? "missing api key" : auth.error,
+      });
+    }
+  } else {
+    logger.warn("turn_comment_llm_skipped", { reason: "no_model" });
+  }
+
+  const fallback = deriveTurnComment(companion, event.message);
+  logger.warn("turn_comment_fallback", {
+    fallback,
+    assistantPreview: assistantText.slice(0, 200),
+  });
+  return { comment: fallback, source: fallback ? "fallback" : "none" };
+}
+
+export function resolveTurnCommentModel(
+  ctx: ExtensionContext,
+  logger?: PiBuddyLogger,
+  override?: BuddyTurnCommentModelConfig,
+): NonNullable<ExtensionContext["model"]> | null {
+  const configuredOverride = override ?? new PiBuddyStorage().loadPiConfig().turnCommentModel;
+  const activeOverride = configuredOverride;
+  if (activeOverride?.provider && activeOverride.model) {
+    const model = ctx.modelRegistry.find(activeOverride.provider, activeOverride.model);
+    if (model) {
+      logger?.debug("turn_comment_model_selected", {
+        source: "config",
+        provider: model.provider,
+        model: model.id,
+      });
+      return model;
     }
+    logger?.warn("turn_comment_model_missing", {
+      source: "config",
+      provider: activeOverride.provider,
+      model: activeOverride.model,
+    });
   }
 
-  return deriveTurnComment(companion, event.message);
+  if (ctx.model) {
+    logger?.debug("turn_comment_model_selected", {
+      source: "session",
+      provider: ctx.model.provider,
+      model: ctx.model.id,
+    });
+    return ctx.model;
+  }
+
+  return null;
 }
 
 function getToolResultsText(event: TurnEndEvent): string {
@@ -233,6 +374,22 @@ function getToolResultsText(event: TurnEndEvent): string {
     .slice(0, 4000);
 }
 
+function getUserPromptText(ctx: ExtensionContext): string {
+  const branch = ctx.sessionManager.getBranch();
+  for (let i = branch.length - 1; i >= 0; i--) {
+    const entry = branch[i];
+    if (entry.type !== "message") continue;
+    const message = entry.message;
+    if (message.role !== "user" || !Array.isArray(message.content)) continue;
+    return message.content
+      .filter((block): block is TextContent => block.type === "text")
+      .map((block) => block.text)
+      .join("\n")
+      .slice(0, 4000);
+  }
+  return "";
+}
+
 export function deriveTurnComment(companion: Companion, message: AgentMessage): string | null {
   if (!isAssistantMessage(message)) return null;
 

package/adapters/pi/index.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { BuddyCommandService } from "../../core/command-service.ts";
 import { PiIdentityProvider } from "./identity.ts";
+import { PiBuddyLogger } from "./logger.ts";
 import { registerBuddyCommands } from "./commands.ts";
 import { registerBuddyEvents } from "./events.ts";
 import { PiBuddyStorage } from "./storage.ts";
@@ -10,6 +11,7 @@ import { PiBuddyUI } from "./ui.ts";
 export default function registerPiBuddyExtension(pi: ExtensionAPI): void {
   const storage = new PiBuddyStorage();
   const identity = new PiIdentityProvider(storage);
+  const logger = new PiBuddyLogger(storage);
   const service = new BuddyCommandService({
     identity,
     buddies: storage,
@@ -20,6 +22,6 @@ export default function registerPiBuddyExtension(pi: ExtensionAPI): void {
   const ui = new PiBuddyUI(storage);
 
   registerBuddyCommands(pi, { service, storage, ui });
-  registerBuddyEvents(pi, { service, storage, ui });
+  registerBuddyEvents(pi, { service, storage, ui, logger });
   registerBuddyTools(pi);
 }

package/adapters/pi/logger.ts

@@ -0,0 +1,52 @@
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import pino, { type Logger } from "pino";
+import { PiBuddyStorage } from "./storage.ts";
+
+function resolveLogLevel(): pino.LevelWithSilent {
+  const level = (process.env.PI_BUDDY_LOG_LEVEL
+    ?? process.env.CODING_BUDDY_LOG_LEVEL
+    ?? "info").toLowerCase();
+
+  if (["fatal", "error", "warn", "info", "debug", "trace", "silent"].includes(level)) {
+    return level as pino.LevelWithSilent;
+  }
+
+  return "info";
+}
+
+export class PiBuddyLogger {
+  readonly filePath: string;
+  readonly logger: Logger;
+
+  constructor(storage: PiBuddyStorage) {
+    const logDir = join(storage.stateDir, "logs");
+    mkdirSync(logDir, { recursive: true });
+    this.filePath = join(logDir, "buddy.log");
+    this.logger = pino(
+      {
+        name: "pi-buddy",
+        level: resolveLogLevel(),
+        base: undefined,
+        timestamp: pino.stdTimeFunctions.isoTime,
+      },
+      pino.destination({ dest: this.filePath, append: true, mkdir: true, sync: true }),
+    );
+  }
+
+  info(event: string, data: Record<string, unknown> = {}): void {
+    this.logger.info({ event, ...data });
+  }
+
+  warn(event: string, data: Record<string, unknown> = {}): void {
+    this.logger.warn({ event, ...data });
+  }
+
+  error(event: string, data: Record<string, unknown> = {}): void {
+    this.logger.error({ event, ...data });
+  }
+
+  debug(event: string, data: Record<string, unknown> = {}): void {
+    this.logger.debug({ event, ...data });
+  }
+}

package/adapters/pi/prompt.ts

@@ -1,9 +1,24 @@
 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}.`,
@@ -18,6 +33,9 @@ export function buildBuddyReactionPrompt(
     "- 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)",
     "",

package/adapters/pi/storage.ts

@@ -60,6 +60,7 @@ const DEFAULT_CONFIG: PiBuddyConfig = {
   bubblePosition: "top",
   showRarity: true,
   statusLineEnabled: true,
+  turnCommentModel: undefined,
   muted: false,
 };