protoagent 0.0.2 → 0.0.3

package/dist/index.js

@@ -18,7 +18,9 @@ program
     .description('Interactive AI coding agent CLI with file system capabilities')
     .version('1.0.0')
     .option('--dangerously-accept-all', 'Auto-approve all shell commands and file operations without confirmation (DANGEROUS)')
-    .option('--log-level <level>', 'Set logging level (ERROR, WARN, INFO, DEBUG, TRACE)', 'INFO');
+    .option('--log-level <level>', 'Set logging level (ERROR, WARN, INFO, DEBUG, TRACE)', 'INFO')
+    .option('--log-to-file', 'Enable file logging to ~/.protoagent/logs/')
+    .option('--log-dir <path>', 'Custom directory for log files (requires --log-to-file)');
 // Configuration management command
 program
     .command('config')
@@ -41,73 +43,99 @@ program
         await resetConfiguration();
     }
     else {
-        console.log('Use --help to see available configuration options');
+        logger.consoleLog('Use --help to see available configuration options');
     }
 });
 async function respondToUser(userInput) {
+    logger.debug('🤖 respondToUser called', { component: 'Main', inputLength: userInput.length });
     if (agenticLoop) {
+        logger.debug('✅ Agentic loop available - processing input');
         await agenticLoop.processUserInput(userInput);
+        logger.debug('✅ Agentic loop processing complete');
     }
     else {
+        logger.error('❌ Agentic loop not initialized', { component: 'Main' });
         console.error('❌ Agentic loop not initialized');
     }
 }
 async function initializeConfig() {
+    logger.debug('🔧 Starting configuration initialization', { component: 'Config' });
     // Check if configuration exists
     if (await hasConfig()) {
+        logger.debug('📋 Configuration file exists - loading', { component: 'Config' });
         try {
             config = await loadConfig();
+            logger.debug('✅ Configuration loaded successfully', { component: 'Config', provider: config.provider, model: config.model });
             if (!validateConfig(config)) {
-                console.log('⚠️  Configuration is invalid or corrupted.');
+                logger.warn('⚠️  Configuration validation failed', { component: 'Config' });
+                logger.consoleLog('⚠️  Configuration is invalid or corrupted.');
+                logger.info('⚠️  Invalid config message displayed to user');
                 if (await promptReconfigure()) {
+                    logger.debug('🔄 User chose to reconfigure', { component: 'Config' });
                     config = await setupConfig();
                 }
                 else {
-                    console.log('Cannot proceed without valid configuration.');
+                    logger.error('❌ User declined reconfiguration', { component: 'Config' });
+                    logger.consoleLog('Cannot proceed without valid configuration.');
+                    logger.error('❌ Cannot proceed message displayed');
                     process.exit(1);
                 }
             }
         }
         catch (error) {
-            console.log(`❌ Error loading configuration: ${error.message}`);
+            logger.error('❌ Error loading configuration', { component: 'Config', error: error.message });
+            logger.consoleLog(`❌ Error loading configuration: ${error.message}`);
+            logger.info('❌ Config error message displayed to user');
             if (await promptReconfigure()) {
+                logger.debug('🔄 User chose to reconfigure after error', { component: 'Config' });
                 config = await setupConfig();
             }
             else {
-                console.log('Cannot proceed without valid configuration.');
+                logger.error('❌ User declined reconfiguration after error', { component: 'Config' });
+                logger.consoleLog('Cannot proceed without valid configuration.');
+                logger.error('❌ Cannot proceed after error message displayed');
                 process.exit(1);
             }
         }
     }
     else {
+        logger.debug('📝 No configuration exists - running setup', { component: 'Config' });
         // No configuration exists, run setup
         config = await setupConfig();
     }
+    logger.debug('🔧 Setting tools configuration', { component: 'Config' });
     // Set config for tools
     setToolsConfig(config);
+    logger.debug('🤖 Initializing OpenAI client', { component: 'Config', provider: config.provider });
     // Initialize OpenAI client with the configuration
     try {
         openaiClient = createOpenAIClient(config);
+        if (!openaiClient) {
+            throw new Error('Failed to create OpenAI client');
+        }
+        logger.debug('✅ OpenAI client created successfully', { component: 'Config' });
+        logger.debug('🔄 Creating agentic loop', { component: 'Config', maxIterations: 100, streamOutput: true });
         // Initialize the agentic loop 
         agenticLoop = await createAgenticLoop(openaiClient, config, {
             maxIterations: 100,
             streamOutput: true
         });
-        logger.debug(`✅ Successfully initialized ProtoAgent`);
+        logger.debug(`✅ Successfully initialized ProtoAgent`, { component: 'Config' });
     }
     catch (error) {
-        logger.error(`❌ Failed to initialize OpenAI client: ${error.message}`);
+        logger.error(`❌ Failed to initialize OpenAI client: ${error.message}`, { component: 'Config', error: error.message });
         process.exit(1);
     }
 }
 async function startInteractiveMode() {
-    console.log('🤖 Welcome to ProtoAgent - Your AI Coding Assistant with File System & Shell Powers!');
-    console.log('💡 I can read, write, edit, search files and run shell commands in your project.');
-    console.log('🔧 Ask me to create files, analyze code, run npm commands, git operations, or execute any shell command.');
+    logger.debug('🚀 Starting interactive mode initialization');
+    logger.debug(' Parsing command line options');
     // Check for options
     const options = program.opts();
+    logger.debug('🔍 Command line options parsed', { component: 'Main', options });
     // Set log level
     if (options.logLevel) {
+        logger.debug('🔧 Setting log level', { component: 'Main', requestedLevel: options.logLevel });
         const logLevel = LogLevel[options.logLevel.toUpperCase()];
         if (logLevel !== undefined) {
             logger.setLevel(logLevel);
@@ -117,19 +145,50 @@ async function startInteractiveMode() {
             logger.warn(`⚠️  Invalid log level: ${options.logLevel}. Using INFO.`);
         }
     }
+    // Enable file logging if requested (BEFORE welcome messages)
+    if (options.logToFile) {
+        logger.debug('📝 Enabling file logging', { component: 'Main', logDir: options.logDir || 'default' });
+        logger.enableFileLogging(options.logDir);
+        logger.info('📝 File logging enabled');
+    }
     // Check for dangerous flag
     if (options.dangerouslyAcceptAll) {
+        logger.debug('⚠️  Enabling dangerous mode', { component: 'Main' });
         logger.warn('⚠️  DANGER MODE: All shell commands and file operations will be auto-approved without confirmation!');
         setToolsDangerouslyAcceptAll(true);
     }
-    console.log('🚪 Type "exit" to quit.\n');
+    // NOW display welcome messages (after file logging is enabled)
+    logger.consoleLog('🤖 Welcome to ProtoAgent - Your AI Coding Assistant with File System & Shell Powers!');
+    logger.debug('🤖 Welcome message displayed');
+    logger.consoleLog('💡 I can read, write, edit, search files and run shell commands in your project.');
+    logger.consoleLog('🔧 Ask me to create files, analyze code, run npm commands, git operations, or execute any shell command.');
+    logger.debug('💡 Capability messages displayed');
+    logger.consoleLog('🚪 Type "exit" to quit.');
+    logger.debug('🚪 Exit instruction displayed');
+    logger.debug('🔧 Initializing configuration');
     // Initialize configuration
     await initializeConfig();
-    logger.info(`🧠 Using ${config.provider} with model: ${config.model}`);
+    // Set up cleanup handlers for file logging
+    logger.debug('🛡️  Setting up cleanup handlers');
+    process.on('SIGINT', () => {
+        logger.debug('🛑 SIGINT received - cleaning up');
+        logger.consoleLog('\n👋 Goodbye! Happy coding!');
+        logger.info('👋 Goodbye message displayed (SIGINT)');
+        logger.disableFileLogging();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        logger.debug('🛑 SIGTERM received - cleaning up');
+        logger.disableFileLogging();
+        process.exit(0);
+    });
+    logger.consoleLog(`🧠 Using ${config.provider} with model: ${config.model}`);
     // Show current working directory
-    logger.info(`📁 Working directory: ${process.cwd()}`);
-    console.log(`📁 Working directory: ${process.cwd()}\n`);
+    logger.consoleLog(`📁 Working directory: ${process.cwd()}`);
+    logger.debug('📁 Working directory displayed to user');
+    logger.debug('🔄 Starting main interaction loop');
     while (true) {
+        logger.trace('📥 Waiting for user input');
         const { input } = await inquirer.prompt([
             {
                 type: 'input',
@@ -137,15 +196,23 @@ async function startInteractiveMode() {
                 message: 'protoagent>',
             }
         ]);
+        logger.debug('📝 User input received', { component: 'Main', inputLength: input.length, isEmpty: input.trim() === '' });
         if (input.toLowerCase() === 'exit' || input.toLowerCase() === 'quit') {
-            console.log('👋 Goodbye! Happy coding!');
+            logger.debug('🚪 Exit command received');
+            logger.consoleLog('👋 Goodbye! Happy coding!');
+            logger.info('👋 Goodbye message displayed (normal exit)');
+            // Clean up file logging
+            logger.debug('🧹 Cleaning up file logging');
+            logger.disableFileLogging();
             break;
         }
         if (input.trim() === '') {
+            logger.trace('⏭️  Empty input - continuing');
             continue;
         }
+        logger.debug('🤖 Forwarding input to agent', { component: 'Main', input: input.slice(0, 100) + (input.length > 100 ? '...' : '') });
         await respondToUser(input);
-        console.log(); // Add extra newline for spacing
+        logger.trace('✅ User input processing complete');
     }
 }
 program

package/dist/tools/index.js

@@ -29,6 +29,7 @@ import { viewDirectoryTree } from './view-directory-tree.js';
 import { searchFiles } from './search-files.js';
 import { runShellCommand } from './run-shell-command.js';
 import { handleTodoTool } from './todo.js';
+import { logger } from '../utils/logger.js';
 // Consolidated tool definitions
 export const tools = [
     readFileTool,
@@ -44,41 +45,96 @@ export const tools = [
 ];
 // Tool handler function
 export async function handleToolCall(toolName, args) {
+    logger.debug('🛠️  handleToolCall invoked', {
+        component: 'ToolHandler',
+        toolName,
+        argsKeys: Object.keys(args || {})
+    });
     try {
+        const startTime = Date.now();
+        let result;
         switch (toolName) {
             case 'read_file':
+                logger.debug('📖 Executing read_file', { component: 'ToolHandler', filePath: args.file_path });
                 const content = await readFile(args.file_path, args.offset, args.limit);
-                return `File content of ${args.file_path}:\n\n${content}`;
+                result = `File content of ${args.file_path}:\n\n${content}`;
+                break;
             case 'write_file':
-                const writeResult = await writeFile(args.file_path, args.content);
-                return writeResult;
+                logger.debug('✏️  Executing write_file', { component: 'ToolHandler', filePath: args.file_path, contentLength: args.content?.length });
+                result = await writeFile(args.file_path, args.content);
+                break;
             case 'edit_file':
-                const editResult = await editFile(args.file_path, args.old_string, args.new_string, args.expected_replacements);
-                return editResult;
+                logger.debug('✂️  Executing edit_file', {
+                    component: 'ToolHandler',
+                    filePath: args.file_path,
+                    oldStringLength: args.old_string?.length,
+                    newStringLength: args.new_string?.length,
+                    expectedReplacements: args.expected_replacements
+                });
+                result = await editFile(args.file_path, args.old_string, args.new_string, args.expected_replacements);
+                break;
             case 'list_directory':
+                logger.debug('📁 Executing list_directory', { component: 'ToolHandler', directoryPath: args.directory_path });
                 const listResult = await listDirectory(args.directory_path);
-                return `Contents of ${args.directory_path}:\n\n${listResult}`;
+                result = `Contents of ${args.directory_path}:\n\n${listResult}`;
+                break;
             case 'create_directory':
-                const createResult = await createDirectory(args.directory_path);
-                return createResult;
+                logger.debug('📂 Executing create_directory', { component: 'ToolHandler', directoryPath: args.directory_path });
+                result = await createDirectory(args.directory_path);
+                break;
             case 'view_directory_tree':
-                const treeResult = await viewDirectoryTree(args.directory_path, args.max_depth);
-                return treeResult;
+                logger.debug('🌳 Executing view_directory_tree', {
+                    component: 'ToolHandler',
+                    directoryPath: args.directory_path,
+                    maxDepth: args.max_depth
+                });
+                result = await viewDirectoryTree(args.directory_path, args.max_depth);
+                break;
             case 'search_files':
-                const searchResult = await searchFiles(args.search_term, args.directory_path, args.case_sensitive, args.file_extensions);
-                return searchResult;
+                logger.debug('🔍 Executing search_files', {
+                    component: 'ToolHandler',
+                    searchTerm: args.search_term,
+                    directoryPath: args.directory_path,
+                    caseSensitive: args.case_sensitive,
+                    fileExtensions: args.file_extensions
+                });
+                result = await searchFiles(args.search_term, args.directory_path, args.case_sensitive, args.file_extensions);
+                break;
             case 'run_shell_command':
-                const shellResult = await runShellCommand(args.command, args.args || [], args.timeout_ms || 30000);
-                return shellResult;
+                logger.debug('🐚 Executing run_shell_command', {
+                    component: 'ToolHandler',
+                    command: args.command,
+                    argsCount: args.args?.length || 0,
+                    timeout: args.timeout_ms || 30000
+                });
+                result = await runShellCommand(args.command, args.args || [], args.timeout_ms || 30000);
+                break;
             case 'todo_read':
             case 'todo_write':
-                return await handleTodoTool(toolName, args);
+                logger.debug('📋 Executing todo tool', { component: 'ToolHandler', toolName });
+                result = await handleTodoTool(toolName, args);
+                break;
             default:
-                return `Error: Unknown tool ${toolName}`;
+                logger.error('❌ Unknown tool requested', { component: 'ToolHandler', toolName });
+                result = `Error: Unknown tool ${toolName}`;
         }
+        const executionTime = Date.now() - startTime;
+        logger.debug('✅ Tool execution completed', {
+            component: 'ToolHandler',
+            toolName,
+            executionTime,
+            resultLength: result.length,
+            success: !result.startsWith('Error:')
+        });
+        return result;
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('❌ Tool execution failed with exception', {
+            component: 'ToolHandler',
+            toolName,
+            error: errorMessage
+        });
         return `Error executing ${toolName}: ${errorMessage}`;
     }
 }

package/dist/tools/run-shell-command.js

@@ -1,5 +1,6 @@
 import { spawn } from 'child_process';
 import inquirer from 'inquirer';
+import { logger } from '../utils/logger.js';
 // Current working directory for file operations
 const workingDirectory = process.cwd();
 // Global flags and session state
@@ -39,10 +40,10 @@ async function runShellCommandWithRetry(command, args = [], timeoutMs = 30000, r
         // Check if we should auto-approve (only show approval prompt on first attempt)
         if (retryCount === 0) {
             if (dangerouslyAcceptAll) {
-                console.log(`🚀 Auto-executing (--dangerously-accept-all): ${commandString}`);
+                logger.consoleLog(`🚀 Auto-executing (--dangerously-accept-all): ${commandString}`);
             }
             else if (approvedCommandsForSession.has(baseCommand)) {
-                console.log(`🚀 Auto-executing (${baseCommand} approved for session): ${commandString}`);
+                logger.consoleLog(`🚀 Auto-executing (${baseCommand} approved for session): ${commandString}`);
             }
             else {
                 // Check if it's a safe command
@@ -54,12 +55,12 @@ async function runShellCommandWithRetry(command, args = [], timeoutMs = 30000, r
                         (!normalizedSafe.includes(' ') && normalizedFull.split(' ')[0] === normalizedSafe);
                 });
                 if (isSafeCommand) {
-                    console.log(`🟢 Executing safe command: ${commandString}`);
+                    logger.consoleLog(`🟢 Executing safe command: ${commandString}`);
                 }
                 else {
                     // Require user confirmation with enhanced options
-                    console.log(`\n🔐 Shell Command Requested: ${commandString}`);
-                    console.log(`📁 Working Directory: ${workingDirectory}`);
+                    logger.consoleLog(`\n🔐 Shell Command Requested: ${commandString}`);
+                    logger.consoleLog(`📁 Working Directory: ${workingDirectory}`);
                     const { choice } = await inquirer.prompt([
                         {
                             type: 'list',
@@ -75,12 +76,12 @@ async function runShellCommandWithRetry(command, args = [], timeoutMs = 30000, r
                     ]);
                     switch (choice) {
                         case 'execute':
-                            console.log(`🚀 Executing: ${commandString}`);
+                            logger.consoleLog(`🚀 Executing: ${commandString}`);
                             break;
                         case 'approve_session':
                             approvedCommandsForSession.add(baseCommand);
-                            console.log(`🔓 "${baseCommand}" approved for session - all future ${baseCommand} commands will auto-execute`);
-                            console.log(`🚀 Executing: ${commandString}`);
+                            logger.consoleLog(`🔓 "${baseCommand}" approved for session - all future ${baseCommand} commands will auto-execute`);
+                            logger.consoleLog(`🚀 Executing: ${commandString}`);
                             break;
                         case 'cancel':
                             return getSuggestion(commandString);
@@ -91,7 +92,7 @@ async function runShellCommandWithRetry(command, args = [], timeoutMs = 30000, r
             }
         }
         else {
-            console.log(`🔄 Retry attempt ${retryCount}/${maxRetries}: ${commandString}`);
+            logger.consoleLog(`🔄 Retry attempt ${retryCount}/${maxRetries}: ${commandString}`);
         }
         return new Promise((resolve, reject) => {
             const child = spawn(command, args, {
@@ -154,18 +155,18 @@ async function runShellCommandWithRetry(command, args = [], timeoutMs = 30000, r
 }
 async function analyzeTimeoutAndRetry(command, args = [], originalTimeout, retryCount) {
     const commandString = `${command} ${args.join(' ')}`;
-    console.log(`⏱️  Command timed out after ${originalTimeout}ms: ${commandString}`);
-    console.log(`🔍 Analyzing timeout cause and preparing retry...`);
+    logger.consoleLog(`⏱️  Command timed out after ${originalTimeout}ms: ${commandString}`);
+    logger.consoleLog(`🔍 Analyzing timeout cause and preparing retry...`);
     // Analyze the command to understand why it might have timed out
     const analysis = analyzeCommandForTimeout(command, args);
-    console.log(`💡 Timeout analysis: ${analysis.reason}`);
+    logger.consoleLog(`💡 Timeout analysis: ${analysis.reason}`);
     if (analysis.suggestedArgs.length > 0) {
-        console.log(`🔧 Suggested fix: ${command} ${analysis.suggestedArgs.join(' ')}`);
+        logger.consoleLog(`🔧 Suggested fix: ${command} ${analysis.suggestedArgs.join(' ')}`);
         // Try with suggested arguments
         return await runShellCommandWithRetry(command, analysis.suggestedArgs, analysis.suggestedTimeout, retryCount + 1);
     }
     else if (analysis.suggestedTimeout > originalTimeout) {
-        console.log(`⏰ Increasing timeout to ${analysis.suggestedTimeout}ms for long-running operation`);
+        logger.consoleLog(`⏰ Increasing timeout to ${analysis.suggestedTimeout}ms for long-running operation`);
         // Try with longer timeout
         return await runShellCommandWithRetry(command, args, analysis.suggestedTimeout, retryCount + 1);
     }

package/dist/utils/conversation-compactor.js

@@ -1,6 +1,7 @@
 /**
  * Conversation history compaction utilities
  */
+import { logger } from './logger.js';
 /**
  * Provides the system prompt for the history compression process.
  * This prompt instructs the model to act as a specialized state manager,
@@ -69,14 +70,14 @@ The structure MUST be as follows:
  * Compact conversation history by creating a summary
  */
 export async function compactConversation(client, model, messages, recentMessagesToKeep = 5) {
-    console.log('\n🗜️  Compacting conversation history to manage context window...');
+    logger.consoleLog('\n🗜️  Compacting conversation history to manage context window...');
     // Keep the system message and recent messages
     const systemMessage = messages.find(m => m.role === 'system');
     const recentMessages = messages.slice(-recentMessagesToKeep);
     // Get the history to compress (excluding system and recent messages)
     const historyToCompress = messages.slice(systemMessage ? 1 : 0, -recentMessagesToKeep);
     if (historyToCompress.length === 0) {
-        console.log('   No history to compress, keeping current messages');
+        logger.consoleLog('   No history to compress, keeping current messages');
         return messages;
     }
     try {
@@ -100,7 +101,7 @@ export async function compactConversation(client, model, messages, recentMessage
         });
         const compressionSummary = response.choices[0]?.message?.content;
         if (!compressionSummary) {
-            console.log('   Failed to generate compression summary, keeping original messages');
+            logger.consoleLog('   Failed to generate compression summary, keeping original messages');
             return messages;
         }
         // Create the compressed history message
@@ -118,12 +119,12 @@ export async function compactConversation(client, model, messages, recentMessage
         compactedMessages.push(compressedMessage);
         // Add recent messages
         compactedMessages.push(...recentMessages);
-        console.log(`   ✅ Compressed ${historyToCompress.length} messages into summary`);
-        console.log(`   📝 Keeping ${recentMessages.length} recent messages`);
+        logger.consoleLog(`   ✅ Compressed ${historyToCompress.length} messages into summary`);
+        logger.consoleLog(`   📝 Keeping ${recentMessages.length} recent messages`);
         return compactedMessages;
     }
     catch (error) {
-        console.log(`   ❌ Compression failed: ${error}. Keeping original messages.`);
+        logger.consoleLog(`   ❌ Compression failed: ${error}. Keeping original messages.`);
         return messages;
     }
 }

package/dist/utils/cost-tracker.js

@@ -1,6 +1,7 @@
 /**
  * Cost tracking and token counting utilities
  */
+import { logger } from './logger.js';
 /**
  * Rough token estimation for OpenAI models
  * This is approximate - actual tokenization may vary
@@ -72,11 +73,11 @@ export function getContextInfo(messages, modelConfig) {
  * Log usage and cost information
  */
 export function logUsageInfo(usage, contextInfo, modelConfig) {
-    console.log(`💰 Usage: ${usage.inputTokens} in + ${usage.outputTokens} out = ${usage.totalTokens} tokens`);
-    console.log(`💸 Estimated cost: $${usage.estimatedCost.toFixed(6)}`);
-    console.log(`📊 Context: ${contextInfo.currentTokens}/${contextInfo.maxTokens} tokens (${contextInfo.utilizationPercentage.toFixed(1)}%)`);
+    logger.consoleLog(`💰 Usage: ${usage.inputTokens} in + ${usage.outputTokens} out = ${usage.totalTokens} tokens`);
+    logger.consoleLog(`💸 Estimated cost: $${usage.estimatedCost.toFixed(6)}`);
+    logger.consoleLog(`📊 Context: ${contextInfo.currentTokens}/${contextInfo.maxTokens} tokens (${contextInfo.utilizationPercentage.toFixed(1)}%)`);
     if (contextInfo.needsCompaction) {
-        console.log(`⚠️  Context approaching limit - automatic compaction will trigger soon`);
+        logger.consoleLog(`⚠️  Context approaching limit - automatic compaction will trigger soon`);
     }
 }
 /**

package/dist/utils/file-operations-approval.js

@@ -33,21 +33,9 @@ export async function requestFileOperationApproval(context) {
         return true;
     }
     // Show detailed information about the operation
-    console.log(`\n🔐 File Operation Requested: ${operation.toUpperCase()}`);
-    console.log(`📁 File: ${filePath}`);
-    console.log(`📝 Description: ${description}`);
-    if (contentPreview) {
-        console.log(`\n📄 Content Preview:`);
-        const lines = contentPreview.split('\n');
-        if (lines.length > 10) {
-            console.log(lines.slice(0, 5).join('\n'));
-            console.log(`... (${lines.length - 10} more lines) ...`);
-            console.log(lines.slice(-5).join('\n'));
-        }
-        else {
-            console.log(contentPreview);
-        }
-    }
+    logger.consoleLog(`\n🔐 File Operation Requested: ${operation.toUpperCase()}`);
+    logger.consoleLog(`📁 File: ${filePath}`);
+    logger.consoleLog(`📝 Description: ${description}`);
     // Ask for user approval with enhanced options
     const { choice } = await inquirer.prompt([
         {
@@ -89,43 +77,43 @@ export async function requestFileOperationApproval(context) {
  */
 async function showFileOperationDetails(context) {
     const { operation, filePath, description, contentPreview } = context;
-    console.log(`\n📋 Detailed File Operation Information:`);
-    console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
-    console.log(`🔧 Operation Type: ${operation.toUpperCase()}`);
-    console.log(`📁 Target File: ${filePath}`);
-    console.log(`📝 Description: ${description}`);
-    console.log(`📂 Working Directory: ${process.cwd()}`);
+    logger.consoleLog(`\n📋 Detailed File Operation Information:`);
+    logger.consoleLog(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+    logger.consoleLog(`🔧 Operation Type: ${operation.toUpperCase()}`);
+    logger.consoleLog(`📁 Target File: ${filePath}`);
+    logger.consoleLog(`📝 Description: ${description}`);
+    logger.consoleLog(`📂 Working Directory: ${process.cwd()}`);
     // Show file status
     try {
         const fs = await import('fs/promises');
         const stats = await fs.stat(filePath);
-        console.log(`📊 File exists: YES`);
-        console.log(`📅 Last modified: ${stats.mtime.toLocaleString()}`);
-        console.log(`📏 File size: ${stats.size} bytes`);
+        logger.consoleLog(`📊 File exists: YES`);
+        logger.consoleLog(`📅 Last modified: ${stats.mtime.toLocaleString()}`);
+        logger.consoleLog(`📏 File size: ${stats.size} bytes`);
     }
     catch (error) {
-        console.log(`📊 File exists: NO (will be created)`);
+        logger.consoleLog(`📊 File exists: NO (will be created)`);
     }
     // Show full content if available
     if (contentPreview) {
-        console.log(`\n📄 Full Content Preview:`);
-        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
-        console.log(contentPreview);
-        console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        logger.consoleLog(`\n📄 Full Content Preview:`);
+        logger.consoleLog(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+        logger.consoleLog(contentPreview);
+        logger.consoleLog(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
     }
     // Show security information
-    console.log(`\n🔒 Security Information:`);
-    console.log(`• File path is validated and restricted to working directory`);
-    console.log(`• Operation will be performed atomically with backup`);
-    console.log(`• You can undo changes using git if needed`);
-    console.log(`\n💡 Recommendation:`);
+    logger.consoleLog(`\n🔒 Security Information:`);
+    logger.consoleLog(`• File path is validated and restricted to working directory`);
+    logger.consoleLog(`• Operation will be performed atomically with backup`);
+    logger.consoleLog(`• You can undo changes using git if needed`);
+    logger.consoleLog(`\n💡 Recommendation:`);
     if (operation === 'write' && contentPreview) {
-        console.log(`• WRITE operation will ${contentPreview.includes('export') ? 'create a new file' : 'replace file content'}`);
-        console.log(`• Consider approving if the content looks correct`);
+        logger.consoleLog(`• WRITE operation will ${contentPreview.includes('export') ? 'create a new file' : 'replace file content'}`);
+        logger.consoleLog(`• Consider approving if the content looks correct`);
     }
     else if (operation === 'edit') {
-        console.log(`• EDIT operation will make targeted changes to existing file`);
-        console.log(`• Generally safer than write operations`);
+        logger.consoleLog(`• EDIT operation will make targeted changes to existing file`);
+        logger.consoleLog(`• Generally safer than write operations`);
     }
     await inquirer.prompt([{ type: 'input', name: 'continue', message: 'Press Enter to continue...' }]);
 }
@@ -151,13 +139,13 @@ export function clearSessionApprovals() {
  */
 export function showApprovalStatus() {
     const status = getSessionApprovalStatus();
-    console.log('\n📊 Current File Operation Approval Status:');
-    console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
-    console.log(`🚀 Dangerous Mode (auto-approve all): ${status.dangerousMode ? '✅ ENABLED' : '❌ Disabled'}`);
-    console.log(`✏️  Edit operations for session: ${status.editApproved ? '✅ Auto-approved' : '❌ Require approval'}`);
-    console.log(`📝 Write operations for session: ${status.writeApproved ? '✅ Auto-approved' : '❌ Require approval'}`);
+    logger.consoleLog('\n📊 Current File Operation Approval Status:');
+    logger.consoleLog(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+    logger.consoleLog(`🚀 Dangerous Mode (auto-approve all): ${status.dangerousMode ? '✅ ENABLED' : '❌ Disabled'}`);
+    logger.consoleLog(`✏️  Edit operations for session: ${status.editApproved ? '✅ Auto-approved' : '❌ Require approval'}`);
+    logger.consoleLog(`📝 Write operations for session: ${status.writeApproved ? '✅ Auto-approved' : '❌ Require approval'}`);
     if (status.dangerousMode) {
-        console.log(`\n⚠️  WARNING: Dangerous mode is enabled - all file operations will be auto-approved!`);
+        logger.consoleLog(`\n⚠️  WARNING: Dangerous mode is enabled - all file operations will be auto-approved!`);
     }
-    console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`);
+    logger.consoleLog(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`);
 }