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

package/adapters/pi/events.ts

@@ -10,25 +10,30 @@ import type {
 import { isBashToolResult } from "@mariozechner/pi-coding-agent";
 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 { BuddyCommandService, type ReactionResult } from "../../core/command-service.ts";
 import type { Achievement } from "../../core/achievements.ts";
 import type { BuddyTurnCommentModelConfig, Companion } from "../../core/model.ts";
-import { getNameReaction, getSuccessReaction } from "../../core/reactions.ts";
+import { getNameReaction, getSuccessReaction, isNameMentioned } from "../../core/reactions.ts";
 import { PiBuddyStorage } from "./storage.ts";
 import { buildBuddyReactionPrompt, buildBuddyReactionSystemPrompt, normalizeBuddyComment, stripBuddyComments } from "./prompt.ts";
 import { PiBuddyUI } from "./ui.ts";
-import { PiBuddyLogger } from "./logger.ts";
 
+export interface PiBuddyLog {
+  info(event: string, data?: Record<string, unknown>): void;
+  warn(event: string, data?: Record<string, unknown>): void;
+  error(event: string, data?: Record<string, unknown>): void;
+  debug(event: string, data?: Record<string, unknown>): void;
+}
 interface RegisterBuddyEventsDeps {
   service: BuddyCommandService;
   storage: PiBuddyStorage;
   ui: PiBuddyUI;
-  logger: PiBuddyLogger;
+  logger: PiBuddyLog;
 }
 
 export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsDeps): void {
   pi.on("session_start", async (_event: SessionStartEvent, ctx: ExtensionContext) => {
-    const result = deps.service.ensureCompanion();
+    const result = deps.service.startSession();
     deps.logger.info("session_start", {
       companion: result.companion.name,
       species: result.companion.bones.species,
@@ -37,8 +42,8 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
     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);
     }
+    deps.ui.notifyAchievements(ctx, result.achievements);
   });
 
   pi.on("input", async (event: InputEvent, ctx: ExtensionContext): Promise<InputEventResult> => {
@@ -51,15 +56,14 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
     }
 
     const companion = deps.service.ensureCompanion().companion;
-    const pattern = new RegExp(`\\b${escapeRegExp(companion.name)}\\b`, "i");
-    if (!pattern.test(event.text)) {
+    if (!isNameMentioned(event.text, companion.name)) {
       return { action: "continue" };
     }
 
     deps.logger.info("name_mention_detected", {
       companion: companion.name,
       species: companion.bones.species,
-      textPreview: event.text.slice(0, 160),
+      textLength: event.text.length,
     });
 
     const reaction = getNameReaction(companion.bones.species);
@@ -74,44 +78,68 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
       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:
-      | ReturnType<BuddyCommandService["recordToolError"]>
-      | ReturnType<BuddyCommandService["recordTestFailure"]>
-      | ReturnType<BuddyCommandService["recordLargeDiff"]>
-      | ReturnType<BuddyCommandService["recordComment"]>
-      | undefined;
-
+    const canEmit = shouldEmitPassiveReaction(deps.storage);
+    let result: ReactionResult | undefined;
     const companion = deps.service.ensureCompanion().companion;
-    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);
-      } else if (looksLikeSuccess(text)) {
-        result = deps.service.recordComment(getSuccessReaction(companion.bones.species), "turn");
+    if (isBashToolResult(event)) {
+      if (looksLikeTestFailure(text)) {
+        const count = extractFailureCount(text);
+        if (canEmit) {
+          result = deps.service.recordTestFailure(undefined, count);
+        } else {
+          const achievements = deps.service.trackTestFailure(undefined, count);
+          if (achievements.length > 0) { deps.ui.refresh(ctx, companion, deps.storage.loadLatest(), achievements); }
+        }
+      } else if (event.isError) {
+        const line = firstLineNumber(text);
+        if (canEmit) {
+          result = deps.service.recordToolError(undefined, line);
+        } else {
+          const achievements = deps.service.trackToolError(undefined, line);
+          if (achievements.length > 0) { deps.ui.refresh(ctx, companion, deps.storage.loadLatest(), achievements); }
+        }
+      } else {
+        const diffLines = extractLargeDiffLines(text);
+        if (diffLines >= 80) {
+          if (canEmit) {
+            result = deps.service.recordLargeDiff(diffLines);
+          } else {
+            const achievements = deps.service.trackLargeDiff(diffLines);
+            if (achievements.length > 0) { deps.ui.refresh(ctx, companion, deps.storage.loadLatest(), achievements); }
+          }
+        } else if (canEmit && looksLikeSuccess(text)) {
+          result = deps.service.recordComment(getSuccessReaction(companion.bones.species), "turn");
+        }
       }
+    } else if (event.isError) {
+      const line = firstLineNumber(text);
+      if (canEmit) {
+        result = deps.service.recordToolError(undefined, line);
+      } else {
+        const achievements = deps.service.trackToolError(undefined, line);
+        if (achievements.length > 0) { deps.ui.refresh(ctx, companion, deps.storage.loadLatest(), achievements); }
+      }
+    }
+
+    if (!canEmit) {
+      deps.logger.debug("tool_result_skipped", { reason: "cooldown" });
+      return;
     }
 
     if (!result) {
-      deps.logger.debug("tool_result_ignored", {
-        isError: event.isError,
-        textPreview: text.slice(0, 200),
-      });
+      const ignoredData: Record<string, unknown> = { isError: event.isError, textLength: text.length };
+      if (diagnosticPreviewsEnabled()) {
+        ignoredData.textPreview = text.slice(0, 200);
+      }
+      deps.logger.debug("tool_result_ignored", ignoredData);
       return;
     }
     deps.logger.info("tool_result_reaction", {
       reason: result.state.reason,
-      reaction: result.state.reaction,
-      textPreview: text.slice(0, 200),
+      reactionLength: result.state.reaction.length,
+      textLength: text.length,
     });
     deps.ui.refresh(ctx, result.companion, result.state, result.achievements);
     deps.ui.notifyAchievements(ctx, result.achievements);
@@ -125,18 +153,24 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
       return;
     }
 
-    const generated = await generateTurnComment(ctx, progress.companion, event, deps.logger);
+    const generated = await generateTurnComment(
+      ctx,
+      progress.companion,
+      event,
+      deps.logger,
+      complete,
+      deps.storage.loadPiConfig().turnCommentModel,
+    );
     if (!generated.comment) {
-      deps.logger.warn("turn_end_comment_missing", {
-        assistantPreview: isAssistantMessage(event.message) ? getAssistantText(event.message).slice(0, 200) : "",
-      });
+      const assistantLength = isAssistantMessage(event.message) ? getAssistantText(event.message).length : 0;
+      deps.logger.warn("turn_end_comment_missing", { assistantLength });
       deps.ui.refresh(ctx, progress.companion, deps.storage.loadLatest(), progress.achievements);
       return;
     }
 
     deps.logger.info("turn_end_reaction", {
       source: generated.source,
-      reaction: generated.comment,
+      reactionLength: generated.comment.length,
     });
 
     const reaction = deps.service.recordComment(generated.comment, "turn");
@@ -144,6 +178,13 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
     deps.ui.refresh(ctx, reaction.companion, reaction.state, achievements);
     deps.ui.notifyAchievements(ctx, achievements);
   });
+  pi.on("session_shutdown", () => {
+    deps.ui.cancelTimers();
+  });
+}
+function diagnosticPreviewsEnabled(): boolean {
+  const value = process.env.BUDDY_DIAGNOSTIC_PREVIEWS;
+  return value === "1" || value === "true";
 }
 
 function shouldEmitPassiveReaction(storage: PiBuddyStorage): boolean {
@@ -167,8 +208,33 @@ function extractToolText(event: ToolResultEvent): string {
   return "";
 }
 
-function looksLikeTestFailure(text: string): boolean {
-  return /(FAIL|failed|failing|test(s)? failed|not ok)/i.test(text);
+const EXPLICIT_FAILURE_PATTERN = /\b(?:[1-9][0-9]*\s+)?(?:tests?|specs?)\s+(?:failed|failing|did\s+not\s+pass)\b/i;
+
+function hasTestContext(line: string): boolean {
+  return /\b(?:bun\s+test|npm\s+test|yarn\s+test|pnpm\s+test|vitest|jest|mocha|ava|tap|pytest|cargo\s+test|go\s+test|dotnet\s+test|phpunit|rspec|test\s+suite|test\s+runner|tests?\s+(?:passed|failed|ok)|TAP\s*version|1\.\.\d+|#\s+(?:tests|pass|fail|todo|skip|ok))\b/i.test(line);
+}
+
+function isGenericFailureMarker(line: string): boolean {
+  return /^\s*(?:FAIL|not\s+ok|[✗✘×])\s*$/i.test(line) ||
+    /\b[✗✘×]\b/.test(line) ||
+    /(?:^|[\r\n])\s*FAIL(?:\s|$)/i.test(line) ||
+    /\bnot\s+ok\b/i.test(line);
+}
+
+export function looksLikeTestFailure(text: string): boolean {
+  if (EXPLICIT_FAILURE_PATTERN.test(text)) return true;
+
+  const lines = text.split(/\r?\n/);
+  const contextWindow: string[] = [];
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    contextWindow.push(line);
+    if (contextWindow.length > 3) contextWindow.shift();
+    if (isGenericFailureMarker(line) && contextWindow.some((contextLine) => hasTestContext(contextLine))) {
+      return true;
+    }
+  }
+  return false;
 }
 
 function looksLikeSuccess(text: string): boolean {
@@ -198,10 +264,6 @@ function firstLineNumber(text: string): number | undefined {
   return match ? Number(match[1]) : undefined;
 }
 
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 function mergeAchievements(first: Achievement[], second: Achievement[]): Achievement[] {
   const merged = new Map<string, Achievement>();
   for (const achievement of [...first, ...second]) {
@@ -221,11 +283,18 @@ function getAssistantText(message: AssistantMessage): string {
     .join("\n");
 }
 
-async function generateTurnComment(
+type TurnCommentCompleter = (
+  model: Parameters<typeof complete>[0],
+  context: Parameters<typeof complete>[1],
+  options: Parameters<typeof complete>[2],
+) => Promise<AssistantMessage>;
+export async function generateTurnComment(
   ctx: ExtensionContext,
   companion: Companion,
   event: TurnEndEvent,
-  logger: PiBuddyLogger,
+  logger: PiBuddyLog,
+  completeTurnComment: TurnCommentCompleter = complete,
+  modelOverride?: BuddyTurnCommentModelConfig,
 ): Promise<{ comment: string | null; source: "llm" | "fallback" | "none" }> {
   const assistantText = isAssistantMessage(event.message) ? getAssistantText(event.message) : "";
   if (!assistantText.trim()) {
@@ -233,7 +302,7 @@ async function generateTurnComment(
     return { comment: null, source: "none" };
   }
 
-  const turnCommentModel = resolveTurnCommentModel(ctx, logger);
+  const turnCommentModel = resolveTurnCommentModel(ctx, logger, modelOverride);
   if (turnCommentModel) {
     const toolResultsText = getToolResultsText(event);
     const userText = getUserPromptText(ctx);
@@ -242,21 +311,26 @@ async function generateTurnComment(
     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,
+      userTextLength: userText.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 promptDebugData: Record<string, unknown> = {
+      assistantLength: assistantText.length,
+      toolLength: toolResultsText.length,
+      userTextLength: userText.length,
+    };
+    if (diagnosticPreviewsEnabled()) {
+      promptDebugData.systemPromptPreview = systemPrompt.slice(0, 800);
+      promptDebugData.promptPreview = promptText.slice(0, 1200);
+      promptDebugData.userTextPreview = userText.slice(0, 200);
+      promptDebugData.assistantPreview = assistantText.slice(0, 200);
+      promptDebugData.toolPreview = toolResultsText.slice(0, 200);
+    }
+    logger.debug("turn_comment_llm_prompt", promptDebugData);
     const auth = await ctx.modelRegistry.getApiKeyAndHeaders(turnCommentModel);
     logger.debug("turn_comment_auth", {
       ok: auth.ok,
@@ -271,7 +345,7 @@ async function generateTurnComment(
       };
 
       try {
-        const response = await complete(
+        const response = await completeTurnComment(
           turnCommentModel,
           {
             systemPrompt,
@@ -294,14 +368,11 @@ async function generateTurnComment(
             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,
+            normalizedLength: normalized.length,
           });
           if (normalized) return { comment: normalized, source: "llm" };
-          logger.warn("turn_comment_llm_empty", {
-            rawPreview: text.slice(0, 200),
-          });
+          logger.warn("turn_comment_llm_empty", { rawLength: text.length });
         }
       } catch (error) {
         logger.error("turn_comment_llm_error", {
@@ -321,19 +392,23 @@ async function generateTurnComment(
 
   const fallback = deriveTurnComment(companion, event.message);
   logger.warn("turn_comment_fallback", {
-    fallback,
-    assistantPreview: assistantText.slice(0, 200),
+    fallbackLength: fallback?.length ?? 0,
+    assistantLength: assistantText.length,
   });
   return { comment: fallback, source: fallback ? "fallback" : "none" };
 }
 
+export interface PiTurnCommentModelContext {
+  model: ExtensionContext["model"];
+  modelRegistry: Pick<ExtensionContext["modelRegistry"], "find">;
+}
+
 export function resolveTurnCommentModel(
-  ctx: ExtensionContext,
-  logger?: PiBuddyLogger,
+  ctx: PiTurnCommentModelContext,
+  logger?: PiBuddyLog,
   override?: BuddyTurnCommentModelConfig,
-): NonNullable<ExtensionContext["model"]> | null {
-  const configuredOverride = override ?? new PiBuddyStorage().loadPiConfig().turnCommentModel;
-  const activeOverride = configuredOverride;
+): NonNullable<PiTurnCommentModelContext["model"]> | null {
+  const activeOverride = override;
   if (activeOverride?.provider && activeOverride.model) {
     const model = ctx.modelRegistry.find(activeOverride.provider, activeOverride.model);
     if (model) {

package/adapters/pi/index.ts

@@ -5,11 +5,17 @@ import { PiBuddyLogger } from "./logger.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();
+export interface PiBuddyExtensionOptions {
+  stateDir?: string;
+}
+
+export default function registerPiBuddyExtension(
+  pi: ExtensionAPI,
+  options: PiBuddyExtensionOptions = {},
+): void {
+  const storage = new PiBuddyStorage(options.stateDir);
   const identity = new PiIdentityProvider(storage);
   const logger = new PiBuddyLogger(storage);
   const service = new BuddyCommandService({
@@ -23,5 +29,4 @@ export default function registerPiBuddyExtension(pi: ExtensionAPI): void {
 
   registerBuddyCommands(pi, { service, storage, ui });
   registerBuddyEvents(pi, { service, storage, ui, logger });
-  registerBuddyTools(pi);
 }