refactor(logging): replace sendToOutput with structured logger

Introduce a new Logger class using VS Code's LogOutputChannel for structured logging with trace, debug, info, warn, and error levels. Update all service files to use the logger instance instead of the deprecated sendToOutput function, improving debugging and respecting log level settings. Maintain backward compatibility with deprecated exports.

Author: Hi7cl4w

src/Diffy.ts

@@ -10,7 +10,7 @@ import OpenAiService from "./service/OpenAiService";
 import VsCodeLlmService from "./service/VsCodeLlmService";
 import WindowService from "./service/WindowService";
 import WorkspaceService from "./service/WorkspaceService";
-import { sendToOutput } from "./utils/log";
+import { logger } from "./utils/log";
 
 class Diffy extends BaseDiffy {
   static _instance: Diffy;
@@ -42,7 +42,7 @@ class Diffy extends BaseDiffy {
       this.onWorkSpaceChanged();
     });
     this.isEnabled = true;
-    sendToOutput("initiated");
+    logger.info("Diffy extension initialized");
   }
 
   /**
@@ -128,7 +128,7 @@ class Diffy extends BaseDiffy {
       const codebaseContext = await this.getCodebaseIndexService().getCodebaseContext();
 
       if (codebaseContext) {
-        sendToOutput(`Adding codebase context (${strategy} mode) to prompt`);
+        logger.info("Adding codebase context to prompt", { strategy });
 
         // If using structured mode, also analyze the diff
         if (strategy === "structured") {
@@ -143,7 +143,7 @@ class Diffy extends BaseDiffy {
         return `${codebaseContext}\n\nDIFF:\n${diff}`;
       }
     } catch (error) {
-      sendToOutput(`Error getting codebase context: ${error}`);
+      logger.error("Error getting codebase context", error);
     }
 
     return diff;

src/service/CodebaseIndexService.ts

@@ -1,6 +1,6 @@
 import { countTokens } from "gpt-tokenizer";
 import * as vscode from "vscode";
-import { sendToOutput } from "../utils/log";
+import { logger } from "../utils/log";
 import WorkspaceService from "./WorkspaceService";
 
 interface IndexedFileContent {
@@ -286,7 +286,7 @@ export default class CodebaseIndexService {
 
     const workspaceFolder = workspaceService.getCurrentWorkspace();
     if (!workspaceFolder) {
-      sendToOutput("No workspace folder found for codebase indexing");
+      logger.info("No workspace folder found for codebase indexing");
       return null;
     }
 
@@ -298,19 +298,17 @@ export default class CodebaseIndexService {
     // Auto-detect project files if indexedFiles is empty or includes "auto"
     if (!indexedFiles || indexedFiles.length === 0 || indexedFiles.includes("auto")) {
       const autoDetected = await this.autoDetectProjectFiles(workspaceFolder);
-      sendToOutput(
-        `Auto-detected ${autoDetected.length} project files: ${autoDetected.join(", ")}`,
-      );
+      logger.info(`Auto-detected ${autoDetected.length} project files: ${autoDetected.join(", ")}`);
       indexedFiles = autoDetected;
     }
 
     if (indexedFiles.length === 0) {
-      sendToOutput("No files configured for indexing");
+      logger.info("No files configured for indexing");
       return null;
     }
 
-    sendToOutput(`Starting smart codebase indexing with max file size: ${maxFileSizeKB}KB`);
-    sendToOutput(`Files to index: ${indexedFiles.join(", ")}`);
+    logger.info(`Starting smart codebase indexing with max file size: ${maxFileSizeKB}KB`);
+    logger.info(`Files to index: ${indexedFiles.join(", ")}`);
 
     const indexedContent: IndexedFileContent[] = [];
     let totalTokens = 0;
@@ -341,7 +339,7 @@ export default class CodebaseIndexService {
           if (cached && totalTokens + cached.tokens <= maxTotalTokens) {
             indexedContent.push(cached);
             totalTokens += cached.tokens;
-            sendToOutput(`Using cached ${filePattern}: ${cached.tokens} tokens`);
+            logger.info(`Using cached ${filePattern}: ${cached.tokens} tokens`);
             continue;
           }
         }
@@ -352,7 +350,7 @@ export default class CodebaseIndexService {
 
           // Skip if file is too large
           if (fileStat.size > maxFileSizeBytes) {
-            sendToOutput(
+            logger.info(
               `Skipping ${filePattern}: file size ${(fileStat.size / this.KB_TO_BYTES).toFixed(
                 1,
               )}KB exceeds limit of ${maxFileSizeKB}KB`,
@@ -372,7 +370,7 @@ export default class CodebaseIndexService {
 
           // Check if adding this file would exceed total token budget
           if (totalTokens + tokenCount > maxTotalTokens) {
-            sendToOutput(
+            logger.info(
               `Skipping ${filePattern}: would exceed total token budget (${
                 totalTokens + tokenCount
               } > ${maxTotalTokens})`,
@@ -391,18 +389,18 @@ export default class CodebaseIndexService {
           this.cache.set(filePattern, indexedItem);
 
           totalTokens += tokenCount;
-          sendToOutput(`Indexed ${filePattern}: ${tokenCount} tokens (analyzed)`);
+          logger.info(`Indexed ${filePattern}: ${tokenCount} tokens (analyzed)`);
         } catch {
           // File doesn't exist, skip silently
-          sendToOutput(`File not found: ${filePattern}`);
+          logger.info(`File not found: ${filePattern}`);
         }
       } catch (error) {
-        sendToOutput(`Error reading ${filePattern}: ${error}`);
+        logger.info(`Error reading ${filePattern}: ${error}`);
       }
     }
 
     if (indexedContent.length === 0) {
-      sendToOutput("No files were successfully indexed");
+      logger.info("No files were successfully indexed");
       return null;
     }
 
@@ -435,7 +433,11 @@ export default class CodebaseIndexService {
             strategy: "structured",
           },
         };
-        formattedContext = `CODEBASE CONTEXT (Structured):\n${JSON.stringify(structuredData, null, 2)}`;
+        formattedContext = `CODEBASE CONTEXT (Structured):\n${JSON.stringify(
+          structuredData,
+          null,
+          2,
+        )}`;
         break;
       }
 
@@ -447,15 +449,15 @@ export default class CodebaseIndexService {
           return `${item.file}: ${item.content} [${item.tokens} tokens]`;
         });
         formattedContext = `CODEBASE (AST-Enhanced):\n${astLines.join("\n")}`;
-        sendToOutput("AST-based indexing: Full implementation pending. Using enhanced format.");
+        logger.info("AST-based indexing: Full implementation pending. Using enhanced format.");
         break;
       }
 
       default:
         formattedContext = `PROJECT: ${indexedContent.map((i) => i.content).join(" • ")}`;
     }
 
-    sendToOutput(
+    logger.info(
       `Indexed [${strategy}]: ${indexedContent.length} files, ${totalTokens} tokens (${this.cache.size} cached)`,
     );
 
@@ -467,6 +469,6 @@ export default class CodebaseIndexService {
    */
   public clearCache(): void {
     this.cache.clear();
-    sendToOutput("Codebase index cache cleared");
+    logger.info("Codebase index cache cleared");
   }
 }

src/service/DiffAnalyzer.ts

@@ -1,4 +1,4 @@
-import { sendToOutput } from "../utils/log";
+import { logger } from "../utils/log";
 
 /**
  * Structured representation of a file change
@@ -56,7 +56,7 @@ export default class DiffAnalyzer {
    * @returns Structured diff context
    */
   async analyzeGitDiff(diff: string): Promise<DiffContext> {
-    sendToOutput("Starting structured diff analysis");
+    logger.info("Starting structured diff analysis");
 
     const files: FileChange[] = [];
     const affectedModules = new Set<string>();
@@ -112,7 +112,7 @@ export default class DiffAnalyzer {
       },
     };
 
-    sendToOutput(`Analyzed ${files.length} files: +${totalAdditions} -${totalDeletions}`);
+    logger.info(`Analyzed ${files.length} files: +${totalAdditions} -${totalDeletions}`);
 
     return context;
   }

src/service/GeminiService.ts

@@ -2,7 +2,7 @@ import { GoogleGenAI } from "@google/genai";
 import type * as vscode from "vscode";
 import { window } from "vscode";
 import { cleanAiResponse } from "../utils/aiResponse";
-import { clearOutput, sendToOutput } from "../utils/log";
+import { logger } from "../utils/log";
 import { CacheService } from "./CacheService";
 import WorkspaceService from "./WorkspaceService";
 
@@ -84,18 +84,20 @@ class GeminiService implements AIService {
 
     if (exist) {
       const result = this.cacheService.get(model, instructions + prompt) as string;
-      sendToOutput(`result: ${JSON.stringify(result)}`);
+      logger.debug("Gemini cache hit", { model });
       return result;
     }
 
     progress?.report({ increment: 50 });
 
-    clearOutput();
-    sendToOutput(`instructions: ${instructions}`);
-    sendToOutput(`git diff prompt: ${prompt}`);
-    sendToOutput(`model: ${model}`);
-    sendToOutput(`temperature: ${WorkspaceService.getInstance().getTemp()}`);
-    sendToOutput(`max_tokens: ${WorkspaceService.getInstance().getMaxTokens()}`);
+    logger.clear();
+    logger.info("Gemini request", {
+      model,
+      temperature: WorkspaceService.getInstance().getTemp(),
+      maxTokens: WorkspaceService.getInstance().getMaxTokens(),
+    });
+    logger.trace("System instructions", instructions);
+    logger.trace("User prompt", prompt);
 
     let response: string | undefined;
     try {
@@ -118,11 +120,12 @@ class GeminiService implements AIService {
       });
 
       response = result.text;
-      sendToOutput(`result success: ${JSON.stringify(response)}`);
+      logger.info("Gemini response received");
+      logger.debug("Gemini full response", response);
       progress?.report({ increment: 49 });
     } catch (reason: unknown) {
+      logger.error("Gemini request failed", reason);
       console.error(reason);
-      sendToOutput(`result failed: ${JSON.stringify(reason)}`);
 
       const hasResponse = (
         err: unknown,

src/service/OpenAiService.ts

@@ -2,7 +2,7 @@ import OpenAI from "openai";
 import type * as vscode from "vscode";
 import { window } from "vscode";
 import { cleanAiResponse } from "../utils/aiResponse";
-import { clearOutput, sendToOutput } from "../utils/log";
+import { logger } from "../utils/log";
 import { CacheService } from "./CacheService";
 import WorkspaceService from "./WorkspaceService";
 
@@ -106,7 +106,7 @@ class OpenAiService implements AIService {
         model,
         instructions + prompt,
       ) as OpenAI.Chat.Completions.ChatCompletion;
-      sendToOutput(`result: ${JSON.stringify(result)}`);
+      logger.debug("OpenAI cache hit", { model });
       return result;
     }
     if (!openAIKey) {
@@ -136,22 +136,28 @@ class OpenAiService implements AIService {
       temperature: WorkspaceService.getInstance().getTemp(),
       max_tokens: WorkspaceService.getInstance().getMaxTokens(),
     };
-    clearOutput();
-    sendToOutput(`instructions: ${instructions}`);
-    sendToOutput(`git diff prompt: ${prompt}`);
-    sendToOutput(`base url: ${openAiClient.baseURL}`);
-    sendToOutput(`model: ${params.model}`);
-    sendToOutput(`max_tokens: ${params.max_tokens}`);
-    sendToOutput(`temperature: ${params.temperature}`);
+    logger.clear();
+    logger.info("OpenAI request", {
+      baseUrl: openAiClient.baseURL,
+      model: params.model,
+      maxTokens: params.max_tokens,
+      temperature: params.temperature,
+    });
+    logger.trace("System instructions", instructions);
+    logger.trace("User prompt", prompt);
 
     let response: OpenAI.Chat.Completions.ChatCompletion | undefined;
     try {
       response = await openAiClient.chat.completions.create(params);
-      sendToOutput(`result success: ${JSON.stringify(response)}`);
+      logger.info("OpenAI response received", {
+        usage: response.usage,
+        model: response.model,
+      });
+      logger.debug("OpenAI full response", response);
       progress?.report({ increment: 49 });
     } catch (reason: unknown) {
+      logger.error("OpenAI request failed", reason);
       console.error(reason);
-      sendToOutput(`result failed: ${JSON.stringify(reason)}`);
 
       // Type guard for error with response property
       const hasResponse = (

src/service/VsCodeLlmService.ts

@@ -1,7 +1,7 @@
 import * as vscode from "vscode";
 import { window } from "vscode";
 import { cleanAiResponse } from "../utils/aiResponse";
-import { clearOutput, sendToOutput } from "../utils/log";
+import { logger } from "../utils/log";
 import { CacheService } from "./CacheService";
 import WorkspaceService from "./WorkspaceService";
 
@@ -89,15 +89,15 @@ class VsCodeLlmService implements AIService {
     const exist = this.cacheService.recordExists(vscodeLmModel, cacheKey);
     if (exist) {
       const result = this.cacheService.get(vscodeLmModel, cacheKey) as string;
-      sendToOutput(`result (cached): ${result}`);
+      logger.debug("VS Code LLM cache hit", { model: vscodeLmModel });
       return result;
     }
 
     try {
-      clearOutput();
-      sendToOutput(`instructions: ${instructions}`);
-      sendToOutput(`git diff prompt: ${prompt}`);
-      sendToOutput(`model: ${vscodeLmModel}`);
+      logger.clear();
+      logger.info("VS Code LLM request", { model: vscodeLmModel });
+      logger.trace("System instructions", instructions);
+      logger.trace("User prompt", prompt);
 
       // Select the appropriate model based on settings
       let models: vscode.LanguageModelChat[] = [];
@@ -277,7 +277,11 @@ class VsCodeLlmService implements AIService {
       }
 
       const [model] = models;
-      sendToOutput(`Selected model: ${model.id} (${model.vendor}/${model.family})`);
+      logger.info("Selected VS Code LLM model", {
+        id: model.id,
+        vendor: model.vendor,
+        family: model.family,
+      });
 
       progress?.report({ increment: 30 });
 
@@ -299,7 +303,10 @@ class VsCodeLlmService implements AIService {
         responseText += fragment;
       }
 
-      sendToOutput(`result success: ${responseText}`);
+      logger.info("VS Code LLM response received", {
+        responseLength: responseText.length,
+      });
+      logger.debug("VS Code LLM full response", responseText);
 
       // Cache the result
       if (responseText && responseText.length > 6) {
@@ -315,8 +322,8 @@ class VsCodeLlmService implements AIService {
 
       return responseText;
     } catch (error: unknown) {
+      logger.error("VS Code LLM request failed", error);
       console.error(error);
-      sendToOutput(`result failed: ${JSON.stringify(error)}`);
 
       if (error instanceof vscode.LanguageModelError) {
         // Handle specific LLM errors