@probelabs/visor 0.1.78 → 0.1.80

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-process.env.VISOR_VERSION = '0.1.78';
-process.env.PROBE_VERSION = '0.6.0-rc120';
+process.env.VISOR_VERSION = '0.1.80';
+process.env.PROBE_VERSION = '0.6.0-rc122';
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -102520,21 +102520,30 @@ class CheckExecutionEngine {
                             dependencyResults.set(depId, depResult);
                         }
                     }
-                    // If any direct dependency failed (errors/critical or */error ruleIds), skip this check
+                    // If any direct dependency failed or was skipped, skip this check
                     const directDeps = checkConfig.depends_on || [];
                     const failedDeps = [];
                     for (const depId of directDeps) {
                         const depRes = results.get(depId);
                         if (!depRes)
                             continue;
-                        // Only treat command provider execution/transform failures as dependency-fatal
-                        const hasFatalCommandFailure = (depRes.issues || []).some(issue => {
+                        // Check if dependency was skipped
+                        const wasSkipped = (depRes.issues || []).some(issue => {
                             const id = issue.ruleId || '';
-                            return (id.endsWith('/command/execution_error') ||
+                            return id.endsWith('/__skipped');
+                        });
+                        // Check for fatal failures: command provider execution/transform failures and forEach iteration errors
+                        const hasFatalFailure = (depRes.issues || []).some(issue => {
+                            const id = issue.ruleId || '';
+                            return (id === 'command/execution_error' ||
+                                id.endsWith('/command/execution_error') ||
+                                id === 'command/transform_js_error' ||
                                 id.endsWith('/command/transform_js_error') ||
-                                id.endsWith('/command/transform_error'));
+                                id === 'command/transform_error' ||
+                                id.endsWith('/command/transform_error') ||
+                                id.endsWith('/forEach/iteration_error'));
                         });
-                        if (hasFatalCommandFailure)
+                        if (wasSkipped || hasFatalFailure)
                             failedDeps.push(depId);
                     }
                     if (failedDeps.length > 0) {
@@ -102606,8 +102615,8 @@ class CheckExecutionEngine {
                         if (debug) {
                             log(`🔄 Debug: Check "${checkName}" depends on forEach check "${forEachParentName}", executing ${forEachItems.length} times`);
                         }
-                        // Log forEach processing start
-                        logger_1.logger.info(`  Processing ${forEachItems.length} items...`);
+                        // Log forEach processing start (non-debug)
+                        logger_1.logger.info(`  forEach: processing ${forEachItems.length} items from "${forEachParentName}"...`);
                         const allIssues = [];
                         const allOutputs = [];
                         const aggregatedContents = [];
@@ -102678,8 +102687,19 @@ class CheckExecutionEngine {
                                 parent: forEachParentName,
                             });
                             // Record iteration completion
+                            // Check if this iteration had fatal errors
+                            const hadFatalError = (itemResult.issues || []).some(issue => {
+                                const id = issue.ruleId || '';
+                                return (id === 'command/execution_error' ||
+                                    id.endsWith('/command/execution_error') ||
+                                    id === 'command/transform_js_error' ||
+                                    id.endsWith('/command/transform_js_error') ||
+                                    id === 'command/transform_error' ||
+                                    id.endsWith('/command/transform_error'));
+                            });
                             const iterationDuration = (Date.now() - iterationStart) / 1000;
-                            this.recordIterationComplete(checkName, iterationStart, true, itemResult.issues || [], itemResult.output);
+                            this.recordIterationComplete(checkName, iterationStart, !hadFatalError, // Success if no fatal errors
+                            itemResult.issues || [], itemResult.output);
                             // Log iteration progress
                             logger_1.logger.info(`  ✔ ${itemIndex + 1}/${forEachItems.length} (${iterationDuration.toFixed(1)}s)`);
                             return { index: itemIndex, itemResult };
@@ -102691,7 +102711,22 @@ class CheckExecutionEngine {
                         const forEachResults = await this.executeWithLimitedParallelism(itemTasks, forEachConcurrency, false);
                         for (const result of forEachResults) {
                             if (result.status === 'rejected') {
-                                throw result.reason;
+                                // Instead of throwing, record the failure and continue with other iterations
+                                const error = result.reason;
+                                const errorMessage = error instanceof Error ? error.message : String(error);
+                                // Create an error issue for this failed iteration
+                                allIssues.push({
+                                    ruleId: `${checkName}/forEach/iteration_error`,
+                                    severity: 'error',
+                                    category: 'logic',
+                                    message: `forEach iteration failed: ${errorMessage}`,
+                                    file: '',
+                                    line: 0,
+                                });
+                                if (debug) {
+                                    log(`🔄 Debug: forEach iteration for check "${checkName}" failed: ${errorMessage}`);
+                                }
+                                continue;
                             }
                             // Skip results from skipped items (those that failed if condition)
                             if (result.value.skipped) {
@@ -102749,7 +102784,18 @@ class CheckExecutionEngine {
                         // Execute with retry/routing semantics
                         finalResult = await this.executeWithRouting(checkName, checkConfig, provider, providerConfig, prInfo, dependencyResults, sessionInfo, config, dependencyGraph, debug, results);
                         // Record normal (non-forEach) execution
-                        this.recordIterationComplete(checkName, checkStartTime, true, finalResult.issues || [], finalResult.output);
+                        // Check if this check had fatal errors
+                        const hadFatalError = (finalResult.issues || []).some(issue => {
+                            const id = issue.ruleId || '';
+                            return (id === 'command/execution_error' ||
+                                id.endsWith('/command/execution_error') ||
+                                id === 'command/transform_js_error' ||
+                                id.endsWith('/command/transform_js_error') ||
+                                id === 'command/transform_error' ||
+                                id.endsWith('/command/transform_error'));
+                        });
+                        this.recordIterationComplete(checkName, checkStartTime, !hadFatalError, // Success if no fatal errors
+                        finalResult.issues || [], finalResult.output);
                         if (checkConfig.forEach) {
                             try {
                                 const finalResultWithOutput = finalResult;
@@ -102830,11 +102876,24 @@ class CheckExecutionEngine {
                 const result = levelResults[i];
                 const checkConfig = config.checks[checkName];
                 if (result.status === 'fulfilled' && result.value.result && !result.value.error) {
-                    // Skip storing results for skipped checks (they should not appear in outputs)
+                    // For skipped checks, store a marker so dependent checks can detect the skip
                     if (result.value.skipped) {
                         if (debug) {
-                            log(`🔧 Debug: Not storing result for skipped check "${checkName}"`);
+                            log(`🔧 Debug: Storing skip marker for skipped check "${checkName}"`);
                         }
+                        // Store a special marker result with a skip issue so dependencies can detect it
+                        results.set(checkName, {
+                            issues: [
+                                {
+                                    ruleId: `${checkName}/__skipped`,
+                                    severity: 'info',
+                                    category: 'logic',
+                                    message: 'Check was skipped',
+                                    file: '',
+                                    line: 0,
+                                },
+                            ],
+                        });
                         continue;
                     }
                     const reviewResult = result.value.result;
@@ -102864,6 +102923,8 @@ class CheckExecutionEngine {
                         else {
                             normalizedOutput = [rawOutput];
                         }
+                        // Log forEach items found (non-debug)
+                        logger_1.logger.info(`  Found ${normalizedOutput.length} items for forEach iteration`);
                         try {
                             const preview = JSON.stringify(normalizedOutput);
                             logger_1.logger.debug(`🔧 Debug: Check "${checkName}" forEach output: ${preview?.slice(0, 200) || '(empty)'}`);
@@ -103166,7 +103227,9 @@ class CheckExecutionEngine {
                     debugInfo.push(`✅ Check "${checkName}" completed: ${(result.issues || []).length} issues found (level ${executionGroup.level})`);
                 }
                 // Issues are already prefixed and enriched with group/schema info
-                aggregatedIssues.push(...(result.issues || []));
+                // Filter out internal __skipped markers
+                const nonInternalIssues = (result.issues || []).filter(issue => !issue.ruleId?.endsWith('/__skipped'));
+                aggregatedIssues.push(...nonInternalIssues);
                 const resultSummary = result;
                 const resultContent = resultSummary.content;
                 if (typeof resultContent === 'string' && resultContent.trim()) {
@@ -112708,8 +112771,22 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
                 output = parsed;
             }
             catch {
-                // If not JSON, keep as string
-                output = rawOutput;
+                // Try to extract JSON from the end of output (for commands with debug logs)
+                const extracted = this.extractJsonFromEnd(rawOutput);
+                if (extracted) {
+                    try {
+                        output = JSON.parse(extracted);
+                        logger_1.logger.debug(`🔧 Debug: Extracted and parsed JSON from end of output (${extracted.length} chars from ${rawOutput.length} total)`);
+                    }
+                    catch {
+                        // Extraction found something but it's not valid JSON
+                        output = rawOutput;
+                    }
+                }
+                else {
+                    // Not JSON, keep as string
+                    output = rawOutput;
+                }
             }
             // Apply transform if specified (Liquid or JavaScript)
             let finalOutput = output;
@@ -112945,6 +113022,7 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
      *  - If it's a JSON string, expose parsed properties via Proxy (e.g., value.key)
      *  - When coerced to string (toString/valueOf/Symbol.toPrimitive), return the original raw string
      *  - If parsing fails or value is not a string, return the value unchanged
+     *  - Attempts to extract JSON from the end of the output if full parse fails
      */
     makeJsonSmart(value) {
         if (typeof value !== 'string') {
@@ -112952,12 +113030,28 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
         }
         const raw = value;
         let parsed;
+        // First try: parse the entire string as JSON
         try {
             parsed = JSON.parse(raw);
         }
         catch {
-            // Not JSON, return original string
-            return raw;
+            // Second try: extract JSON from the end of the output
+            // Look for { or [ at the start of a line and take everything after it
+            const jsonMatch = this.extractJsonFromEnd(raw);
+            if (jsonMatch) {
+                try {
+                    parsed = JSON.parse(jsonMatch);
+                    logger_1.logger.debug(`🔧 Debug: Extracted JSON from end of output (${jsonMatch.length} chars from ${raw.length} total)`);
+                }
+                catch {
+                    // Not valid JSON even after extraction, return original string
+                    return raw;
+                }
+            }
+            else {
+                // Not JSON, return original string
+                return raw;
+            }
         }
         // Use a boxed string so string methods still work via Proxy fallback
         const boxed = new String(raw);
@@ -113010,6 +113104,30 @@ class CommandCheckProvider extends check_provider_interface_1.CheckProvider {
         };
         return new Proxy(boxed, handler);
     }
+    /**
+     * Extract JSON from the end of a string that may contain logs/debug output
+     * Looks for the last occurrence of { or [ and tries to parse from there
+     */
+    extractJsonFromEnd(text) {
+        // Strategy: Find the last line that starts with { or [
+        // Then try to parse from that point to the end
+        const lines = text.split('\n');
+        // Search backwards for a line starting with { or [
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const trimmed = lines[i].trim();
+            if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+                // Found potential JSON start - take everything from here to the end
+                const candidate = lines.slice(i).join('\n');
+                // Quick validation: does it look like valid JSON structure?
+                const trimmedCandidate = candidate.trim();
+                if ((trimmedCandidate.startsWith('{') && trimmedCandidate.endsWith('}')) ||
+                    (trimmedCandidate.startsWith('[') && trimmedCandidate.endsWith(']'))) {
+                    return trimmedCandidate;
+                }
+            }
+        }
+        return null;
+    }
     /**
      * Recursively apply JSON-smart wrapper to outputs object values
      */
@@ -136162,6 +136280,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) {
@@ -136645,7 +136831,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
       });
@@ -136780,11 +136966,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();
@@ -137860,7 +138046,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"],
@@ -138044,11 +138230,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();
@@ -138573,15 +138759,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);
   }
 });
 
@@ -159891,8 +160077,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) {
@@ -159928,7 +160114,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;
@@ -166366,13 +166552,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);
@@ -195519,6 +195705,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?```/,
@@ -196331,8 +196525,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) {
@@ -196358,12 +196552,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);
       }
     }
   }
@@ -196439,12 +196633,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;
       }
     }
@@ -196575,20 +196769,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,
@@ -196604,7 +196823,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(
@@ -196623,6 +196842,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}`;
@@ -196632,16 +196852,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;
         }
       }
@@ -196661,7 +196882,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) => {
@@ -196676,9 +196897,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;
         }
       }
@@ -196723,20 +196950,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");
+        }
       }
     };
   }
@@ -196888,31 +197127,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);
+          }
         }
       }
       /**
@@ -196937,24 +197203,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,
@@ -197088,6 +197365,7 @@ var init_ProbeAgent = __esm({
         this.mcpConfig = options.mcpConfig || null;
         this.mcpServers = options.mcpServers || null;
         this.mcpBridge = null;
+        this._mcpInitialized = false;
         this.initializeModel();
       }
       /**
@@ -197095,7 +197373,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) {
@@ -197119,7 +197398,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;
           }
         }
@@ -197543,13 +197825,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}`);
@@ -197557,8 +197839,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);
@@ -197566,22 +197853,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;
         }
       }
@@ -197589,6 +197879,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}
@@ -198889,6 +199196,7 @@ __export(index_exports, {
   extractTool: () => extractTool,
   extractToolDefinition: () => extractToolDefinition,
   getBinaryPath: () => getBinaryPath,
+  grep: () => grep,
   initializeSimpleTelemetryFromOptions: () => initializeSimpleTelemetryFromOptions,
   listFilesByLevel: () => listFilesByLevel,
   listFilesToolInstance: () => listFilesToolInstance,
@@ -198911,6 +199219,7 @@ var init_index = __esm({
     init_search();
     init_query();
     init_extract();
+    init_grep();
     init_delegate();
     init_utils();
     init_tools();
@@ -228501,7 +228810,7 @@ module.exports = /*#__PURE__*/JSON.parse('{"application/1d-interleaved-parityfec
 /***/ ((module) => {
 
 "use strict";
-module.exports = {"rE":"0.1.78"};
+module.exports = {"rE":"0.1.80"};
 
 /***/ })