@probelabs/probe 0.6.0-rc118 → 0.6.0-rc120

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc118",
+  "version": "0.6.0-rc120",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",
@@ -80,7 +80,7 @@
     "@opentelemetry/sdk-node": "^0.203.0",
     "@opentelemetry/sdk-trace-base": "^1.30.0",
     "@opentelemetry/semantic-conventions": "^1.36.0",
-    "@probelabs/maid": "^0.0.7",
+    "@probelabs/maid": "^0.0.8",
     "ai": "^5.0.0",
     "axios": "^1.8.3",
     "fs-extra": "^11.1.1",

package/src/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/src/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);

package/src/agent/index.js

@@ -428,6 +428,8 @@ class ProbeAgentMcpServer {
           };
 
           this.agent = new ProbeAgent(agentConfig);
+          // Initialize MCP if enabled
+          await this.agent.initialize();
         }
 
         const agent = this.agent;
@@ -717,7 +719,9 @@ async function main() {
     };
 
     const agent = new ProbeAgent(agentConfig);
-    
+    // Initialize MCP if enabled
+    await agent.initialize();
+
     // Execute with tracing if available
     let result;
     if (appTracer) {

package/src/agent/mcp/client.js

@@ -242,11 +242,25 @@ export class MCPClientManager {
         console.error(`[MCP] Calling ${toolName} with args:`, args);
       }
 
-      const result = await clientInfo.client.callTool({
-        name: tool.originalName,
-        arguments: args
+      // Get timeout from config (default 30 seconds)
+      const timeout = this.config?.settings?.timeout || 30000;
+
+      // Create a timeout promise
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+          reject(new Error(`MCP tool call timeout after ${timeout}ms`));
+        }, timeout);
       });
 
+      // Race between the actual call and timeout
+      const result = await Promise.race([
+        clientInfo.client.callTool({
+          name: tool.originalName,
+          arguments: args
+        }),
+        timeoutPromise
+      ]);
+
       return result;
     } catch (error) {
       console.error(`[MCP] Error calling tool ${toolName}:`, error);

package/src/agent/schemaUtils.js

@@ -562,15 +562,18 @@ export async function validateMermaidDiagram(diagram) {
     const result = validate(diagram);
 
     // Maid returns { type: string, errors: array }
-    // Valid if errors array is empty
-    if (result.errors && result.errors.length === 0) {
+    // Only count actual errors (severity: 'error'), not warnings
+    const actualErrors = (result.errors || []).filter(err => err.severity === 'error');
+
+    // Valid if no actual errors (warnings are OK)
+    if (actualErrors.length === 0) {
       return {
         isValid: true,
         diagramType: result.type || 'unknown'
       };
     } else {
       // Format maid errors into a readable error message
-      const errorMessages = (result.errors || []).map(err => {
+      const errorMessages = actualErrors.map(err => {
         const location = err.line ? `line ${err.line}${err.column ? `:${err.column}` : ''}` : '';
         return location ? `${location} - ${err.message}` : err.message;
       });
@@ -580,7 +583,7 @@ export async function validateMermaidDiagram(diagram) {
         diagramType: result.type || 'unknown',
         error: errorMessages[0] || 'Validation failed',
         detailedError: errorMessages.join('\n'),
-        errors: result.errors || [] // Include raw maid errors for AI fixing
+        errors: actualErrors // Include only actual errors for AI fixing
       };
     }