protoagent 0.0.2 → 0.0.3

package/dist/config/client.js

@@ -4,28 +4,47 @@
 import OpenAI from 'openai';
 import { geminiProvider, cerebrasProvider, getModelConfig } from './providers.js';
 import { estimateTokens, getContextInfo } from '../utils/cost-tracker.js';
+import { logger } from '../utils/logger.js';
 /**
  * Create OpenAI client from configuration
  */
 export function createOpenAIClient(config) {
+    logger.debug('🤖 Creating OpenAI client', {
+        component: 'OpenAIClient',
+        provider: config.provider,
+        model: config.model
+    });
     if (config.provider === 'openai') {
+        logger.debug('🔑 Using OpenAI provider', { component: 'OpenAIClient' });
         return new OpenAI({
             apiKey: config.credentials.OPENAI_API_KEY
         });
     }
     if (config.provider === 'gemini') {
+        logger.debug('🔑 Using Gemini provider', {
+            component: 'OpenAIClient',
+            baseURL: geminiProvider.baseURL
+        });
         return new OpenAI({
             apiKey: config.credentials.GEMINI_API_KEY,
             baseURL: geminiProvider.baseURL
         });
     }
     if (config.provider === 'cerebras') {
+        logger.debug('🔑 Using Cerebras provider', {
+            component: 'OpenAIClient',
+            baseURL: cerebrasProvider.baseURL
+        });
         return new OpenAI({
             apiKey: config.credentials.CEREBRAS_API_KEY,
             baseURL: cerebrasProvider.baseURL
         });
     }
-    throw new Error(`Unsupported provider: ${config.provider}`);
+    logger.error('❌ Unknown provider', {
+        component: 'OpenAIClient',
+        provider: config.provider
+    });
+    throw new Error(`Unknown provider: ${config.provider}`);
 }
 /**
  * Sleep for a given number of milliseconds
@@ -37,12 +56,22 @@ function sleep(ms) {
  * Check if an error is retryable
  */
 function isRetryableError(error) {
+    logger.debug('🔍 Checking if error is retryable', {
+        component: 'OpenAIClient',
+        status: error?.status,
+        code: error?.code
+    });
     // Check for rate limiting (429)
     if (error?.status === 429) {
+        logger.debug('⏳ Error is rate limit (429)', { component: 'OpenAIClient' });
         return true;
     }
     // Check for server errors (5xx)
     if (error?.status >= 500 && error?.status < 600) {
+        logger.debug('🔧 Error is server error (5xx)', {
+            component: 'OpenAIClient',
+            status: error.status
+        });
         return true;
     }
     // Check for network/connection errors
@@ -51,25 +80,50 @@ function isRetryableError(error) {
         error?.code === 'ECONNREFUSED' ||
         error?.message?.includes('network') ||
         error?.message?.includes('timeout')) {
+        logger.debug('🌐 Error is network related', {
+            component: 'OpenAIClient',
+            code: error.code,
+            message: error.message
+        });
         return true;
     }
+    logger.debug('❌ Error is not retryable', { component: 'OpenAIClient' });
     return false;
 }
 /**
  * Get appropriate delay for rate limiting based on error
  */
 function getRateLimitDelay(error, attempt) {
+    logger.debug('⏱️ Calculating rate limit delay', {
+        component: 'OpenAIClient',
+        attempt,
+        retryAfterHeader: error?.headers?.['retry-after']
+    });
     // Check for Retry-After header (OpenAI provides this for rate limits)
     if (error?.headers?.['retry-after']) {
         const retryAfter = parseInt(error.headers['retry-after'], 10);
         if (!isNaN(retryAfter)) {
-            return retryAfter * 1000; // Convert to milliseconds
+            const delayMs = retryAfter * 1000;
+            logger.debug('📨 Using Retry-After header delay', {
+                component: 'OpenAIClient',
+                retryAfter,
+                delayMs
+            });
+            return delayMs; // Convert to milliseconds
         }
     }
     // Default exponential backoff for rate limits: 2^attempt seconds (min 2s, max 60s)
     const baseDelay = Math.min(Math.pow(2, attempt) * 1000, 60000);
     const jitter = Math.random() * 1000; // Add jitter to prevent thundering herd
-    return Math.max(baseDelay + jitter, 2000); // Minimum 2 seconds
+    const finalDelay = Math.max(baseDelay + jitter, 2000); // Minimum 2 seconds
+    logger.debug('⚡ Using exponential backoff delay', {
+        component: 'OpenAIClient',
+        attempt,
+        baseDelay,
+        jitter,
+        finalDelay
+    });
+    return finalDelay;
 }
 /**
  * Get delay for general retryable errors
@@ -78,7 +132,15 @@ function getRetryDelay(attempt) {
     // Exponential backoff: 1, 2, 4 seconds with jitter
     const baseDelay = Math.pow(2, attempt - 1) * 1000;
     const jitter = Math.random() * 500;
-    return Math.min(baseDelay + jitter, 4000); // Max 4 seconds
+    const finalDelay = Math.min(baseDelay + jitter, 4000); // Max 4 seconds
+    logger.debug('🔄 Calculating retry delay', {
+        component: 'OpenAIClient',
+        attempt,
+        baseDelay,
+        jitter,
+        finalDelay
+    });
+    return finalDelay;
 }
 /**
  * Create chat completion with OpenAI with retry logic and cost tracking
@@ -86,6 +148,13 @@ function getRetryDelay(attempt) {
 export async function createChatCompletion(client, params, config, messages) {
     const maxRetries = 3;
     let lastError;
+    logger.debug('🚀 Starting chat completion request', {
+        component: 'OpenAIClient',
+        provider: config.provider,
+        model: config.model,
+        messageCount: messages.length,
+        maxRetries
+    });
     // Get model configuration for cost tracking
     const modelConfig = getModelConfig(config.provider, config.model);
     // Estimate input tokens for cost calculation
@@ -95,37 +164,78 @@ export async function createChatCompletion(client, params, config, messages) {
         }
         return total;
     }, 0);
+    logger.debug('📊 Token estimation complete', {
+        component: 'OpenAIClient',
+        estimatedInputTokens,
+        hasModelConfig: !!modelConfig
+    });
     // Log context information before making the request
     if (modelConfig) {
         const contextInfo = getContextInfo(messages, modelConfig);
-        console.log(`📊 Context: ${contextInfo.currentTokens}/${contextInfo.maxTokens} tokens (${contextInfo.utilizationPercentage.toFixed(1)}%)`);
+        logger.consoleLog(`📊 Context: ${contextInfo.currentTokens}/${contextInfo.maxTokens} tokens (${contextInfo.utilizationPercentage.toFixed(1)}%)`, {
+            component: 'OpenAIClient',
+            ...contextInfo
+        });
         if (contextInfo.needsCompaction) {
-            console.log(`⚠️  Context approaching limit - automatic compaction will trigger soon`);
+            logger.consoleLog(`⚠️  Context approaching limit - automatic compaction will trigger soon`, {
+                component: 'OpenAIClient',
+                needsCompaction: true
+            });
         }
     }
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        logger.debug(`🎯 Attempt ${attempt}/${maxRetries}`, {
+            component: 'OpenAIClient',
+            attempt,
+            maxRetries
+        });
         try {
+            logger.debug('📡 Making API request', {
+                component: 'OpenAIClient',
+                stream: params.stream || true,
+                includeUsage: true
+            });
             const stream = await client.chat.completions.create({
                 ...params,
                 stream: true,
                 stream_options: { include_usage: true }
             });
+            logger.debug('✅ API request successful', {
+                component: 'OpenAIClient',
+                attempt,
+                estimatedInputTokens
+            });
             return { stream, estimatedInputTokens };
         }
         catch (error) {
             lastError = error;
+            logger.debug('❌ API request failed', {
+                component: 'OpenAIClient',
+                attempt,
+                errorStatus: error?.status,
+                errorCode: error?.code,
+                errorMessage: error?.message
+            });
             // Handle rate limiting (429) specially
             if (error?.status === 429) {
                 const delay = getRateLimitDelay(error, attempt);
                 const seconds = Math.round(delay / 1000);
                 if (attempt < maxRetries) {
-                    console.log(`\n⏳ Rate limited by API. Waiting ${seconds} seconds before retry (attempt ${attempt}/${maxRetries})...`);
+                    logger.consoleLog(`\n⏳ Rate limited by API. Waiting ${seconds} seconds before retry (attempt ${attempt}/${maxRetries})...`, {
+                        component: 'OpenAIClient',
+                        attempt,
+                        maxRetries,
+                        delayMs: delay
+                    });
                     await sleep(delay);
                     continue;
                 }
                 else {
-                    console.error('\n❌ Rate limit exceeded. Maximum retries reached.');
-                    console.log('💡 Tip: Consider upgrading your API plan or waiting before making more requests.');
+                    logger.consoleLog('\n❌ Rate limit exceeded. Maximum retries reached.', {
+                        component: 'OpenAIClient',
+                        maxRetries
+                    });
+                    logger.consoleLog('💡 Tip: Consider upgrading your API plan or waiting before making more requests.');
                     break;
                 }
             }
@@ -133,34 +243,63 @@ export async function createChatCompletion(client, params, config, messages) {
             if (isRetryableError(error) && attempt < maxRetries) {
                 const delay = getRetryDelay(attempt);
                 const seconds = Math.round(delay / 1000);
-                console.log(`\n⚠️  API error (${error?.status || error?.code || 'unknown'}). Retrying in ${seconds} seconds (attempt ${attempt}/${maxRetries})...`);
+                logger.consoleLog(`\n⚠️  API error (${error?.status || error?.code || 'unknown'}). Retrying in ${seconds} seconds (attempt ${attempt}/${maxRetries})...`, {
+                    component: 'OpenAIClient',
+                    attempt,
+                    maxRetries,
+                    errorType: error?.status || error?.code || 'unknown',
+                    delayMs: delay
+                });
                 await sleep(delay);
                 continue;
             }
             // For non-retryable errors or max retries reached, break immediately
+            logger.error('💥 Breaking retry loop', {
+                component: 'OpenAIClient',
+                attempt,
+                maxRetries,
+                isRetryable: isRetryableError(error)
+            });
             break;
         }
     }
     // If we get here, all retries failed
-    console.error('\n❌ API request failed after all retry attempts.');
+    logger.consoleLog('\n❌ API request failed after all retry attempts.', {
+        component: 'OpenAIClient',
+        maxRetries,
+        lastErrorStatus: lastError?.status,
+        lastErrorCode: lastError?.code
+    });
     // Provide user-friendly error messages
     if (lastError?.status === 401) {
-        console.log('💡 This looks like an authentication error. Check your API key configuration.');
-        console.log('   Run: protoagent config --update-key');
+        logger.consoleLog('💡 This looks like an authentication error. Check your API key configuration.');
+        logger.consoleLog('   Run: protoagent config --update-key');
+        logger.error('🔐 Authentication error detected', { component: 'OpenAIClient' });
     }
     else if (lastError?.status === 429) {
-        console.log('💡 Rate limit exceeded. Try again later or upgrade your API plan.');
+        logger.consoleLog('💡 Rate limit exceeded. Try again later or upgrade your API plan.');
+        logger.error('⏳ Rate limit error detected', { component: 'OpenAIClient' });
     }
     else if (lastError?.status === 403) {
-        console.log('💡 Access forbidden. Check your API key permissions and billing status.');
+        logger.consoleLog('💡 Access forbidden. Check your API key permissions and billing status.');
+        logger.error('🚫 Forbidden access error detected', { component: 'OpenAIClient' });
     }
     else if (lastError?.status >= 500) {
-        console.log('💡 Server error. The API service may be temporarily unavailable.');
+        logger.consoleLog('💡 Server error. The API service may be temporarily unavailable.');
+        logger.error('🔧 Server error detected', {
+            component: 'OpenAIClient',
+            status: lastError.status
+        });
     }
     else if (lastError?.code === 'ENOTFOUND' || lastError?.message?.includes('network')) {
-        console.log('💡 Network connection error. Check your internet connection.');
+        logger.consoleLog('💡 Network connection error. Check your internet connection.');
+        logger.error('🌐 Network error detected', {
+            component: 'OpenAIClient',
+            code: lastError?.code
+        });
     }
     // Suggest graceful shutdown
-    console.log('\n🚪 ProtoAgent will now exit. Please resolve the issue and try again.');
+    logger.consoleLog('\n🚪 ProtoAgent will now exit. Please resolve the issue and try again.');
+    logger.error('🚪 Exiting due to API failure', { component: 'OpenAIClient' });
     process.exit(1);
 }

package/dist/config/commands.js

@@ -7,6 +7,7 @@ import { setupConfig } from './setup.js';
 import { openaiProvider, geminiProvider, cerebrasProvider } from './providers.js';
 import fs from 'fs/promises';
 import path from 'path';
+import { logger } from '../utils/logger.js';
 /**
  * Mask API key for display (show first 8 and last 4 characters)
  */
@@ -26,27 +27,27 @@ export async function showCurrentConfig() {
     try {
         const configExists = await hasConfig();
         if (!configExists) {
-            console.log('❌ No configuration found. Run ProtoAgent to set up.');
+            logger.consoleLog('❌ No configuration found. Run ProtoAgent to set up.');
             return;
         }
         const config = await loadConfig();
         const configDir = getConfigDirectory();
-        console.log('\n📋 Current ProtoAgent Configuration:');
-        console.log('─'.repeat(40));
-        console.log(`Provider: ${config.provider}`);
-        console.log(`Model: ${config.model}`);
+        logger.consoleLog('\n📋 Current ProtoAgent Configuration:');
+        logger.consoleLog('─'.repeat(40));
+        logger.consoleLog(`Provider: ${config.provider}`);
+        logger.consoleLog(`Model: ${config.model}`);
         // Show the appropriate API key based on provider
         if (config.provider === 'openai' && config.credentials.OPENAI_API_KEY) {
-            console.log(`API Key: ${maskApiKey(config.credentials.OPENAI_API_KEY)}`);
+            logger.consoleLog(`API Key: ${maskApiKey(config.credentials.OPENAI_API_KEY)}`);
         }
         else if (config.provider === 'gemini' && config.credentials.GEMINI_API_KEY) {
-            console.log(`API Key: ${maskApiKey(config.credentials.GEMINI_API_KEY)}`);
+            logger.consoleLog(`API Key: ${maskApiKey(config.credentials.GEMINI_API_KEY)}`);
         }
         else if (config.provider === 'cerebras' && config.credentials.CEREBRAS_API_KEY) {
-            console.log(`API Key: ${maskApiKey(config.credentials.CEREBRAS_API_KEY)}`);
+            logger.consoleLog(`API Key: ${maskApiKey(config.credentials.CEREBRAS_API_KEY)}`);
         }
-        console.log(`Config Location: ${configDir}/config.json`);
-        console.log('─'.repeat(40));
+        logger.consoleLog(`Config Location: ${configDir}/config.json`);
+        logger.consoleLog('─'.repeat(40));
     }
     catch (error) {
         console.error(`❌ Error reading configuration: ${error.message}`);
@@ -59,11 +60,11 @@ export async function updateApiKey() {
     try {
         const configExists = await hasConfig();
         if (!configExists) {
-            console.log('❌ No configuration found. Run ProtoAgent to set up first.');
+            logger.consoleLog('❌ No configuration found. Run ProtoAgent to set up first.');
             return;
         }
         const config = await loadConfig();
-        console.log(`\n🔑 Update ${config.provider.toUpperCase()} API Key`);
+        logger.consoleLog(`\n🔑 Update ${config.provider.toUpperCase()} API Key`);
         // Show current API key based on provider
         let currentKey = '';
         let helpUrl = '';
@@ -83,8 +84,8 @@ export async function updateApiKey() {
             helpUrl = 'https://cloud.cerebras.ai/platform';
             keyPrefix = '';
         }
-        console.log(`Current API Key: ${maskApiKey(currentKey)}`);
-        console.log(`Get your API key from: ${helpUrl}\n`);
+        logger.consoleLog(`Current API Key: ${maskApiKey(currentKey)}`);
+        logger.consoleLog(`Get your API key from: ${helpUrl}\n`);
         const { newApiKey } = await inquirer.prompt([
             {
                 type: 'password',
@@ -113,8 +114,8 @@ export async function updateApiKey() {
             config.credentials.CEREBRAS_API_KEY = newApiKey.trim();
         }
         await saveConfig(config);
-        console.log('\n✅ API key updated successfully!');
-        console.log(`New API Key: ${maskApiKey(newApiKey)}`);
+        logger.consoleLog('\n✅ API key updated successfully!');
+        logger.consoleLog(`New API Key: ${maskApiKey(newApiKey)}`);
     }
     catch (error) {
         console.error(`❌ Error updating API key: ${error.message}`);
@@ -127,12 +128,12 @@ export async function updateModel() {
     try {
         const configExists = await hasConfig();
         if (!configExists) {
-            console.log('❌ No configuration found. Run ProtoAgent to set up first.');
+            logger.consoleLog('❌ No configuration found. Run ProtoAgent to set up first.');
             return;
         }
         const config = await loadConfig();
-        console.log(`\n🤖 Update ${config.provider.toUpperCase()} Model`);
-        console.log(`Current Model: ${config.model}\n`);
+        logger.consoleLog(`\n🤖 Update ${config.provider.toUpperCase()} Model`);
+        logger.consoleLog(`Current Model: ${config.model}\n`);
         // Get available models based on provider
         let availableModels = [];
         if (config.provider === 'openai') {
@@ -157,16 +158,16 @@ export async function updateModel() {
             }
         ]);
         if (newModel === config.model) {
-            console.log('✨ No change needed - same model selected.');
+            logger.consoleLog('✨ No change needed - same model selected.');
             return;
         }
         // Update configuration
         const previousModel = config.model;
         config.model = newModel;
         await saveConfig(config);
-        console.log('\n✅ Model updated successfully!');
-        console.log(`Previous Model: ${previousModel}`);
-        console.log(`New Model: ${newModel}`);
+        logger.consoleLog('\n✅ Model updated successfully!');
+        logger.consoleLog(`Previous Model: ${previousModel}`);
+        logger.consoleLog(`New Model: ${newModel}`);
     }
     catch (error) {
         console.error(`❌ Error updating model: ${error.message}`);
@@ -179,8 +180,8 @@ export async function resetConfiguration() {
     try {
         const configExists = await hasConfig();
         if (configExists) {
-            console.log('\n⚠️  Reset Configuration');
-            console.log('This will delete your current configuration and set up ProtoAgent from scratch.');
+            logger.consoleLog('\n⚠️  Reset Configuration');
+            logger.consoleLog('This will delete your current configuration and set up ProtoAgent from scratch.');
             const { confirm } = await inquirer.prompt([
                 {
                     type: 'confirm',
@@ -190,16 +191,16 @@ export async function resetConfiguration() {
                 }
             ]);
             if (!confirm) {
-                console.log('Configuration reset cancelled.');
+                logger.consoleLog('Configuration reset cancelled.');
                 return;
             }
             // Delete existing configuration
             const configPath = path.join(getConfigDirectory(), 'config.json');
             await fs.unlink(configPath);
-            console.log('✅ Existing configuration deleted.');
+            logger.consoleLog('✅ Existing configuration deleted.');
         }
         // Run setup again
-        console.log('\n🔄 Starting fresh configuration setup...');
+        logger.consoleLog('\n🔄 Starting fresh configuration setup...');
         await setupConfig();
     }
     catch (error) {

package/dist/config/setup.js

@@ -4,12 +4,13 @@
 import inquirer from 'inquirer';
 import { openaiProvider, geminiProvider, cerebrasProvider } from './providers.js';
 import { saveConfig, getConfigDirectory } from './manager.js';
+import { logger } from '../utils/logger.js';
 /**
  * Run interactive configuration setup
  */
 export async function setupConfig() {
-    console.log('\n🤖 Welcome to ProtoAgent!');
-    console.log("Let's set up your model configuration.\n");
+    logger.consoleLog('\n🤖 Welcome to ProtoAgent!');
+    logger.consoleLog("Let's set up your model configuration.\n");
     // Step 1: Select provider and model
     const modelChoices = [
         new inquirer.Separator('--- OpenAI Models ---'),
@@ -47,9 +48,9 @@ export async function setupConfig() {
         CEREBRAS_API_KEY: ''
     };
     if (provider === 'openai') {
-        console.log(`\n📝 ${openaiProvider.auth.label} Setup`);
-        console.log("You'll need an API key from OpenAI.");
-        console.log(`Get your API key from: ${openaiProvider.auth.helpUrl}`);
+        logger.consoleLog(`\n📝 ${openaiProvider.auth.label} Setup`);
+        logger.consoleLog("You'll need an API key from OpenAI.");
+        logger.consoleLog(`Get your API key from: ${openaiProvider.auth.helpUrl}`);
         const response = await inquirer.prompt([
             {
                 type: 'password',
@@ -71,9 +72,9 @@ export async function setupConfig() {
         credentials.OPENAI_API_KEY = apiKey;
     }
     else if (provider === 'gemini') {
-        console.log(`\n📝 ${geminiProvider.auth.label} Setup`);
-        console.log("You'll need an API key from Gemini.");
-        console.log(`Get your API key from: ${geminiProvider.auth.helpUrl}`);
+        logger.consoleLog(`\n📝 ${geminiProvider.auth.label} Setup`);
+        logger.consoleLog("You'll need an API key from Gemini.");
+        logger.consoleLog(`Get your API key from: ${geminiProvider.auth.helpUrl}`);
         const response = await inquirer.prompt([
             {
                 type: 'password',
@@ -93,9 +94,9 @@ export async function setupConfig() {
         credentials.GEMINI_API_KEY = apiKey;
     }
     else if (provider === 'cerebras') {
-        console.log(`\n📝 ${cerebrasProvider.auth.label} Setup`);
-        console.log("You'll need an API key from Cerebras.");
-        console.log(`Get your API key from: ${cerebrasProvider.auth.helpUrl}`);
+        logger.consoleLog(`\n📝 ${cerebrasProvider.auth.label} Setup`);
+        logger.consoleLog("You'll need an API key from Cerebras.");
+        logger.consoleLog(`Get your API key from: ${cerebrasProvider.auth.helpUrl}`);
         const response = await inquirer.prompt([
             {
                 type: 'password',
@@ -115,7 +116,7 @@ export async function setupConfig() {
         credentials.CEREBRAS_API_KEY = apiKey;
     }
     // Step 3: Confirm configuration
-    console.log('\n📋 Configuration Summary:');
+    logger.consoleLog('\n📋 Configuration Summary:');
     let providerName = '';
     if (provider === 'openai') {
         providerName = openaiProvider.name;
@@ -126,9 +127,9 @@ export async function setupConfig() {
     else if (provider === 'cerebras') {
         providerName = cerebrasProvider.name;
     }
-    console.log(`Provider: ${providerName}`);
-    console.log(`Model: ${model}`);
-    console.log(`API Key: ${'*'.repeat(Math.min(apiKey.length, 20))}...`);
+    logger.consoleLog(`Provider: ${providerName}`);
+    logger.consoleLog(`Model: ${model}`);
+    logger.consoleLog(`API Key: ${'*'.repeat(Math.min(apiKey.length, 20))}...`);
     const { confirm } = await inquirer.prompt([
         {
             type: 'confirm',
@@ -138,7 +139,7 @@ export async function setupConfig() {
         }
     ]);
     if (!confirm) {
-        console.log('Configuration cancelled.');
+        logger.consoleLog('Configuration cancelled.');
         process.exit(0);
     }
     // Step 4: Save configuration
@@ -149,9 +150,9 @@ export async function setupConfig() {
     };
     try {
         await saveConfig(config);
-        console.log(`\n✅ Configuration saved successfully!`);
-        console.log(`Config location: ${getConfigDirectory()}/config.json`);
-        console.log("\nYou're all set! ProtoAgent is ready to use.\n");
+        logger.consoleLog(`\n✅ Configuration saved successfully!`);
+        logger.consoleLog(`Config location: ${getConfigDirectory()}/config.json`);
+        logger.consoleLog("\nYou're all set! ProtoAgent is ready to use.\n");
         return config;
     }
     catch (error) {

package/dist/config/system-prompt.js

@@ -9,6 +9,7 @@ import { searchFilesTool } from '../tools/search-files.js';
 import { runShellCommandTool } from '../tools/run-shell-command.js';
 import fs from 'fs/promises';
 import path from 'path';
+import { logger } from '../utils/logger.js';
 // Collect all tools
 const allTools = [
     readFileTool,
@@ -82,10 +83,23 @@ async function generateDirectoryTree(dirPath = '.', depth = 0, maxDepth = 3) {
 }
 // Generate project context asynchronously
 async function generateProjectContext() {
+    logger.debug('📁 Generating project context', { component: 'SystemPrompt' });
     const workingDir = getCurrentWorkingDirectory();
     const projectName = path.basename(workingDir);
+    logger.debug('📂 Project info', {
+        component: 'SystemPrompt',
+        workingDir,
+        projectName
+    });
     try {
+        const treeStartTime = Date.now();
         const tree = await generateDirectoryTree();
+        const treeGenerationTime = Date.now() - treeStartTime;
+        logger.debug('🌳 Directory tree generated', {
+            component: 'SystemPrompt',
+            treeLength: tree.length,
+            generationTime: treeGenerationTime
+        });
         return `
 ## Current Project Context:
 
@@ -96,6 +110,10 @@ async function generateProjectContext() {
 ${tree}`;
     }
     catch (error) {
+        logger.error('❌ Failed to generate directory tree', {
+            component: 'SystemPrompt',
+            error: error instanceof Error ? error.message : String(error)
+        });
         return `
 ## Current Project Context:
 
@@ -107,7 +125,15 @@ ${tree}`;
 }
 // Generate the complete system prompt with project context
 export async function generateSystemPrompt() {
+    logger.debug('🏗️  Generating system prompt', { component: 'SystemPrompt' });
+    const startTime = Date.now();
     const projectContext = await generateProjectContext();
+    const generationTime = Date.now() - startTime;
+    logger.debug('✅ System prompt generated', {
+        component: 'SystemPrompt',
+        generationTime,
+        contextLength: projectContext.length
+    });
     return `You are ProtoAgent, a helpful coding assistant with file system and shell command capabilities. Your objective is to help the user
 complete their coding tasks, most likely related to the directory you were started in. 
   
@@ -131,6 +157,24 @@ When users ask you to work with files or run commands, you should:
 - Show the user the results of your operations
 - Ask for confirmation before running any write, delete operations
 
+## CRITICAL: Always Be Proactive With Tool Usage
+
+**When users ask about existing code, projects, or codebases:**
+1. IMMEDIATELY start using tools to explore and understand the codebase
+2. Use find/search commands to locate relevant files and directories
+3. Use read_file to examine source code files
+4. Use list_directory and view_directory_tree to understand project structure
+5. NEVER just "think" about code - always examine it with tools first
+
+**When asked to analyze or compare codebases:**
+1. Start by searching for the mentioned projects/directories
+2. Explore their structure systematically
+3. Read key files (main entry points, package.json, README, etc.)
+4. Build understanding iteratively through tool usage
+5. Document findings as you discover them
+
+**MANDATORY: If a user mentions specific codebases or asks you to analyze source code, you MUST start using tools immediately to explore and understand the code before providing any analysis.**
+
 ## TODO TRACKING - MANDATORY REQUIREMENT:
 
 **YOU MUST ALWAYS USE TODO TRACKING FOR ANY NON-TRIVIAL TASK:**
@@ -244,6 +288,24 @@ When users ask you to work with files or run commands, you should:
 - Show the user the results of your operations
 - Ask for confirmation before running any write, delete operations
 
+## CRITICAL: Always Be Proactive With Tool Usage
+
+**When users ask about existing code, projects, or codebases:**
+1. IMMEDIATELY start using tools to explore and understand the codebase
+2. Use find/search commands to locate relevant files and directories
+3. Use read_file to examine source code files
+4. Use list_directory and view_directory_tree to understand project structure
+5. NEVER just "think" about code - always examine it with tools first
+
+**When asked to analyze or compare codebases:**
+1. Start by searching for the mentioned projects/directories
+2. Explore their structure systematically
+3. Read key files (main entry points, package.json, README, etc.)
+4. Build understanding iteratively through tool usage
+5. Document findings as you discover them
+
+**MANDATORY: If a user mentions specific codebases or asks you to analyze source code, you MUST start using tools immediately to explore and understand the code before providing any analysis.**
+
 ## File Operation Guidelines - CRITICAL:
 
 **ALWAYS PREFER EDITING OVER WRITING FILES:**