centaurus-cli 2.3.0 → 2.5.0

package/dist/cli-adapter.js

@@ -2,7 +2,6 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
-import * as shellUtils from './utils/shell.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { ConfigManager } from './config/manager.js';
@@ -15,11 +14,16 @@ import { conversationManager } from './services/conversation-manager.js';
 import { aiServiceClient } from './services/ai-service-client.js';
 import { SUPPORTED_MODELS, getModelDisplayName, isValidModel, getInvalidModelError } from './config/models.js';
 import { authenticateWithGoogle } from './services/auth-handler.js';
+import { ContextManager } from './context/context-manager.js';
+import { CommandDetector } from './context/command-detector.js';
+import { SSHHandler } from './context/handlers/ssh-handler.js';
+import { WSLHandler } from './context/handlers/wsl-handler.js';
+import { DockerHandler } from './context/handlers/docker-handler.js';
+import { AIContextInjector } from './services/ai-context-injector.js';
 export class CentaurusCLI {
     configManager;
     toolRegistry;
     conversationHistory = [];
-    systemPrompt;
     cwd;
     planMode = false;
     commandMode = false;
@@ -34,12 +38,30 @@ export class CentaurusCLI {
     onToolStreamingOutput;
     onPlanModeChange;
     onPlanApprovalRequest;
+    onPasswordRequest;
     conversationStarted = false;
+    contextManager;
+    commandDetector;
+    aiContextInjector;
+    onSubshellContextChange;
     constructor() {
         this.configManager = new ConfigManager();
         this.toolRegistry = new ToolRegistry();
         this.cwd = process.cwd();
-        this.systemPrompt = this.loadSystemPrompt();
+        // Initialize Context Manager and Command Detector
+        this.contextManager = new ContextManager(this.cwd, process.platform);
+        this.commandDetector = new CommandDetector();
+        this.aiContextInjector = new AIContextInjector();
+        // Register context change callback to update cwd
+        this.contextManager.onContextChange((context) => {
+            this.cwd = context.metadata.workingDirectory;
+            if (this.onCwdChange) {
+                this.onCwdChange(this.cwd);
+            }
+            if (this.onSubshellContextChange) {
+                this.onSubshellContextChange(context);
+            }
+        });
     }
     setOnResponseCallback(callback) {
         this.onResponseCallback = callback;
@@ -71,6 +93,16 @@ export class CentaurusCLI {
     setOnCwdChange(callback) {
         this.onCwdChange = callback;
     }
+    setOnSubshellContextChange(callback) {
+        this.onSubshellContextChange = callback;
+    }
+    setOnPasswordRequest(callback) {
+        this.onPasswordRequest = callback;
+        // Update SSH handler if already initialized
+        if (this.sshHandler) {
+            this.sshHandler.setPasswordRequestCallback(callback);
+        }
+    }
     getPlanMode() {
         return this.planMode;
     }
@@ -80,6 +112,9 @@ export class CentaurusCLI {
     getCurrentWorkingDirectory() {
         return this.cwd;
     }
+    getCurrentSubshellContext() {
+        return this.contextManager.getCurrentContext();
+    }
     async handlePickerSelection(selection, pickerType) {
         try {
             // Validate and set model (ConfigManager will validate)
@@ -97,6 +132,7 @@ export class CentaurusCLI {
             }
         }
     }
+    sshHandler;
     async initialize() {
         // Register tools
         this.toolRegistry.register(readFileTool);
@@ -113,6 +149,16 @@ export class CentaurusCLI {
         if (apiClient.isAuthenticated()) {
             this.configManager.enableBackendSync();
         }
+        // Initialize subshell handlers
+        this.sshHandler = new SSHHandler();
+        this.contextManager.registerHandler('ssh', this.sshHandler);
+        this.commandDetector.registerHandler(this.sshHandler);
+        const wslHandler = new WSLHandler();
+        this.contextManager.registerHandler('wsl', wslHandler);
+        this.commandDetector.registerHandler(wslHandler);
+        const dockerHandler = new DockerHandler();
+        this.contextManager.registerHandler('docker', dockerHandler);
+        this.commandDetector.registerHandler(dockerHandler);
         // Note: No need to initialize AI provider - using backend proxy via aiServiceClient
     }
     /**
@@ -222,16 +268,17 @@ Press Enter to continue...
         });
         // Save user message to backend
         await this.saveMessageToBackend('user', message);
-        // Create messages array with system prompt
-        const systemContent = this.systemPrompt + this.getEnvironmentContext() + (this.planMode ? this.getPlanModeInstructions() : '');
-        let messages = [
-            { role: 'system', content: systemContent },
-            ...this.conversationHistory,
-        ];
+        // Create messages array WITHOUT system prompt
+        // Backend will inject the system prompt automatically
+        let messages = [...this.conversationHistory];
+        // Inject subshell context if in a subshell environment
+        const currentContext = this.contextManager.getCurrentContext();
+        messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
         try {
             const tools = this.toolRegistry.getSchemas();
             const context = {
                 cwd: this.cwd,
+                contextManager: this.contextManager,
                 requireApproval: async (message, risky, preview, operationType, operationDetails) => {
                     if (this.onToolApprovalRequest) {
                         return await this.onToolApprovalRequest({ message, risky, preview, operationType, operationDetails });
@@ -248,8 +295,11 @@ Press Enter to continue...
             // Get selected model from config
             const config = this.configManager.load();
             const selectedModel = config.model || 'gemini-2.0-flash-exp';
+            // Build environment context to send to backend
+            const environmentContext = this.getEnvironmentContext();
+            const mode = this.getMode();
             let finalAssistantMessage = '';
-            const MAX_TURNS = 10; // Prevent infinite loops
+            const MAX_TURNS = 100; // Allow up to 100 turns for complex tasks
             let turnCount = 0;
             // Multi-turn tool execution loop
             while (turnCount < MAX_TURNS) {
@@ -257,7 +307,8 @@ Press Enter to continue...
                 let assistantMessage = '';
                 let toolCalls = [];
                 // Stream AI response from backend
-                for await (const chunk of aiServiceClient.streamChat(selectedModel, messages, tools)) {
+                // Backend will inject system prompt automatically with environment context
+                for await (const chunk of aiServiceClient.streamChat(selectedModel, messages, tools, environmentContext, mode)) {
                     // Handle error chunks
                     if (chunk.type === 'error') {
                         throw new Error(chunk.message);
@@ -265,9 +316,13 @@ Press Enter to continue...
                     // Handle text chunks
                     if (chunk.type === 'text') {
                         assistantMessage += chunk.content;
-                        // Send chunk to UI in real-time
+                        // Send chunk to UI in real-time (but filter out completion marker)
                         if (this.onResponseStreamCallback) {
-                            this.onResponseStreamCallback(chunk.content);
+                            // Don't stream the completion marker to the UI
+                            const cleanChunk = chunk.content.replace(/<TASK_COMPLETE>/g, '');
+                            if (cleanChunk) {
+                                this.onResponseStreamCallback(cleanChunk);
+                            }
                         }
                     }
                     // Handle tool call chunks
@@ -279,19 +334,21 @@ Press Enter to continue...
                         break;
                     }
                 }
+                // Three-tier completion detection
+                // Tier 1: Check for explicit completion marker
+                if (this.hasCompletionMarker(assistantMessage)) {
+                    finalAssistantMessage = this.removeCompletionMarker(assistantMessage);
+                    break;
+                }
                 // If there are tool calls, execute them and continue loop
                 if (toolCalls.length > 0) {
                     const toolResults = [];
-                    for (const toolCall of toolCalls) {
+                    let userCancelledOperation = false;
+                    for (let i = 0; i < toolCalls.length; i++) {
+                        const toolCall = toolCalls[i];
                         try {
-                            // Notify UI: tool is executing
-                            if (this.onToolExecutionUpdate) {
-                                this.onToolExecutionUpdate({
-                                    toolName: toolCall.name,
-                                    status: 'executing',
-                                    arguments: toolCall.arguments
-                                });
-                            }
+                            // Execute the tool (it will request approval if needed)
+                            // Don't send 'executing' status here - it causes duplication with approval UI
                             const result = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
                             if (result.success) {
                                 // Notify UI: tool succeeded
@@ -303,13 +360,28 @@ Press Enter to continue...
                                         arguments: toolCall.arguments
                                     });
                                 }
+                                // Parse result if it's a string (avoid double-stringification)
+                                let parsedResult = result.result;
+                                if (typeof result.result === 'string') {
+                                    try {
+                                        parsedResult = JSON.parse(result.result);
+                                    }
+                                    catch {
+                                        // Keep as string if not valid JSON
+                                        parsedResult = result.result;
+                                    }
+                                }
                                 toolResults.push({
                                     tool_call_id: toolCall.id,
                                     name: toolCall.name,
-                                    content: result.result,
+                                    result: parsedResult,
                                 });
                             }
                             else {
+                                // Check if operation was cancelled by user
+                                if (result.error && result.error.includes('Operation cancelled by user')) {
+                                    userCancelledOperation = true;
+                                }
                                 // Notify UI: tool failed
                                 if (this.onToolExecutionUpdate) {
                                     this.onToolExecutionUpdate({
@@ -322,11 +394,19 @@ Press Enter to continue...
                                 toolResults.push({
                                     tool_call_id: toolCall.id,
                                     name: toolCall.name,
-                                    content: `Error: ${result.error}`,
+                                    result: `Error: ${result.error}`,
                                 });
+                                // If user cancelled, stop processing remaining tools
+                                if (userCancelledOperation) {
+                                    break;
+                                }
                             }
                         }
                         catch (error) {
+                            // Check if operation was cancelled by user
+                            if (error.message && error.message.includes('Operation cancelled by user')) {
+                                userCancelledOperation = true;
+                            }
                             // Notify UI: tool failed
                             if (this.onToolExecutionUpdate) {
                                 this.onToolExecutionUpdate({
@@ -339,42 +419,131 @@ Press Enter to continue...
                             toolResults.push({
                                 tool_call_id: toolCall.id,
                                 name: toolCall.name,
-                                content: `Error: ${error.message}`,
+                                result: `Error: ${error.message}`,
                             });
+                            // If user cancelled, stop processing remaining tools
+                            if (userCancelledOperation) {
+                                break;
+                            }
                         }
                     }
+                    // If user cancelled an operation, stop the agentic loop immediately
+                    if (userCancelledOperation) {
+                        // Add assistant message to history
+                        this.conversationHistory.push({
+                            role: 'assistant',
+                            content: assistantMessage || '',
+                        });
+                        // Add tool results to history
+                        for (const toolResult of toolResults) {
+                            const toolMessage = {
+                                tool_call_id: toolResult.tool_call_id,
+                                name: toolResult.name,
+                                result: toolResult.result,
+                            };
+                            this.conversationHistory.push({
+                                role: 'tool',
+                                content: JSON.stringify(toolMessage),
+                            });
+                        }
+                        // Set final message indicating cancellation
+                        finalAssistantMessage = 'Operation cancelled by user. The task was not completed.';
+                        break;
+                    }
                     // Add assistant message with tool calls to conversation history
                     this.conversationHistory.push({
                         role: 'assistant',
                         content: assistantMessage || '',
                     });
                     // Add tool results to conversation history as tool messages
+                    // Format: { tool_call_id, name, result: <object or string> }
+                    // Include system instruction to remind AI to continue if needed
                     for (const toolResult of toolResults) {
+                        const toolMessage = {
+                            tool_call_id: toolResult.tool_call_id,
+                            name: toolResult.name,
+                            result: toolResult.result,
+                            system_instruction: 'IMPORTANT: This tool executed successfully. If there are MORE steps needed to complete the task, continue executing the necessary tools. If the task is fully complete, respond with "<TASK_COMPLETE>" followed by a summary.'
+                        };
                         this.conversationHistory.push({
                             role: 'tool',
-                            content: JSON.stringify({
-                                tool_call_id: toolResult.tool_call_id,
-                                name: toolResult.name,
-                                result: toolResult.content,
-                            }),
+                            content: JSON.stringify(toolMessage),
                         });
                     }
                     // Rebuild messages array with updated history
-                    messages = [
-                        { role: 'system', content: systemContent },
-                        ...this.conversationHistory,
-                    ];
+                    // Backend will inject system prompt automatically
+                    messages = [...this.conversationHistory];
+                    // Re-inject subshell context for the next turn
+                    messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
+                    // Add delay between turns to prevent rate limiting
+                    await new Promise(resolve => setTimeout(resolve, 500));
                     // Continue to next turn to let AI process results
                     continue;
                 }
-                // No more tool calls - AI provided final response
+                // No tool calls - apply three-tier completion detection
                 if (assistantMessage) {
+                    // Tier 2: Check for strong completion phrases
+                    if (this.hasStrongCompletionPhrase(assistantMessage)) {
+                        finalAssistantMessage = assistantMessage;
+                        break;
+                    }
+                    // Tier 3: Check if response seems incomplete (only within first 15 turns)
+                    if (this.seemsIncomplete(assistantMessage, turnCount)) {
+                        // Add assistant message to history
+                        this.conversationHistory.push({
+                            role: 'assistant',
+                            content: assistantMessage,
+                        });
+                        // Add continuation prompt to messages
+                        const continuationPrompt = 'Continue with the remaining steps. Execute all necessary tools to complete the entire task.';
+                        this.conversationHistory.push({
+                            role: 'user',
+                            content: continuationPrompt,
+                        });
+                        // Rebuild messages array with continuation prompt
+                        messages = [...this.conversationHistory];
+                        // Re-inject subshell context for continuation
+                        messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
+                        // Add delay before continuation
+                        await new Promise(resolve => setTimeout(resolve, 500));
+                        // Continue loop to process continuation
+                        continue;
+                    }
+                    // Tier 3 fallback: Prompt AI for explicit completion (after turn 2)
+                    if (turnCount >= 2) {
+                        // Add assistant message to history
+                        this.conversationHistory.push({
+                            role: 'assistant',
+                            content: assistantMessage,
+                        });
+                        // Prompt AI to either continue or confirm completion
+                        const completionPrompt = 'Are there any remaining steps to complete this task? If yes, continue with them now. If the task is fully complete, respond with "<TASK_COMPLETE>" followed by a brief summary.';
+                        this.conversationHistory.push({
+                            role: 'user',
+                            content: completionPrompt,
+                        });
+                        // Rebuild messages array
+                        messages = [...this.conversationHistory];
+                        // Re-inject subshell context for completion check
+                        messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
+                        // Add delay before prompting
+                        await new Promise(resolve => setTimeout(resolve, 500));
+                        // Continue loop to get AI's response
+                        continue;
+                    }
+                    // Response seems complete (turn 1 or 2 without clear signals)
                     finalAssistantMessage = assistantMessage;
                     break;
                 }
                 // No tool calls and no message - something went wrong
                 break;
             }
+            // Check if max turns was reached
+            if (turnCount >= MAX_TURNS) {
+                // Add a warning message to the final response
+                const warningMessage = '\n\n⚠️ Note: The task reached the maximum number of processing turns. The work may be incomplete. Please review the results and let me know if you need me to continue.';
+                finalAssistantMessage = (finalAssistantMessage || 'Task processing limit reached.') + warningMessage;
+            }
             // Send final message to user (without tool execution logs)
             const finalMessage = finalAssistantMessage || 'Task completed.';
             // Save to conversation history
@@ -558,7 +727,11 @@ Press Enter to continue...
                 else {
                     // View config
                     const config = this.configManager.load();
+                    // Import version checker to get current version
+                    const { getCurrentVersion } = await import('./utils/version-checker.js');
+                    const currentVersion = getCurrentVersion();
                     responseMessage = `Current Configuration:\n\n` +
+                        `Version: ${currentVersion}\n` +
                         `Model: ${config.model || 'gemini-2.0-flash-exp (default)'}\n` +
                         `Authentication: ${apiClient.isAuthenticated() ? '✅ Signed in' : '❌ Not signed in'}`;
                 }
@@ -607,21 +780,134 @@ Press Enter to continue...
             this.onResponseCallback(responseMessage);
         }
     }
-    loadSystemPrompt() {
-        const promptPath = path.join(__dirname, '../prompts/centaurus-system-prompt.txt');
-        try {
-            return fs.readFileSync(promptPath, 'utf-8');
-        }
-        catch (error) {
-            return 'You are Centaurus, an AI coding assistant.';
-        }
-    }
+    /**
+     * Get environment context for backend
+     * Returns structured environment information to be sent to backend
+     */
     getEnvironmentContext() {
         const platform = process.platform;
         const isWindows = platform === 'win32';
         const homeDir = process.env.HOME || process.env.USERPROFILE || '~';
         const shell = process.env.SHELL || process.env.ComSpec || (isWindows ? 'cmd' : 'bash');
-        return `\n## Environment Context\n\nYou are running in the following environment:\n- **OS**: ${isWindows ? 'Windows' : platform === 'darwin' ? 'macOS' : 'Linux'} (${platform})\n- **Current Directory**: ${this.cwd}\n- **Home Directory**: ${homeDir}\n- **Shell**: ${shell}\n\n${isWindows ? 'Windows Environment: Use commands like dir, type, cd. Downloads folder is at ' + homeDir + '\\Downloads' : 'Unix Environment: Use ls, pwd, cat. Downloads folder is at ' + homeDir + '/Downloads'}`;
+        return {
+            os: isWindows ? 'windows' : platform === 'darwin' ? 'macos' : 'linux',
+            platform,
+            shell,
+            cwd: this.cwd,
+            homeDir,
+        };
+    }
+    /**
+     * Get current mode
+     * Returns the current mode (default, plan, or command)
+     */
+    getMode() {
+        if (this.commandMode)
+            return 'command';
+        if (this.planMode)
+            return 'plan';
+        return 'default';
+    }
+    /**
+     * Check if response contains completion marker
+     * Returns true if the <TASK_COMPLETE> marker is found in the text
+     */
+    hasCompletionMarker(text) {
+        return text.includes('<TASK_COMPLETE>');
+    }
+    /**
+     * Remove completion marker from text
+     * Strips the <TASK_COMPLETE> marker from display text
+     */
+    removeCompletionMarker(text) {
+        return text.replace(/<TASK_COMPLETE>/g, '').trim();
+    }
+    /**
+     * Check if response contains strong completion phrases
+     * Returns true if the text contains phrases that strongly indicate task completion
+     * Used as fallback when completion marker is not present
+     */
+    hasStrongCompletionPhrase(text) {
+        const strongCompletionPhrases = [
+            'task complete',
+            'task is complete',
+            'tasks complete',
+            'tasks are complete',
+            'all done',
+            'everything is done',
+            'everything is ready',
+            'everything is set up',
+            'everything is complete',
+            'all set',
+            'all finished',
+            'finished everything',
+            'completed everything',
+            'completed all',
+            'done with everything',
+            'implementation complete',
+            'implementation is complete',
+            'setup complete',
+            'setup is complete',
+            'all tasks completed',
+            'all steps completed',
+            'work is complete',
+            'work complete',
+            'fully implemented',
+            'fully complete',
+            'ready to use',
+            'ready to go',
+            'successfully completed',
+            'completed successfully'
+        ];
+        const lowerText = text.toLowerCase();
+        return strongCompletionPhrases.some(phrase => lowerText.includes(phrase));
+    }
+    /**
+     * Check if response seems incomplete
+     * Returns true if the text contains phrases that suggest the AI stopped prematurely
+     * Only triggers within first 15 turns to prevent infinite loops
+     */
+    seemsIncomplete(text, turnCount) {
+        // Only check for incomplete responses within first 15 turns
+        if (turnCount > 15) {
+            return false;
+        }
+        const incompletePhrases = [
+            'i created',
+            'i\'ve created',
+            'created the',
+            'i made',
+            'i\'ve made',
+            'i wrote',
+            'i\'ve written',
+            'next i',
+            'now i',
+            'i will',
+            'i\'ll',
+            'let me',
+            'i should',
+            'first',
+            'step 1',
+            'step 2',
+            'step 3',
+            'i\'ll create',
+            'i\'ll make',
+            'i\'ll write',
+            'i\'ll add',
+            'i\'ll implement',
+            'i need to',
+            'i\'ll need to',
+            'next step',
+            'following step',
+            'then i',
+            'after that',
+            'i\'m creating',
+            'i\'m making',
+            'i\'m writing',
+            'i\'m adding'
+        ];
+        const lowerText = text.toLowerCase();
+        return incompletePhrases.some(phrase => lowerText.includes(phrase));
     }
     getPlanModeInstructions() {
         return `\n\n## PLAN MODE ACTIVE\n\nYou are currently in PLAN MODE. In this mode, you should:\n\n1. **Explore the current directory** using list_directory and read_file tools to understand the codebase structure\n2. **Research the topic** using the web_search tool to gather best practices and implementation approaches\n3. **Create a detailed implementation plan** with ordered tasks\n\nWhen you've completed your planning, you MUST format your response in this EXACT format:\n\n<tasks>\n1. First task description\n2. Second task description\n3. Third task description\n...\n</tasks>\n\n<question>\nShall I proceed with implementing this plan?\n</question>\n\nIMPORTANT:\n- The <tasks> section must contain a numbered list of tasks in order\n- The <question> section must contain a yes/no question asking if you should proceed\n- Do NOT execute any implementation tasks in plan mode - only create the plan\n- Use tools to explore and research, but do not modify any files`;
@@ -682,54 +968,96 @@ Press Enter to continue...
             return;
         }
         try {
-            // Special handling for cd command - change the actual working directory
-            const cdMatch = command.match(/^cd\s+(.+)$/);
-            if (cdMatch) {
-                const targetDir = cdMatch[1].trim();
-                const newCwd = path.resolve(this.cwd, targetDir);
-                if (!fs.existsSync(newCwd)) {
+            // Check for exit command in subshell
+            if (command.trim() === 'exit') {
+                const currentContext = this.contextManager.getCurrentContext();
+                if (currentContext.type !== 'local') {
+                    // Disconnect from subshell
+                    if (currentContext.handler) {
+                        await currentContext.handler.disconnect();
+                    }
+                    // Pop context
+                    this.contextManager.popContext();
                     if (this.onResponseCallback) {
-                        this.onResponseCallback(`❌ Directory not found: ${targetDir}`);
+                        this.onResponseCallback('✅ Exited subshell');
                     }
                     return;
                 }
-                if (!fs.statSync(newCwd).isDirectory()) {
+            }
+            // Detect subshell commands
+            const detection = this.commandDetector.detect(command);
+            if (detection) {
+                // Show connecting message
+                if (this.onResponseCallback) {
+                    this.onResponseCallback(`🔄 Connecting to ${detection.handler.type} environment...`);
+                }
+                // Update connection state
+                this.contextManager.updateConnectionState('connecting');
+                try {
+                    // Connect to subshell
+                    const context = await detection.handler.connect(command, this.cwd);
+                    this.contextManager.pushContext(context);
+                    // Show success message
                     if (this.onResponseCallback) {
-                        this.onResponseCallback(`❌ Not a directory: ${targetDir}`);
+                        const breadcrumbs = detection.handler.getBreadcrumbs();
+                        const breadcrumbText = breadcrumbs.map(b => `${b.label}${b.value ? `: ${b.value}` : ''}`).join(' ');
+                        this.onResponseCallback(`✅ Connected to ${detection.handler.type} environment [${breadcrumbText}]`);
                     }
                     return;
                 }
-                this.cwd = newCwd;
-                // Notify UI of CWD change
-                if (this.onCwdChange) {
-                    this.onCwdChange(newCwd);
-                }
-                if (this.onResponseCallback) {
-                    this.onResponseCallback(`Changed directory to: ${newCwd}`);
+                catch (error) {
+                    // Connection failed
+                    this.contextManager.updateConnectionState('error');
+                    if (this.onResponseCallback) {
+                        this.onResponseCallback(`❌ Failed to connect: ${error.message}`);
+                    }
+                    return;
                 }
-                return;
             }
-            // Execute the command and stream output
-            const result = await shellUtils.executeCommand(command, this.cwd, (chunk, type) => {
-                // Stream output to UI
-                if (this.onToolStreamingOutput) {
-                    this.onToolStreamingOutput({ toolName: 'command_mode', chunk, type });
+            // Special handling for cd command - change the actual working directory
+            const cdMatch = command.match(/^cd\s+(.+)$/);
+            if (cdMatch) {
+                const currentContext = this.contextManager.getCurrentContext();
+                if (currentContext.type === 'local') {
+                    // Local cd handling
+                    const targetDir = cdMatch[1].trim();
+                    const newCwd = path.resolve(this.cwd, targetDir);
+                    if (!fs.existsSync(newCwd)) {
+                        if (this.onResponseCallback) {
+                            this.onResponseCallback(`❌ Directory not found: ${targetDir}`);
+                        }
+                        return;
+                    }
+                    if (!fs.statSync(newCwd).isDirectory()) {
+                        if (this.onResponseCallback) {
+                            this.onResponseCallback(`❌ Not a directory: ${targetDir}`);
+                        }
+                        return;
+                    }
+                    this.contextManager.updateWorkingDirectory(newCwd);
+                    if (this.onResponseCallback) {
+                        this.onResponseCallback(`Changed directory to: ${newCwd}`);
+                    }
+                    return;
                 }
-            });
-            // After command execution, check if directory changed (for commands like pushd, popd)
-            // Get current working directory using 'cd' command which prints current directory on Windows
-            try {
-                const pwdResult = await shellUtils.executeCommand('cd', this.cwd);
-                if (pwdResult.stdout && pwdResult.stdout.trim()) {
-                    const newCwd = pwdResult.stdout.trim();
-                    if (newCwd !== this.cwd && fs.existsSync(newCwd)) {
-                        this.cwd = newCwd;
+                else {
+                    // Subshell cd handling - execute via handler
+                    const result = await this.contextManager.executeCommand(command);
+                    if (result.exitCode === 0) {
+                        if (this.onResponseCallback) {
+                            this.onResponseCallback(`Changed directory to: ${currentContext.metadata.workingDirectory}`);
+                        }
                     }
+                    else {
+                        if (this.onResponseCallback) {
+                            this.onResponseCallback(`❌ ${result.stderr || 'Failed to change directory'}`);
+                        }
+                    }
+                    return;
                 }
             }
-            catch (error) {
-                // Ignore errors when checking pwd
-            }
+            // Execute the command through Context Manager
+            const result = await this.contextManager.executeCommand(command);
             // Format and send the result
             let output = '';
             if (result.stdout && result.stdout.trim()) {