@probelabs/probe 0.6.0-rc118 → 0.6.0-rc120

package/build/agent/ProbeAgent.js

@@ -8,7 +8,7 @@ import { randomUUID } from 'crypto';
 import { EventEmitter } from 'events';
 import { existsSync } from 'fs';
 import { readFile, stat } from 'fs/promises';
-import { resolve, isAbsolute } from 'path';
+import { resolve, isAbsolute, dirname } from 'path';
 import { TokenCounter } from './tokenCounter.js';
 import { 
   createTools,
@@ -145,12 +145,48 @@ export class ProbeAgent {
     // Initialize the AI model
     this.initializeModel();
 
+    // Note: MCP initialization is now done in initialize() method
+    // Constructor must remain synchronous for backward compatibility
+  }
+
+  /**
+   * Initialize the agent asynchronously (must be called after constructor)
+   * This method initializes MCP and merges MCP tools into the tool list
+   */
+  async initialize() {
     // Initialize MCP if enabled
     if (this.enableMcp) {
-      this.initializeMCP().catch(error => {
+      try {
+        await this.initializeMCP();
+
+        // Merge MCP tools into toolImplementations for unified access
+        if (this.mcpBridge) {
+          const mcpTools = this.mcpBridge.mcpTools || {};
+          for (const [toolName, toolImpl] of Object.entries(mcpTools)) {
+            this.toolImplementations[toolName] = toolImpl;
+          }
+        }
+
+        // Log all available tools after MCP initialization
+        if (this.debug) {
+          const allToolNames = Object.keys(this.toolImplementations);
+          const nativeToolCount = allToolNames.filter(name => !this.mcpBridge?.mcpTools?.[name]).length;
+          const mcpToolCount = allToolNames.length - nativeToolCount;
+
+          console.error('\n[DEBUG] ========================================');
+          console.error('[DEBUG] All Tools Initialized');
+          console.error(`[DEBUG] Native tools: ${nativeToolCount}, MCP tools: ${mcpToolCount}`);
+          console.error('[DEBUG] Available tools:');
+          for (const toolName of allToolNames) {
+            const isMCP = this.mcpBridge?.mcpTools?.[toolName] ? ' (MCP)' : '';
+            console.error(`[DEBUG]   - ${toolName}${isMCP}`);
+          }
+          console.error('[DEBUG] ========================================\n');
+        }
+      } catch (error) {
         console.error('[MCP] Failed to initialize MCP:', error);
         this.mcpBridge = null;
-      });
+      }
     }
   }
 
@@ -442,23 +478,62 @@ export class ProbeAgent {
   }
 
   /**
-   * Extract directory paths from listFiles tool output
+   * Extract directory paths from tool output (both listFiles and extract tool)
    * @param {string} content - Tool output content
    * @returns {string[]} - Array of directory paths
    */
   extractListFilesDirectories(content) {
     const directories = [];
 
-    // Pattern to match listFiles output format: "/path/to/directory:" at the start of a line
-    const dirPattern = /^([^\n:]+):\s*$/gm;
+    // Pattern 1: Extract directory from extract tool "File:" header
+    // Format: "File: /path/to/file.md" or "File: ./relative/path/file.md"
+    const fileHeaderPattern = /^File:\s+(.+)$/gm;
 
     let match;
+    while ((match = fileHeaderPattern.exec(content)) !== null) {
+      const filePath = match[1].trim();
+      // Get directory from file path
+      const dir = dirname(filePath);
+      if (dir && dir !== '.') {
+        directories.push(dir);
+        if (this.debug) {
+          console.log(`[DEBUG] Extracted directory context from File header: ${dir}`);
+        }
+      }
+    }
+
+    // Pattern 2: Extract directory from listFiles output format: "/path/to/directory:"
+    // Matches absolute paths (/path/to/dir:) or current directory markers (.:) or Windows paths (C:\path:) at start of line
+    // Very strict to avoid matching random text like ".Something:" or "./Some text:"
+    const dirPattern = /^(\/[^\n:]+|[A-Z]:\\[^\n:]+|\.\.?(?:\/[^\n:]+)?):\s*$/gm;
+
     while ((match = dirPattern.exec(content)) !== null) {
       const dirPath = match[1].trim();
-      if (dirPath && dirPath.length > 0) {
-        directories.push(dirPath);
-        if (this.debug) {
-          console.log(`[DEBUG] Extracted directory context from listFiles: ${dirPath}`);
+
+      // Strict validation: must look like an actual filesystem path
+      // Reject if contains spaces or other characters that wouldn't be in listFiles output
+      const hasInvalidChars = /\s/.test(dirPath); // Contains whitespace
+
+      // Validate this looks like an actual path, not random text
+      // Must be either: absolute path (Unix or Windows), or ./ or ../ followed by valid path chars
+      const isValidPath = (
+        !hasInvalidChars && (
+          dirPath.startsWith('/') ||  // Unix absolute path
+          /^[A-Z]:\\/.test(dirPath) || // Windows absolute path (C:\)
+          dirPath === '.' ||           // Current directory
+          dirPath === '..' ||          // Parent directory
+          (dirPath.startsWith('./') && dirPath.length > 2 && !dirPath.includes(' ')) ||   // ./something (no spaces)
+          (dirPath.startsWith('../') && dirPath.length > 3 && !dirPath.includes(' '))     // ../something (no spaces)
+        )
+      );
+
+      if (isValidPath) {
+        // Avoid duplicates
+        if (!directories.includes(dirPath)) {
+          directories.push(dirPath);
+          if (this.debug) {
+            console.log(`[DEBUG] Extracted directory context from listFiles: ${dirPath}`);
+          }
         }
       }
     }

package/build/agent/acp/server.js

@@ -31,12 +31,14 @@ class ACPSession {
   /**
    * Get or create ProbeAgent for this session
    */
-  getAgent(config = {}) {
+  async getAgent(config = {}) {
     if (!this.agent) {
       this.agent = new ProbeAgent({
         sessionId: this.id,
         ...config
       });
+      // Initialize MCP if enabled
+      await this.agent.initialize();
     }
     return this.agent;
   }
@@ -320,20 +322,23 @@ export class ACPServer {
     }
     
     session.touch();
-    
+
     // Get or create ProbeAgent for this session
-    const agent = session.getAgent({
+    const agent = await session.getAgent({
       path: this.options.path,
       provider: this.options.provider,
       model: this.options.model,
       allowEdit: this.options.allowEdit,
-      debug: this.options.debug
+      debug: this.options.debug,
+      enableMcp: this.options.enableMcp,
+      mcpConfig: this.options.mcpConfig,
+      mcpConfigPath: this.options.mcpConfigPath
     });
-    
+
     if (this.options.debug) {
       console.error(`[ACP] Processing prompt for session ${params.sessionId}:`, params.message.substring(0, 100));
     }
-    
+
     try {
       // Process the message with the ProbeAgent
       const response = await agent.answer(params.message);