@probelabs/visor 0.1.77 → 0.1.79

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-process.env.VISOR_VERSION = '0.1.77';
-process.env.PROBE_VERSION = '0.6.0-rc120';
+process.env.VISOR_VERSION = '0.1.79';
+process.env.PROBE_VERSION = '0.6.0-rc122';
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -105343,6 +105343,44 @@ class ConfigManager {
                             : 'Both ai_mcp_servers and ai.mcpServers are set; ai.mcpServers takes precedence for this check.',
                     });
                 }
+                // Type-specific guidance for MCP placement to avoid silent ignores
+                try {
+                    const anyCheck = checkConfig;
+                    const aiObj = anyCheck.ai || undefined;
+                    const hasBareMcpAtCheck = Object.prototype.hasOwnProperty.call(anyCheck, 'mcpServers');
+                    const hasAiMcp = aiObj && Object.prototype.hasOwnProperty.call(aiObj, 'mcpServers');
+                    const hasClaudeCodeMcp = anyCheck.claude_code &&
+                        typeof anyCheck.claude_code === 'object' &&
+                        Object.prototype.hasOwnProperty.call(anyCheck.claude_code, 'mcpServers');
+                    if (checkConfig.type === 'ai') {
+                        if (hasBareMcpAtCheck) {
+                            warnings.push({
+                                field: `checks.${checkName}.mcpServers`,
+                                message: "'mcpServers' at the check root is ignored for type 'ai'. Use 'ai.mcpServers' or 'ai_mcp_servers' instead.",
+                                value: anyCheck.mcpServers,
+                            });
+                        }
+                        if (hasClaudeCodeMcp) {
+                            warnings.push({
+                                field: `checks.${checkName}.claude_code.mcpServers`,
+                                message: "'claude_code.mcpServers' is ignored for type 'ai'. Use 'ai.mcpServers' or 'ai_mcp_servers' instead.",
+                            });
+                        }
+                    }
+                    if (checkConfig.type === 'claude-code') {
+                        if (hasAiMcp || checkConfig.ai_mcp_servers) {
+                            warnings.push({
+                                field: hasAiMcp
+                                    ? `checks.${checkName}.ai.mcpServers`
+                                    : `checks.${checkName}.ai_mcp_servers`,
+                                message: "For type 'claude-code', MCP must be configured under 'claude_code.mcpServers'. 'ai.mcpServers' and 'ai_mcp_servers' are ignored for this check.",
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // best-effort hints; never fail validation here
+                }
             }
         }
         // Validate global MCP servers if present
@@ -136124,6 +136162,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 = __nccwpck_require__(35317);
+    import_util5 = __nccwpck_require__(39023);
+    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) {
@@ -136607,7 +136713,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
       });
@@ -136742,11 +136848,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 = __nccwpck_require__(35317);
+    import_child_process6 = __nccwpck_require__(35317);
     import_crypto2 = __nccwpck_require__(76982);
     init_utils();
     init_common();
@@ -137822,7 +137928,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"],
@@ -138006,11 +138112,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 = __nccwpck_require__(35317);
+    import_child_process7 = __nccwpck_require__(35317);
     import_path4 = __nccwpck_require__(16928);
     import_fs = __nccwpck_require__(79896);
     init_bashCommandUtils();
@@ -138535,15 +138641,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(__nccwpck_require__(79896), 1);
     import_path6 = __toESM(__nccwpck_require__(16928), 1);
-    import_util5 = __nccwpck_require__(39023);
-    import_child_process7 = __nccwpck_require__(35317);
-    execAsync4 = (0, import_util5.promisify)(import_child_process7.exec);
+    import_util6 = __nccwpck_require__(39023);
+    import_child_process8 = __nccwpck_require__(35317);
+    execAsync4 = (0, import_util6.promisify)(import_child_process8.exec);
   }
 });
 
@@ -159853,8 +159959,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 = __nccwpck_require__(35317);
-    var import_util9 = __nccwpck_require__(39023);
+    var import_child_process10 = __nccwpck_require__(35317);
+    var import_util10 = __nccwpck_require__(39023);
     var import_client7 = (init_client(), __toCommonJS(client_exports));
     var getValidatedProcessCredentials = /* @__PURE__ */ __name((profileName, data2, profiles) => {
       if (data2.Version !== 1) {
@@ -159890,7 +159996,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;
@@ -166328,13 +166434,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 = __nccwpck_require__(35317);
-    import_util8 = __nccwpck_require__(39023);
+    import_child_process9 = __nccwpck_require__(35317);
+    import_util9 = __nccwpck_require__(39023);
     import_crypto4 = __nccwpck_require__(76982);
     import_events = __nccwpck_require__(24434);
     import_fs3 = __toESM(__nccwpck_require__(79896), 1);
@@ -195481,6 +195587,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?```/,
@@ -196293,8 +196407,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) {
@@ -196320,12 +196434,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);
       }
     }
   }
@@ -196401,12 +196515,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;
       }
     }
@@ -196537,20 +196651,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,
@@ -196566,7 +196705,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(
@@ -196585,6 +196724,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}`;
@@ -196594,16 +196734,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;
         }
       }
@@ -196623,7 +196764,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) => {
@@ -196638,9 +196779,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;
         }
       }
@@ -196685,20 +196832,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");
+        }
       }
     };
   }
@@ -196850,31 +197009,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);
+          }
         }
       }
       /**
@@ -196899,24 +197085,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,
@@ -197050,6 +197247,7 @@ var init_ProbeAgent = __esm({
         this.mcpConfig = options.mcpConfig || null;
         this.mcpServers = options.mcpServers || null;
         this.mcpBridge = null;
+        this._mcpInitialized = false;
         this.initializeModel();
       }
       /**
@@ -197057,7 +197255,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) {
@@ -197081,7 +197280,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;
           }
         }
@@ -197505,13 +197707,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}`);
@@ -197519,8 +197721,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);
@@ -197528,22 +197735,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;
         }
       }
@@ -197551,6 +197761,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}
@@ -198851,6 +199078,7 @@ __export(index_exports, {
   extractTool: () => extractTool,
   extractToolDefinition: () => extractToolDefinition,
   getBinaryPath: () => getBinaryPath,
+  grep: () => grep,
   initializeSimpleTelemetryFromOptions: () => initializeSimpleTelemetryFromOptions,
   listFilesByLevel: () => listFilesByLevel,
   listFilesToolInstance: () => listFilesToolInstance,
@@ -198873,6 +199101,7 @@ var init_index = __esm({
     init_search();
     init_query();
     init_extract();
+    init_grep();
     init_delegate();
     init_utils();
     init_tools();
@@ -228463,7 +228692,7 @@ module.exports = /*#__PURE__*/JSON.parse('{"application/1d-interleaved-parityfec
 /***/ ((module) => {
 
 "use strict";
-module.exports = {"rE":"0.1.77"};
+module.exports = {"rE":"0.1.79"};
 
 /***/ })