@probelabs/probe 0.6.0-rc121 → 0.6.0-rc122

package/build/agent/mcp/config.js

@@ -51,8 +51,8 @@ export function loadMCPConfigurationFromPath(configPath) {
     const content = readFileSync(configPath, 'utf8');
     const config = JSON.parse(content);
 
-    if (process.env.DEBUG === '1') {
-      console.error(`[MCP] Loaded configuration from: ${configPath}`);
+    if (process.env.DEBUG === '1' || process.env.DEBUG_MCP === '1') {
+      console.error(`[MCP DEBUG] Loaded configuration from: ${configPath}`);
     }
 
     // Merge with environment variable overrides
@@ -94,12 +94,12 @@ export function loadMCPConfiguration() {
       try {
         const content = readFileSync(configPath, 'utf8');
         config = JSON.parse(content);
-        if (process.env.DEBUG === '1') {
-          console.error(`[MCP] Loaded configuration from: ${configPath}`);
+        if (process.env.DEBUG === '1' || process.env.DEBUG_MCP === '1') {
+          console.error(`[MCP DEBUG] Loaded configuration from: ${configPath}`);
         }
         break;
       } catch (error) {
-        console.error(`[MCP] Failed to parse config from ${configPath}:`, error.message);
+        console.error(`[MCP ERROR] Failed to parse config from ${configPath}:`, error.message);
       }
     }
   }
@@ -209,12 +209,12 @@ export function parseEnabledServers(config) {
     // Validate required fields based on transport
     if (server.transport === 'stdio') {
       if (!server.command) {
-        console.error(`[MCP] Server ${name} missing required 'command' for stdio transport`);
+        console.error(`[MCP ERROR] Server ${name} missing required 'command' for stdio transport`);
         continue;
       }
     } else if (['websocket', 'sse', 'http'].includes(server.transport)) {
       if (!server.url) {
-        console.error(`[MCP] Server ${name} missing required 'url' for ${server.transport} transport`);
+        console.error(`[MCP ERROR] Server ${name} missing required 'url' for ${server.transport} transport`);
         continue;
       }
     }
@@ -301,7 +301,7 @@ export function saveConfig(config, path) {
   }
 
   writeFileSync(path, JSON.stringify(config, null, 2), 'utf8');
-  console.log(`[MCP] Configuration saved to: ${path}`);
+  console.error(`[MCP INFO] Configuration saved to: ${path}`);
 }
 
 export default {

package/build/agent/mcp/xmlBridge.js

@@ -141,23 +141,44 @@ export class MCPXmlBridge {
 
     if (!config) {
       // No config provided - fall back to auto-discovery for backward compatibility
+      if (this.debug) {
+        console.error('[MCP DEBUG] No config provided, attempting auto-discovery...');
+      }
       mcpConfigs = loadMCPConfiguration();
+
+      // Check if auto-discovery found anything
+      if (!mcpConfigs || !mcpConfigs.mcpServers || Object.keys(mcpConfigs.mcpServers).length === 0) {
+        console.error('[MCP WARNING] MCP enabled but no configuration found');
+        console.error('[MCP INFO] To use MCP, provide configuration via:');
+        console.error('[MCP INFO]   - mcpConfig option when creating ProbeAgent');
+        console.error('[MCP INFO]   - mcpConfigPath option pointing to a config file');
+        console.error('[MCP INFO]   - Config file in standard locations (~/.mcp/config.json, etc.)');
+        console.error('[MCP INFO]   - Environment variable MCP_CONFIG_PATH');
+      }
     } else if (Array.isArray(config)) {
       // Deprecated: Array of server configs (backward compatibility)
+      if (this.debug) {
+        console.error('[MCP DEBUG] Using deprecated array config format (consider using mcpConfig object)');
+      }
       mcpConfigs = { mcpServers: config };
     } else {
       // New: Full config object provided directly
+      if (this.debug) {
+        console.error('[MCP DEBUG] Using provided MCP config object');
+      }
       mcpConfigs = config;
     }
 
     if (!mcpConfigs || !mcpConfigs.mcpServers || Object.keys(mcpConfigs.mcpServers).length === 0) {
-      if (this.debug) {
-        console.error('[MCP] No MCP servers configured');
-      }
+      console.error('[MCP INFO] 0 MCP tools available');
       return;
     }
 
     try {
+      if (this.debug) {
+        console.error('[MCP DEBUG] Initializing MCP client manager...');
+      }
+
       // Initialize the MCP client manager
       this.mcpManager = new MCPClientManager({ debug: this.debug });
       const result = await this.mcpManager.initialize(mcpConfigs);
@@ -165,17 +186,27 @@ export class MCPXmlBridge {
       // Get tools from the manager
       const vercelTools = this.mcpManager.getVercelTools();
       this.mcpTools = vercelTools;
+      const toolCount = Object.keys(vercelTools).length;
 
       // Generate XML definitions for all tools
       for (const [name, tool] of Object.entries(vercelTools)) {
         this.xmlDefinitions[name] = mcpToolToXmlDefinition(name, tool);
       }
 
-      if (this.debug) {
-        console.error(`[MCP] Loaded ${Object.keys(vercelTools).length} MCP tools from ${result.connected} server(s)`);
+      if (toolCount === 0) {
+        console.error('[MCP INFO] MCP initialization complete: 0 tools loaded');
+      } else {
+        console.error(`[MCP INFO] MCP initialization complete: ${toolCount} tool${toolCount !== 1 ? 's' : ''} loaded from ${result.connected} server${result.connected !== 1 ? 's' : ''}`);
+
+        if (this.debug) {
+          console.error('[MCP DEBUG] Tool definitions generated for XML bridge');
+        }
       }
     } catch (error) {
-      console.error('[MCP] Failed to initialize MCP connections:', error);
+      console.error('[MCP ERROR] Failed to initialize MCP connections:', error.message);
+      if (this.debug) {
+        console.error('[MCP DEBUG] Full error details:', error);
+      }
     }
   }
 
@@ -204,28 +235,42 @@ export class MCPXmlBridge {
     const parsed = parseXmlMcpToolCall(xmlString, this.getToolNames());
 
     if (!parsed) {
+      console.error('[MCP ERROR] No valid MCP tool call found in XML');
       throw new Error('No valid MCP tool call found in XML');
     }
 
     const { toolName, params } = parsed;
 
     if (this.debug) {
-      console.error(`[MCP] Executing MCP tool: ${toolName} with params:`, params);
+      console.error(`[MCP DEBUG] Executing MCP tool: ${toolName}`);
+      console.error(`[MCP DEBUG] Parameters:`, JSON.stringify(params, null, 2));
     }
 
     const tool = this.mcpTools[toolName];
     if (!tool) {
+      console.error(`[MCP ERROR] Unknown MCP tool: ${toolName}`);
+      console.error(`[MCP ERROR] Available tools: ${this.getToolNames().join(', ')}`);
       throw new Error(`Unknown MCP tool: ${toolName}`);
     }
 
     try {
       const result = await tool.execute(params);
+
+      if (this.debug) {
+        console.error(`[MCP DEBUG] Tool ${toolName} executed successfully`);
+      }
+
       return {
         success: true,
         toolName,
         result
       };
     } catch (error) {
+      console.error(`[MCP ERROR] Tool ${toolName} execution failed:`, error.message);
+      if (this.debug) {
+        console.error(`[MCP DEBUG] Full error details:`, error);
+      }
+
       return {
         success: false,
         toolName,

package/build/agent/schemaUtils.js

@@ -40,7 +40,7 @@ export function decodeHtmlEntities(text) {
 
 /**
  * Clean AI response by extracting JSON content when response contains JSON
- * Only processes responses that contain JSON structures { or [ 
+ * Only processes responses that contain JSON structures { or [
  * @param {string} response - Raw AI response
  * @returns {string} - Cleaned response with JSON boundaries extracted if applicable
  */
@@ -50,34 +50,47 @@ export function cleanSchemaResponse(response) {
   }
 
   const trimmed = response.trim();
-  
-  // First, look for JSON after code block markers
+
+  // First, look for JSON after code block markers - similar to mermaid extraction
+  // Try with json language specifier
+  const jsonBlockMatch = trimmed.match(/```json\s*\n([\s\S]*?)\n```/);
+  if (jsonBlockMatch) {
+    return jsonBlockMatch[1].trim();
+  }
+
+  // Try any code block with JSON content
+  const anyBlockMatch = trimmed.match(/```\s*\n([{\[][\s\S]*?[}\]])\s*```/);
+  if (anyBlockMatch) {
+    return anyBlockMatch[1].trim();
+  }
+
+  // Legacy patterns for more specific matching
   const codeBlockPatterns = [
     /```json\s*\n?([{\[][\s\S]*?[}\]])\s*\n?```/,
     /```\s*\n?([{\[][\s\S]*?[}\]])\s*\n?```/,
     /`([{\[][\s\S]*?[}\]])`/
   ];
-  
+
   for (const pattern of codeBlockPatterns) {
     const match = trimmed.match(pattern);
     if (match) {
       return match[1].trim();
     }
   }
-  
+
   // Look for code block start followed immediately by JSON
   const codeBlockStartPattern = /```(?:json)?\s*\n?\s*([{\[])/;
   const codeBlockMatch = trimmed.match(codeBlockStartPattern);
-  
+
   if (codeBlockMatch) {
     const startIndex = codeBlockMatch.index + codeBlockMatch[0].length - 1; // Position of the bracket
-    
+
     // Find the matching closing bracket
     const openChar = codeBlockMatch[1];
     const closeChar = openChar === '{' ? '}' : ']';
     let bracketCount = 1;
     let endIndex = startIndex + 1;
-    
+
     while (endIndex < trimmed.length && bracketCount > 0) {
       const char = trimmed[endIndex];
       if (char === openChar) {
@@ -87,36 +100,36 @@ export function cleanSchemaResponse(response) {
       }
       endIndex++;
     }
-    
+
     if (bracketCount === 0) {
       return trimmed.substring(startIndex, endIndex);
     }
   }
-  
+
   // Fallback: Find JSON boundaries anywhere in the text
   const firstBracket = Math.min(
     trimmed.indexOf('{') >= 0 ? trimmed.indexOf('{') : Infinity,
     trimmed.indexOf('[') >= 0 ? trimmed.indexOf('[') : Infinity
   );
-  
+
   const lastBracket = Math.max(
     trimmed.lastIndexOf('}'),
     trimmed.lastIndexOf(']')
   );
-  
+
   // Only extract if we found valid JSON boundaries
   if (firstBracket < Infinity && lastBracket >= 0 && firstBracket < lastBracket) {
     // Check if the response likely starts with JSON (directly or after minimal content)
     const beforeFirstBracket = trimmed.substring(0, firstBracket).trim();
-    
+
     // If there's minimal content before the first bracket, extract the JSON
-    if (beforeFirstBracket === '' || 
+    if (beforeFirstBracket === '' ||
         beforeFirstBracket.match(/^```\w*$/) ||
         beforeFirstBracket.split('\n').length <= 2) {
       return trimmed.substring(firstBracket, lastBracket + 1);
     }
   }
-  
+
   return response; // Return original if no extractable JSON found
 }
 

package/build/grep.js

@@ -0,0 +1,152 @@
+/**
+ * Grep functionality for the probe package
+ * @module grep
+ */
+
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { getBinaryPath } from './utils.js';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Flag mapping for grep options
+ * Maps option keys to command-line flags
+ */
+const GREP_FLAG_MAP = {
+	ignoreCase: '-i',
+	lineNumbers: '-n',
+	count: '-c',
+	filesWithMatches: '-l',
+	filesWithoutMatches: '-L',
+	invertMatch: '-v',
+	beforeContext: '-B',
+	afterContext: '-A',
+	context: '-C',
+	noGitignore: '--no-gitignore',
+	color: '--color',
+	maxCount: '-m'
+};
+
+/**
+ * Standard grep-style search across files (works with any file type, not just code)
+ *
+ * This provides a cross-platform grep interface that works on any OS and file type.
+ * Use this for searching non-code files (logs, config files, text files, etc.) that
+ * are not supported by probe's semantic search.
+ *
+ * For code files, prefer using the `search()` function which provides semantic,
+ * AST-aware search capabilities.
+ *
+ * @param {Object} options - Grep options
+ * @param {string} options.pattern - Pattern to search for (regex)
+ * @param {string|string[]} options.paths - Path(s) to search in
+ * @param {boolean} [options.ignoreCase] - Case-insensitive search (-i)
+ * @param {boolean} [options.lineNumbers] - Show line numbers (-n)
+ * @param {boolean} [options.count] - Only show count of matches (-c)
+ * @param {boolean} [options.filesWithMatches] - Only show filenames with matches (-l)
+ * @param {boolean} [options.filesWithoutMatches] - Only show filenames without matches (-L)
+ * @param {boolean} [options.invertMatch] - Invert match, show non-matching lines (-v)
+ * @param {number} [options.beforeContext] - Lines of context before match (-B)
+ * @param {number} [options.afterContext] - Lines of context after match (-A)
+ * @param {number} [options.context] - Lines of context before and after match (-C)
+ * @param {boolean} [options.noGitignore] - Don't respect .gitignore files (--no-gitignore)
+ * @param {string} [options.color] - Colorize output: 'always', 'never', 'auto' (--color)
+ * @param {number} [options.maxCount] - Stop after N matches per file (-m)
+ * @param {Object} [options.binaryOptions] - Options for getting the binary
+ * @param {boolean} [options.binaryOptions.forceDownload] - Force download even if binary exists
+ * @param {string} [options.binaryOptions.version] - Specific version to download
+ * @returns {Promise<string>} - Grep results as string
+ * @throws {Error} If the grep operation fails
+ *
+ * @example
+ * // Search for "error" in log files (case-insensitive)
+ * const results = await grep({
+ *   pattern: 'error',
+ *   paths: '/var/log',
+ *   ignoreCase: true,
+ *   lineNumbers: true
+ * });
+ *
+ * @example
+ * // Count occurrences of "TODO" in project
+ * const count = await grep({
+ *   pattern: 'TODO',
+ *   paths: '.',
+ *   count: true
+ * });
+ *
+ * @example
+ * // Find files containing "config" with context
+ * const matches = await grep({
+ *   pattern: 'config',
+ *   paths: '/etc',
+ *   context: 2,
+ *   filesWithMatches: true
+ * });
+ */
+export async function grep(options) {
+	if (!options || !options.pattern) {
+		throw new Error('Pattern is required');
+	}
+
+	if (!options.paths) {
+		throw new Error('Path(s) are required');
+	}
+
+	// Get the binary path
+	const binaryPath = await getBinaryPath(options.binaryOptions || {});
+
+	// Build CLI arguments array for grep subcommand
+	// Using an array prevents command injection vulnerabilities
+	const cliArgs = ['grep'];
+
+	// Add flags from GREP_FLAG_MAP
+	for (const [key, flag] of Object.entries(GREP_FLAG_MAP)) {
+		const value = options[key];
+		if (value === undefined || value === null) continue;
+
+		if (typeof value === 'boolean' && value) {
+			// Boolean flag
+			cliArgs.push(flag);
+		} else if (typeof value === 'number') {
+			// Numeric option
+			cliArgs.push(flag, String(value));
+		} else if (typeof value === 'string') {
+			// String option (like color)
+			cliArgs.push(flag, value);
+		}
+	}
+
+	// Add pattern (no need to escape - execFile handles it securely)
+	cliArgs.push(options.pattern);
+
+	// Add paths (can be single string or array)
+	const paths = Array.isArray(options.paths) ? options.paths : [options.paths];
+	cliArgs.push(...paths);
+
+	try {
+		// Use execFile instead of exec to prevent command injection
+		// execFile does not spawn a shell and passes arguments as an array
+		const { stdout, stderr } = await execFileAsync(binaryPath, cliArgs, {
+			maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+			env: {
+				...process.env,
+				// Disable colors in stderr for cleaner output
+				NO_COLOR: '1'
+			}
+		});
+
+		// Return stdout (grep results)
+		return stdout;
+	} catch (error) {
+		// Grep exit code 1 means "no matches found", which is not an error
+		if (error.code === 1 && !error.stderr) {
+			return error.stdout || '';
+		}
+
+		// Other errors are real failures
+		const errorMessage = error.stderr || error.message || 'Unknown error';
+		throw new Error(`Grep failed: ${errorMessage}`);
+	}
+}

package/build/index.js

@@ -10,6 +10,7 @@
 import { search } from './search.js';
 import { query } from './query.js';
 import { extract } from './extract.js';
+import { grep } from './grep.js';
 import { delegate } from './delegate.js';
 import { getBinaryPath, setBinaryPath } from './utils.js';
 import * as tools from './tools/index.js';
@@ -40,6 +41,7 @@ export {
 	search,
 	query,
 	extract,
+	grep,
 	delegate,
 	getBinaryPath,
 	setBinaryPath,