@probelabs/probe 0.6.0-rc121 → 0.6.0-rc122

package/cjs/index.cjs

@@ -1136,6 +1136,74 @@ var init_extract = __esm({
   }
 });
 
+// src/grep.js
+async function grep(options) {
+  if (!options || !options.pattern) {
+    throw new Error("Pattern is required");
+  }
+  if (!options.paths) {
+    throw new Error("Path(s) are required");
+  }
+  const binaryPath = await getBinaryPath(options.binaryOptions || {});
+  const cliArgs = ["grep"];
+  for (const [key, flag] of Object.entries(GREP_FLAG_MAP)) {
+    const value = options[key];
+    if (value === void 0 || value === null) continue;
+    if (typeof value === "boolean" && value) {
+      cliArgs.push(flag);
+    } else if (typeof value === "number") {
+      cliArgs.push(flag, String(value));
+    } else if (typeof value === "string") {
+      cliArgs.push(flag, value);
+    }
+  }
+  cliArgs.push(options.pattern);
+  const paths = Array.isArray(options.paths) ? options.paths : [options.paths];
+  cliArgs.push(...paths);
+  try {
+    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;
+  } catch (error2) {
+    if (error2.code === 1 && !error2.stderr) {
+      return error2.stdout || "";
+    }
+    const errorMessage = error2.stderr || error2.message || "Unknown error";
+    throw new Error(`Grep failed: ${errorMessage}`);
+  }
+}
+var import_child_process5, import_util5, execFileAsync, GREP_FLAG_MAP;
+var init_grep = __esm({
+  "src/grep.js"() {
+    "use strict";
+    import_child_process5 = require("child_process");
+    import_util5 = require("util");
+    init_utils();
+    execFileAsync = (0, import_util5.promisify)(import_child_process5.execFile);
+    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"
+    };
+  }
+});
+
 // src/tools/common.js
 function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
   for (const toolName of validTools) {
@@ -1619,7 +1687,7 @@ async function delegate({ task, timeout = 300, debug = false, currentIteration =
     }
     return new Promise((resolve4, reject2) => {
       const delegationSpan = tracer ? tracer.createDelegationSpan(sessionId, task) : null;
-      const process2 = (0, import_child_process5.spawn)(binaryPath, args, {
+      const process2 = (0, import_child_process6.spawn)(binaryPath, args, {
         stdio: ["pipe", "pipe", "pipe"],
         timeout: timeout * 1e3
       });
@@ -1754,11 +1822,11 @@ async function delegate({ task, timeout = 300, debug = false, currentIteration =
     throw new Error(`Delegation setup failed: ${error2.message}`);
   }
 }
-var import_child_process5, import_crypto2;
+var import_child_process6, import_crypto2;
 var init_delegate = __esm({
   "src/delegate.js"() {
     "use strict";
-    import_child_process5 = require("child_process");
+    import_child_process6 = require("child_process");
     import_crypto2 = require("crypto");
     init_utils();
     init_common();
@@ -2834,7 +2902,7 @@ async function executeBashCommand(command, options = {}) {
       return;
     }
     const [cmd, ...cmdArgs] = args;
-    const child = (0, import_child_process6.spawn)(cmd, cmdArgs, {
+    const child = (0, import_child_process7.spawn)(cmd, cmdArgs, {
       cwd,
       env: processEnv,
       stdio: ["ignore", "pipe", "pipe"],
@@ -3018,11 +3086,11 @@ function validateExecutionOptions(options = {}) {
     warnings
   };
 }
-var import_child_process6, import_path4, import_fs;
+var import_child_process7, import_path4, import_fs;
 var init_bashExecutor = __esm({
   "src/agent/bashExecutor.js"() {
     "use strict";
-    import_child_process6 = require("child_process");
+    import_child_process7 = require("child_process");
     import_path4 = require("path");
     import_fs = require("fs");
     init_bashCommandUtils();
@@ -3547,15 +3615,15 @@ function shouldIgnore(filePath, ignorePatterns) {
   }
   return false;
 }
-var import_fs2, import_path6, import_util5, import_child_process7, execAsync4;
+var import_fs2, import_path6, import_util6, import_child_process8, execAsync4;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
     import_fs2 = __toESM(require("fs"), 1);
     import_path6 = __toESM(require("path"), 1);
-    import_util5 = require("util");
-    import_child_process7 = require("child_process");
-    execAsync4 = (0, import_util5.promisify)(import_child_process7.exec);
+    import_util6 = require("util");
+    import_child_process8 = require("child_process");
+    execAsync4 = (0, import_util6.promisify)(import_child_process8.exec);
   }
 });
 
@@ -24865,8 +24933,8 @@ var require_dist_cjs59 = __commonJS({
     module2.exports = __toCommonJS2(index_exports2);
     var import_property_provider2 = require_dist_cjs24();
     var import_shared_ini_file_loader = require_dist_cjs42();
-    var import_child_process9 = require("child_process");
-    var import_util9 = require("util");
+    var import_child_process10 = require("child_process");
+    var import_util10 = require("util");
     var import_client7 = (init_client(), __toCommonJS(client_exports));
     var getValidatedProcessCredentials = /* @__PURE__ */ __name((profileName, data2, profiles) => {
       if (data2.Version !== 1) {
@@ -24902,7 +24970,7 @@ var require_dist_cjs59 = __commonJS({
       if (profiles[profileName]) {
         const credentialProcess = profile["credential_process"];
         if (credentialProcess !== void 0) {
-          const execPromise = (0, import_util9.promisify)(import_shared_ini_file_loader.externalDataInterceptor?.getTokenRecord?.().exec ?? import_child_process9.exec);
+          const execPromise = (0, import_util10.promisify)(import_shared_ini_file_loader.externalDataInterceptor?.getTokenRecord?.().exec ?? import_child_process10.exec);
           try {
             const { stdout } = await execPromise(credentialProcess);
             let data2;
@@ -31340,13 +31408,13 @@ function createWrappedTools(baseTools) {
   }
   return wrappedTools;
 }
-var import_child_process8, import_util8, import_crypto4, import_events, import_fs3, import_fs4, import_path7, import_glob, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
+var import_child_process9, import_util9, import_crypto4, import_events, import_fs3, import_fs4, import_path7, import_glob, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
 var init_probeTool = __esm({
   "src/agent/probeTool.js"() {
     "use strict";
     init_index();
-    import_child_process8 = require("child_process");
-    import_util8 = require("util");
+    import_child_process9 = require("child_process");
+    import_util9 = require("util");
     import_crypto4 = require("crypto");
     import_events = require("events");
     import_fs3 = __toESM(require("fs"), 1);
@@ -60493,6 +60561,14 @@ function cleanSchemaResponse(response) {
     return response;
   }
   const trimmed = response.trim();
+  const jsonBlockMatch = trimmed.match(/```json\s*\n([\s\S]*?)\n```/);
+  if (jsonBlockMatch) {
+    return jsonBlockMatch[1].trim();
+  }
+  const anyBlockMatch = trimmed.match(/```\s*\n([{\[][\s\S]*?[}\]])\s*```/);
+  if (anyBlockMatch) {
+    return anyBlockMatch[1].trim();
+  }
   const codeBlockPatterns = [
     /```json\s*\n?([{\[][\s\S]*?[}\]])\s*\n?```/,
     /```\s*\n?([{\[][\s\S]*?[}\]])\s*\n?```/,
@@ -61305,8 +61381,8 @@ function loadMCPConfigurationFromPath(configPath) {
   try {
     const content = (0, import_fs5.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}`);
     }
     return mergeWithEnvironment(config);
   } catch (error2) {
@@ -61332,12 +61408,12 @@ function loadMCPConfiguration() {
       try {
         const content = (0, import_fs5.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 (error2) {
-        console.error(`[MCP] Failed to parse config from ${configPath}:`, error2.message);
+        console.error(`[MCP ERROR] Failed to parse config from ${configPath}:`, error2.message);
       }
     }
   }
@@ -61413,12 +61489,12 @@ function parseEnabledServers(config) {
     }
     if (server.transport === "stdio") {
       if (!server.command) {
-        console.error(`[MCP] Server ${name14} missing required 'command' for stdio transport`);
+        console.error(`[MCP ERROR] Server ${name14} missing required 'command' for stdio transport`);
         continue;
       }
     } else if (["websocket", "sse", "http"].includes(server.transport)) {
       if (!server.url) {
-        console.error(`[MCP] Server ${name14} missing required 'url' for ${server.transport} transport`);
+        console.error(`[MCP ERROR] Server ${name14} missing required 'url' for ${server.transport} transport`);
         continue;
       }
     }
@@ -61549,20 +61625,45 @@ var init_client2 = __esm({
       async initialize(config = null) {
         this.config = config || loadMCPConfiguration();
         const servers = parseEnabledServers(this.config);
+        console.error(`[MCP INFO] Found ${servers.length} enabled MCP server${servers.length !== 1 ? "s" : ""}`);
+        if (servers.length === 0) {
+          console.error("[MCP INFO] No MCP servers configured or enabled");
+          console.error("[MCP INFO] 0 MCP tools available");
+          return {
+            connected: 0,
+            total: 0,
+            tools: []
+          };
+        }
         if (this.debug) {
-          console.error(`[MCP] Found ${servers.length} enabled servers`);
+          console.error("[MCP DEBUG] Server details:");
+          servers.forEach((server) => {
+            console.error(`[MCP DEBUG]   - ${server.name} (${server.transport})`);
+          });
         }
         const connectionPromises = servers.map(
           (server) => this.connectToServer(server).catch((error2) => {
-            console.error(`[MCP] Failed to connect to ${server.name}:`, error2.message);
+            console.error(`[MCP ERROR] Failed to connect to ${server.name}:`, error2.message);
             return null;
           })
         );
         const results = await Promise.all(connectionPromises);
         const connectedCount = results.filter(Boolean).length;
-        if (this.debug) {
-          console.error(`[MCP] Successfully connected to ${connectedCount}/${servers.length} servers`);
-          console.error(`[MCP] Total tools available: ${this.tools.size}`);
+        if (connectedCount === 0) {
+          console.error(`[MCP ERROR] Failed to connect to all ${servers.length} server${servers.length !== 1 ? "s" : ""}`);
+          console.error("[MCP INFO] 0 MCP tools available");
+        } else if (connectedCount < servers.length) {
+          console.error(`[MCP INFO] Successfully connected to ${connectedCount}/${servers.length} servers`);
+          console.error(`[MCP INFO] ${this.tools.size} MCP tool${this.tools.size !== 1 ? "s" : ""} available`);
+        } else {
+          console.error(`[MCP INFO] Successfully connected to all ${connectedCount} server${connectedCount !== 1 ? "s" : ""}`);
+          console.error(`[MCP INFO] ${this.tools.size} MCP tool${this.tools.size !== 1 ? "s" : ""} available`);
+        }
+        if (this.debug && this.tools.size > 0) {
+          console.error("[MCP DEBUG] Available tools:");
+          Array.from(this.tools.keys()).forEach((toolName) => {
+            console.error(`[MCP DEBUG]   - ${toolName}`);
+          });
         }
         return {
           connected: connectedCount,
@@ -61578,7 +61679,7 @@ var init_client2 = __esm({
         const { name: name14 } = serverConfig;
         try {
           if (this.debug) {
-            console.error(`[MCP] Connecting to ${name14} via ${serverConfig.transport}...`);
+            console.error(`[MCP DEBUG] Connecting to ${name14} via ${serverConfig.transport}...`);
           }
           const transport = createTransport(serverConfig);
           const client = new import_client3.Client(
@@ -61597,6 +61698,7 @@ var init_client2 = __esm({
             config: serverConfig
           });
           const toolsResponse = await client.listTools();
+          const toolCount = toolsResponse?.tools?.length || 0;
           if (toolsResponse && toolsResponse.tools) {
             for (const tool3 of toolsResponse.tools) {
               const qualifiedName = `${name14}_${tool3.name}`;
@@ -61606,16 +61708,17 @@ var init_client2 = __esm({
                 originalName: tool3.name
               });
               if (this.debug) {
-                console.error(`[MCP]   Registered tool: ${qualifiedName}`);
+                console.error(`[MCP DEBUG]     Registered tool: ${qualifiedName}`);
               }
             }
           }
-          if (this.debug) {
-            console.error(`[MCP] Connected to ${name14} with ${toolsResponse?.tools?.length || 0} tools`);
-          }
+          console.error(`[MCP INFO] Connected to ${name14}: ${toolCount} tool${toolCount !== 1 ? "s" : ""} loaded`);
           return true;
         } catch (error2) {
-          console.error(`[MCP] Error connecting to ${name14}:`, error2.message);
+          console.error(`[MCP ERROR] Error connecting to ${name14}:`, error2.message);
+          if (this.debug) {
+            console.error(`[MCP DEBUG] Full error details:`, error2);
+          }
           return false;
         }
       }
@@ -61635,7 +61738,7 @@ var init_client2 = __esm({
         }
         try {
           if (this.debug) {
-            console.error(`[MCP] Calling ${toolName} with args:`, args);
+            console.error(`[MCP DEBUG] Calling ${toolName} with args:`, JSON.stringify(args, null, 2));
           }
           const timeout = this.config?.settings?.timeout || 3e4;
           const timeoutPromise = new Promise((_2, reject2) => {
@@ -61650,9 +61753,15 @@ var init_client2 = __esm({
             }),
             timeoutPromise
           ]);
+          if (this.debug) {
+            console.error(`[MCP DEBUG] Tool ${toolName} executed successfully`);
+          }
           return result;
         } catch (error2) {
-          console.error(`[MCP] Error calling tool ${toolName}:`, error2);
+          console.error(`[MCP ERROR] Error calling tool ${toolName}:`, error2.message);
+          if (this.debug) {
+            console.error(`[MCP DEBUG] Full error details:`, error2);
+          }
           throw error2;
         }
       }
@@ -61697,20 +61806,32 @@ var init_client2 = __esm({
        */
       async disconnect() {
         const disconnectPromises = [];
+        if (this.clients.size === 0) {
+          if (this.debug) {
+            console.error("[MCP DEBUG] No MCP clients to disconnect");
+          }
+          return;
+        }
+        if (this.debug) {
+          console.error(`[MCP DEBUG] Disconnecting from ${this.clients.size} MCP server${this.clients.size !== 1 ? "s" : ""}...`);
+        }
         for (const [name14, clientInfo] of this.clients.entries()) {
           disconnectPromises.push(
             clientInfo.client.close().then(() => {
               if (this.debug) {
-                console.error(`[MCP] Disconnected from ${name14}`);
+                console.error(`[MCP DEBUG] Disconnected from ${name14}`);
               }
             }).catch((error2) => {
-              console.error(`[MCP] Error disconnecting from ${name14}:`, error2);
+              console.error(`[MCP ERROR] Error disconnecting from ${name14}:`, error2.message);
             })
           );
         }
         await Promise.all(disconnectPromises);
         this.clients.clear();
         this.tools.clear();
+        if (this.debug) {
+          console.error("[MCP DEBUG] All MCP connections closed");
+        }
       }
     };
   }
@@ -61862,31 +61983,58 @@ var init_xmlBridge = __esm({
       async initialize(config = null) {
         let mcpConfigs = null;
         if (!config) {
+          if (this.debug) {
+            console.error("[MCP DEBUG] No config provided, attempting auto-discovery...");
+          }
           mcpConfigs = loadMCPConfiguration();
+          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)) {
+          if (this.debug) {
+            console.error("[MCP DEBUG] Using deprecated array config format (consider using mcpConfig object)");
+          }
           mcpConfigs = { mcpServers: config };
         } else {
+          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...");
+          }
           this.mcpManager = new MCPClientManager({ debug: this.debug });
           const result = await this.mcpManager.initialize(mcpConfigs);
           const vercelTools = this.mcpManager.getVercelTools();
           this.mcpTools = vercelTools;
+          const toolCount = Object.keys(vercelTools).length;
           for (const [name14, tool3] of Object.entries(vercelTools)) {
             this.xmlDefinitions[name14] = mcpToolToXmlDefinition(name14, tool3);
           }
-          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 (error2) {
-          console.error("[MCP] Failed to initialize MCP connections:", error2);
+          console.error("[MCP ERROR] Failed to initialize MCP connections:", error2.message);
+          if (this.debug) {
+            console.error("[MCP DEBUG] Full error details:", error2);
+          }
         }
       }
       /**
@@ -61911,24 +62059,35 @@ var init_xmlBridge = __esm({
       async executeFromXml(xmlString) {
         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 tool3 = this.mcpTools[toolName];
         if (!tool3) {
+          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 tool3.execute(params);
+          if (this.debug) {
+            console.error(`[MCP DEBUG] Tool ${toolName} executed successfully`);
+          }
           return {
             success: true,
             toolName,
             result
           };
         } catch (error2) {
+          console.error(`[MCP ERROR] Tool ${toolName} execution failed:`, error2.message);
+          if (this.debug) {
+            console.error(`[MCP DEBUG] Full error details:`, error2);
+          }
           return {
             success: false,
             toolName,
@@ -62062,6 +62221,7 @@ var init_ProbeAgent = __esm({
         this.mcpConfig = options.mcpConfig || null;
         this.mcpServers = options.mcpServers || null;
         this.mcpBridge = null;
+        this._mcpInitialized = false;
         this.initializeModel();
       }
       /**
@@ -62069,7 +62229,8 @@ var init_ProbeAgent = __esm({
        * This method initializes MCP and merges MCP tools into the tool list
        */
       async initialize() {
-        if (this.enableMcp) {
+        if (this.enableMcp && !this._mcpInitialized) {
+          this._mcpInitialized = true;
           try {
             await this.initializeMCP();
             if (this.mcpBridge) {
@@ -62093,7 +62254,10 @@ var init_ProbeAgent = __esm({
               console.error("[DEBUG] ========================================\n");
             }
           } catch (error2) {
-            console.error("[MCP] Failed to initialize MCP:", error2);
+            console.error("[MCP ERROR] Failed to initialize MCP:", error2.message);
+            if (this.debug) {
+              console.error("[MCP DEBUG] Full error details:", error2);
+            }
             this.mcpBridge = null;
           }
         }
@@ -62517,13 +62681,13 @@ var init_ProbeAgent = __esm({
           if (this.mcpConfig) {
             mcpConfig = this.mcpConfig;
             if (this.debug) {
-              console.log("[DEBUG] Using provided MCP config object");
+              console.error("[MCP DEBUG] Using provided MCP config object");
             }
           } else if (this.mcpConfigPath) {
             try {
               mcpConfig = loadMCPConfigurationFromPath(this.mcpConfigPath);
               if (this.debug) {
-                console.log(`[DEBUG] Loaded MCP config from: ${this.mcpConfigPath}`);
+                console.error(`[MCP DEBUG] Loaded MCP config from: ${this.mcpConfigPath}`);
               }
             } catch (error2) {
               throw new Error(`Failed to load MCP config from ${this.mcpConfigPath}: ${error2.message}`);
@@ -62531,8 +62695,13 @@ var init_ProbeAgent = __esm({
           } else if (this.mcpServers) {
             mcpConfig = { mcpServers: this.mcpServers };
             if (this.debug) {
-              console.warn("[DEBUG] Using deprecated mcpServers option. Consider using mcpConfig instead.");
+              console.error("[MCP DEBUG] Using deprecated mcpServers option. Consider using mcpConfig instead.");
+            }
+          } else {
+            if (this.debug) {
+              console.error("[MCP DEBUG] No explicit MCP config provided, will attempt auto-discovery");
             }
+            mcpConfig = null;
           }
           this.mcpBridge = new MCPXmlBridge({ debug: this.debug });
           await this.mcpBridge.initialize(mcpConfig);
@@ -62540,22 +62709,25 @@ var init_ProbeAgent = __esm({
           const mcpToolCount = mcpToolNames.length;
           if (mcpToolCount > 0) {
             if (this.debug) {
-              console.error("\n[DEBUG] ========================================");
-              console.error(`[DEBUG] MCP Tools Initialized (${mcpToolCount} tools)`);
-              console.error("[DEBUG] Available MCP tools:");
+              console.error("\n[MCP DEBUG] ========================================");
+              console.error(`[MCP DEBUG] MCP Tools Initialized (${mcpToolCount} tools)`);
+              console.error("[MCP DEBUG] Available MCP tools:");
               for (const toolName of mcpToolNames) {
-                console.error(`[DEBUG]   - ${toolName}`);
+                console.error(`[MCP DEBUG]   - ${toolName}`);
               }
-              console.error("[DEBUG] ========================================\n");
+              console.error("[MCP DEBUG] ========================================\n");
             }
           } else {
             if (this.debug) {
-              console.error("[DEBUG] No MCP tools loaded, setting bridge to null");
+              console.error("[MCP DEBUG] No MCP tools loaded, setting bridge to null");
             }
             this.mcpBridge = null;
           }
         } catch (error2) {
-          console.error("[MCP] Error initializing MCP:", error2);
+          console.error("[MCP ERROR] Error initializing MCP:", error2.message);
+          if (this.debug) {
+            console.error("[MCP DEBUG] Full error details:", error2);
+          }
           this.mcpBridge = null;
         }
       }
@@ -62563,6 +62735,23 @@ var init_ProbeAgent = __esm({
        * Get the system message with instructions for the AI (XML Tool Format)
        */
       async getSystemMessage() {
+        if (this.enableMcp && !this.mcpBridge && !this._mcpInitialized) {
+          this._mcpInitialized = true;
+          try {
+            await this.initializeMCP();
+            if (this.mcpBridge) {
+              const mcpTools = this.mcpBridge.mcpTools || {};
+              for (const [toolName, toolImpl] of Object.entries(mcpTools)) {
+                this.toolImplementations[toolName] = toolImpl;
+              }
+            }
+          } catch (error2) {
+            console.error("[MCP ERROR] Failed to lazy-initialize MCP:", error2.message);
+            if (this.debug) {
+              console.error("[MCP DEBUG] Full error details:", error2);
+            }
+          }
+        }
         let toolDefinitions = `
 ${searchToolDefinition}
 ${queryToolDefinition}
@@ -63863,6 +64052,7 @@ __export(index_exports, {
   extractTool: () => extractTool,
   extractToolDefinition: () => extractToolDefinition,
   getBinaryPath: () => getBinaryPath,
+  grep: () => grep,
   initializeSimpleTelemetryFromOptions: () => initializeSimpleTelemetryFromOptions,
   listFilesByLevel: () => listFilesByLevel,
   listFilesToolInstance: () => listFilesToolInstance,
@@ -63885,6 +64075,7 @@ var init_index = __esm({
     init_search();
     init_query();
     init_extract();
+    init_grep();
     init_delegate();
     init_utils();
     init_tools();
@@ -63919,6 +64110,7 @@ init_index();
   extractTool,
   extractToolDefinition,
   getBinaryPath,
+  grep,
   initializeSimpleTelemetryFromOptions,
   listFilesByLevel,
   listFilesToolInstance,

package/index.d.ts

@@ -303,6 +303,51 @@ export declare function query(
   }
 ): Promise<any>;
 
+/**
+ * Standard grep-style search that works across multiple operating systems
+ *
+ * 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 AST-aware semantic search.
+ *
+ * @param options - Grep options
+ * @param options.pattern - Regular expression pattern to search for
+ * @param options.paths - Path or array of paths to search in
+ * @param options.ignoreCase - Case-insensitive search (-i flag)
+ * @param options.lineNumbers - Show line numbers in output (-n flag)
+ * @param options.count - Only show count of matches per file (-c flag)
+ * @param options.filesWithMatches - Only show filenames that contain matches (-l flag)
+ * @param options.filesWithoutMatches - Only show filenames that do not contain matches (-L flag)
+ * @param options.invertMatch - Invert match: show lines that do NOT match (-v flag)
+ * @param options.beforeContext - Number of lines of context before match (-B flag)
+ * @param options.afterContext - Number of lines of context after match (-A flag)
+ * @param options.context - Number of lines of context before and after match (-C flag)
+ * @param options.noGitignore - Do not respect .gitignore files (--no-gitignore flag)
+ * @param options.color - Colorize output: 'always', 'never', 'auto' (--color flag)
+ * @param options.maxCount - Stop reading a file after N matching lines (-m flag)
+ * @returns Promise resolving to grep results as string
+ */
+export declare function grep(options: {
+  pattern: string;
+  paths: string | string[];
+  ignoreCase?: boolean;
+  lineNumbers?: boolean;
+  count?: boolean;
+  filesWithMatches?: boolean;
+  filesWithoutMatches?: boolean;
+  invertMatch?: boolean;
+  beforeContext?: number;
+  afterContext?: number;
+  context?: number;
+  noGitignore?: boolean;
+  color?: 'always' | 'never' | 'auto';
+  maxCount?: number;
+  binaryOptions?: {
+    forceDownload?: boolean;
+    version?: string;
+  };
+}): Promise<string>;
+
 /**
  * Extract code blocks from files
  */