Merge pull request #14 from nventive/refactor--Replace-console.log

refactor: Enhance logging

Author: MatFillion

CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to the "promptitude" extension will be documented in this file.
 
+## vNext
+
+### Changed
+
+- Enhanced logging and removed console.logs
+
 ## [1.4.0] - 2025-10-03
 
 ### Added

src/extension.ts

@@ -5,17 +5,31 @@ import { ConfigManager } from './configManager';
 import { Logger } from './utils/logger';
 import { AzureDevOpsApiManager } from './utils/azureDevOps';
 
+
 let syncManager: SyncManager;
 let statusBarManager: StatusBarManager;
 let logger: Logger;
 
 export function activate(context: vscode.ExtensionContext) {
-    logger = new Logger();
+    logger = Logger.get('Extension');
     logger.info('Promptitude Extension is activating...');
 
+    // If debugging and a debugger is attached, auto-select the Output channel without stealing focus
+    try {
+        // Dynamically import inspector to avoid bundling issues; optional behavior
+        const inspector = require('inspector');
+        const debuggerAttached = !!inspector.url();
+        if (debuggerAttached) {
+            // Show output channel but preserve focus (don't steal keyboard focus)
+            logger.show(true);
+        }
+    } catch {
+        // Ignore if inspector isn't available
+    }
+
     const configManager = new ConfigManager();
     statusBarManager = new StatusBarManager();
-    syncManager = new SyncManager(configManager, statusBarManager, logger);
+    syncManager = new SyncManager(configManager, statusBarManager);
 
     // Register commands
     const syncNowCommand = vscode.commands.registerCommand('promptitude.syncNow', async () => {
@@ -157,4 +171,5 @@ export function deactivate() {
     logger?.info('Promptitude Extension is deactivating...');
     syncManager?.dispose();
     statusBarManager?.dispose();
+    Logger.disposeSharedChannel();
 }

src/syncManager.ts

@@ -30,7 +30,6 @@ export interface MultiRepositorySyncResult {
 
 export class SyncManager {
     private timer: NodeJS.Timeout | null = null;
-    private isInitialized = false;
     private context: vscode.ExtensionContext | null = null;
     private notifications: NotificationManager;
     private fileSystem: FileSystemManager;
@@ -39,7 +38,7 @@ export class SyncManager {
     constructor(
         private config: ConfigManager,
         private statusBar: StatusBarManager,
-        private logger: Logger
+        private logger: Logger = Logger.get('SyncManager')
     ) {
         this.notifications = new NotificationManager(this.config, undefined, this.logger);
         this.fileSystem = new FileSystemManager();
@@ -69,7 +68,6 @@ export class SyncManager {
 
         // Schedule periodic syncs
         this.scheduleNextSync();
-        this.isInitialized = true;
 
         this.logger.info('SyncManager initialized successfully');
     }
@@ -161,13 +159,14 @@ export class SyncManager {
             // Support more file extensions including .prompt.md
             const isRelevantFile = item.path.endsWith('.md') || 
                                  item.path.endsWith('.txt');
-            
-            this.logger.debug(`  ${item.path}: blob=${isBlob}, matchesPath=${matchesPath}, isRelevantFile=${isRelevantFile} (normalized: ${normalizedPath})`);
-            
+            if(isRelevantFile) {
+                this.logger.debug(`  ${item.path}: blob=${isBlob}, matchesPath=${matchesPath}, (normalized: ${normalizedPath})`);
+            }
+
             return isBlob && matchesPath && isRelevantFile;
         });
 
-        console.log(`Filtered result: ${filtered.length} files out of ${tree.length} total`);
+        this.logger.debug(`Filtered result: ${filtered.length} files out of ${tree.length} total`);
         return filtered;
     }
 
@@ -267,11 +266,6 @@ export class SyncManager {
                 const tree = await gitApi.getRepositoryTree(owner, repo, branch);
                 this.logger.debug(`Retrieved repository tree with ${tree.tree.length} items for ${repoUrl}`);
 
-                // Debug: Log all items in the tree to see what's actually there
-                console.log('Repository tree contents:');
-                tree.tree.forEach((item, index) => {
-                    console.log(`  ${index + 1}. ${item.path} (type: ${item.type})`);
-                });
 
                 // Filter relevant files
                 const relevantFiles = this.filterRelevantFiles(tree.tree);
@@ -509,7 +503,6 @@ export class SyncManager {
             this.timer = null;
         }
 
-        this.isInitialized = false;
         this.logger.info('SyncManager disposed');
     }
 }

src/utils/azureDevOps.ts

@@ -11,12 +11,14 @@ export class AzureDevOpsApiManager implements GitApiManager {
     private static readonly cacheStorageKey = 'promptitude.azureDevOps.patCache';
     private static readonly minPatLength = 8; // Reduced from 20 to be more permissive
     private extensionContext: vscode.ExtensionContext;
+    private logger: Logger;
 
-    constructor(context: vscode.ExtensionContext) {
+    constructor(context: vscode.ExtensionContext, logger: Logger = Logger.get('AzureDevOpsApi')) {
         if (!context) {
             throw new Error('Extension context is required for Azure DevOps authentication');
         }
         this.extensionContext = context;
+        this.logger = logger;
     }
 
     getProviderName(): string {
@@ -258,24 +260,24 @@ export class AzureDevOpsApiManager implements GitApiManager {
             const headers = this.buildAuthHeaders(pats[cachedIndex]);
 
             if (await this.validateHeaders(headers, organization)) {
-                console.log(`[Promptitude] Cache hit: PAT validated for '${organization}'`);
+                this.logger.debug(`Cache hit: PAT validated for '${organization}'`);
                 return headers;
             }
 
             // Cache was stale, remove this entry
-            console.log(`[Promptitude] Cache miss: cached PAT no longer valid for '${organization}'`);
+            this.logger.debug(`Cache miss: cached PAT no longer valid for '${organization}'`);
             delete cache[organization];
             await this.saveCache(cache);
         }
 
         // Try all PATs
-        console.log(`[Promptitude] Trying all PATs (${pats.length} total) for organization '${organization}'`);
+        this.logger.debug(`Trying all PATs (${pats.length} total) for organization '${organization}'`);
         for (let i = 0; i < pats.length; i++) {
-            console.log(`[Promptitude] Attempting PAT ${i + 1}/${pats.length} for organization '${organization}'`);
+            this.logger.debug(`Attempting PAT ${i + 1}/${pats.length} for organization '${organization}'`);
             const headers = this.buildAuthHeaders(pats[i]);
 
             if (await this.validateHeaders(headers, organization)) {
-                console.log(`[Promptitude] Success: a PAT successfully validated for '${organization}', updating cache`);
+                this.logger.debug(`Success: a PAT successfully validated for '${organization}', updating cache`);
                 // Cache successful PAT
                 cache[organization] = i;
                 await this.saveCache(cache);
@@ -320,7 +322,7 @@ export class AzureDevOpsApiManager implements GitApiManager {
 
             return legacyResponse.ok;
         } catch (error) {
-            console.log(`[Promptitude] Validation failed for organization '${organization}': ${error}`);
+            this.logger.debug(`Validation failed for organization '${organization}': ${error}`);
             return false;
         }
     }

src/utils/github.ts

@@ -1,8 +1,14 @@
 import * as vscode from 'vscode';
 import { GitApiManager, GitTree, RepositoryInfo } from './gitProvider';
+import { Logger } from './logger';
 
 export class GitHubApiManager implements GitApiManager {
     private baseUrl = 'https://api.github.com';
+    private logger: Logger;
+
+    constructor(logger: Logger = Logger.get('GitHubApi')) {
+        this.logger = logger;
+    }
 
     getProviderName(): string {
         return 'github';
@@ -51,7 +57,7 @@ export class GitHubApiManager implements GitApiManager {
         if (!session) {
             throw new Error('GitHub authentication required');
         }
-        console.log(`Fetching file content from ${owner}/${repo}/${path} on branch ${branch}`);
+        this.logger.debug(`Fetching file content from ${owner}/${repo}/${path} on branch ${branch}`);
         const response = await fetch(`${this.baseUrl}/repos/${owner}/${repo}/contents/${path}?ref=${branch}`, {
             headers: {
                 ['Authorization']: `Bearer ${session.accessToken}`,

src/utils/logger.ts

@@ -1,24 +1,54 @@
 import * as vscode from 'vscode';
 
 export class Logger {
-    private outputChannel: vscode.OutputChannel;
+    // Use a single shared OutputChannel across all Logger instances
+    private static sharedChannel: vscode.OutputChannel | undefined;
+    private static scopedCache: Map<string, Logger> = new Map();
+    private scope?: string;
+    private get outputChannel(): vscode.OutputChannel {
+        if (!Logger.sharedChannel) {
+            Logger.sharedChannel = vscode.window.createOutputChannel('Promptitude');
+        }
+        return Logger.sharedChannel;
+    }
+
+    constructor(scope?: string) {
+        this.scope = scope;
+    }
 
-    constructor() {
-        this.outputChannel = vscode.window.createOutputChannel('Promptitude');
+    static get(scope: string): Logger {
+        const existing = Logger.scopedCache.get(scope);
+        if (existing) {
+            return existing;
+        }
+        const logger = new Logger(scope);
+        Logger.scopedCache.set(scope, logger);
+        return logger;
     }
 
     private get isDebugEnabled(): boolean {
         return vscode.workspace.getConfiguration('promptitude').get('debug', false);
     }
 
     private log(level: string, message: string): void {
-        const timestamp = new Date().toISOString();
-        const logMessage = `[${timestamp}] [${level}] ${message}`;
+        const timestamp = this.formatTimestamp(new Date());
+        const scoped = this.scope ? `[${this.scope}] ${message}` : message;
+        const logMessage = `[${timestamp}] [${level}] ${scoped}`;
 
         this.outputChannel.appendLine(logMessage);
-        
-        // Also log to console for debugging
-        console.log(`Promptitude: ${logMessage}`);
+    }
+
+    private formatTimestamp(date: Date): string {
+        const pad = (n: number, width: number = 2) => n.toString().padStart(width, '0');
+        const year = date.getFullYear();
+        const month = pad(date.getMonth() + 1);
+        const day = pad(date.getDate());
+        const hours = pad(date.getHours());
+        const minutes = pad(date.getMinutes());
+        const seconds = pad(date.getSeconds());
+        const millis = pad(date.getMilliseconds(), 3);
+        // Format: 2025-10-08 01:16:21.132 (local time)
+        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${millis}`;
     }
 
     debug(message: string): void {
@@ -46,11 +76,13 @@ export class Logger {
         this.log('ERROR', errorMessage);
     }
 
-    show(): void {
-        this.outputChannel.show();
+    show(preserveFocus: boolean = false): void {
+        this.outputChannel.show(preserveFocus);
     }
 
-    dispose(): void {
-        this.outputChannel.dispose();
+    static disposeSharedChannel(): void {
+        Logger.sharedChannel?.dispose();
+        Logger.sharedChannel = undefined;
+        Logger.scopedCache.clear();
     }
 }