@probelabs/probe 0.6.0-rc209 → 0.6.0-rc211

package/build/agent/index.js

@@ -3346,8 +3346,8 @@ async function search(options) {
     }
   }
   if (!options.maxTokens) {
-    options.maxTokens = 1e4;
-    cliArgs.push("--max-tokens", "10000");
+    options.maxTokens = 2e4;
+    cliArgs.push("--max-tokens", "20000");
   }
   if (!options.timeout) {
     options.timeout = 30;
@@ -3764,7 +3764,10 @@ async function delegate({
   disableTools = false,
   searchDelegate = void 0,
   schema = null,
-  enableTasks = false
+  enableTasks = false,
+  enableMcp = false,
+  mcpConfig = null,
+  mcpConfigPath = null
 }) {
   if (!task || typeof task !== "string") {
     throw new Error("Task parameter is required and must be a string");
@@ -3820,8 +3823,14 @@ async function delegate({
       allowedTools,
       disableTools,
       searchDelegate,
-      enableTasks
+      enableTasks,
       // Inherit from parent (subagent gets isolated TaskManager)
+      enableMcp,
+      // Inherit from parent (subagent creates own MCPXmlBridge)
+      mcpConfig,
+      // Inherit from parent
+      mcpConfigPath
+      // Inherit from parent
     });
     if (debug) {
       console.error(`[DELEGATE] Created subagent with session ${sessionId}`);
@@ -4023,6 +4032,447 @@ var init_delegate = __esm({
   }
 });
 
+// src/tools/analyzeAll.js
+function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function stripResultTags(text) {
+  if (!text) return text;
+  return text.replace(/^<result>\s*/i, "").replace(/\s*<\/result>$/i, "").trim();
+}
+function parsePlanningResult(planningResult) {
+  const result = {
+    searchQuery: null,
+    aggregation: "summarize",
+    extractionPrompt: null,
+    reasoning: null
+  };
+  const queryMatch = planningResult.match(/SEARCH_QUERY:\s*(.+?)(?=\n[A-Z_]+:|$)/s);
+  if (queryMatch) {
+    result.searchQuery = queryMatch[1].trim();
+  }
+  const aggMatch = planningResult.match(/AGGREGATION:\s*(summarize|list_unique|count|group_by)/i);
+  if (aggMatch) {
+    result.aggregation = aggMatch[1].toLowerCase();
+  }
+  const extractMatch = planningResult.match(/EXTRACTION_PROMPT:\s*(.+?)(?=\n[A-Z_]+:|$)/s);
+  if (extractMatch) {
+    result.extractionPrompt = extractMatch[1].trim();
+  }
+  const reasoningMatch = planningResult.match(/REASONING:\s*(.+?)$/s);
+  if (reasoningMatch) {
+    result.reasoning = reasoningMatch[1].trim();
+  }
+  return result;
+}
+function chunkResults(searchResults, chunkSizeTokens) {
+  const chunks = [];
+  const chunkSizeChars = chunkSizeTokens * CHARS_PER_TOKEN;
+  const fileBlocks = searchResults.split(/(?=^```)/m);
+  let currentChunk = "";
+  let currentTokens = 0;
+  for (const block of fileBlocks) {
+    const blockTokens = estimateTokens(block);
+    if (blockTokens > chunkSizeTokens && currentChunk.length > 0) {
+      chunks.push({
+        id: chunks.length + 1,
+        total: 0,
+        content: currentChunk.trim(),
+        estimatedTokens: currentTokens
+      });
+      currentChunk = "";
+      currentTokens = 0;
+    }
+    if (currentTokens + blockTokens > chunkSizeTokens && currentChunk.length > 0) {
+      chunks.push({
+        id: chunks.length + 1,
+        total: 0,
+        content: currentChunk.trim(),
+        estimatedTokens: currentTokens
+      });
+      currentChunk = "";
+      currentTokens = 0;
+    }
+    currentChunk += block;
+    currentTokens += blockTokens;
+  }
+  if (currentChunk.trim().length > 0) {
+    chunks.push({
+      id: chunks.length + 1,
+      total: 0,
+      content: currentChunk.trim(),
+      estimatedTokens: currentTokens
+    });
+  }
+  const totalChunks = chunks.length;
+  for (const chunk of chunks) {
+    chunk.total = totalChunks;
+  }
+  return chunks;
+}
+async function processChunk(chunk, extractionPrompt, options) {
+  const task = `You are analyzing search results (chunk ${chunk.id} of ${chunk.total}).
+
+Your task: ${extractionPrompt}
+
+Search Results:
+${chunk.content}
+
+Instructions:
+- Extract ALL relevant information matching the analysis task
+- Be specific and include actual names, values, patterns found
+- Format as a structured list if multiple items found
+- If nothing relevant is found in this chunk, respond with "No relevant items found in this chunk."
+- Do NOT summarize the code - extract the specific information requested
+- IMPORTANT: When completing, always use the FULL format: <attempt_completion><result>YOUR ANSWER HERE</result></attempt_completion>
+- Do NOT use the shorthand <attempt_complete></attempt_complete> format`;
+  try {
+    const result = await delegate({
+      task,
+      debug: options.debug,
+      parentSessionId: options.sessionId,
+      path: options.path,
+      allowedFolders: options.allowedFolders,
+      provider: options.provider,
+      model: options.model,
+      tracer: options.tracer,
+      enableBash: false,
+      promptType: "code-researcher",
+      allowedTools: ["extract"],
+      maxIterations: 5,
+      timeout: 120
+    });
+    return { chunk, result };
+  } catch (error) {
+    return { chunk, result: `Error processing chunk ${chunk.id}: ${error.message}` };
+  }
+}
+async function processChunksParallel(chunks, extractionPrompt, maxWorkers, options) {
+  const results = [];
+  const queue = [...chunks];
+  const active = /* @__PURE__ */ new Set();
+  while (queue.length > 0 || active.size > 0) {
+    while (active.size < maxWorkers && queue.length > 0) {
+      const chunk = queue.shift();
+      const promise = processChunk(chunk, extractionPrompt, options).then((result) => {
+        active.delete(promise);
+        return result;
+      });
+      active.add(promise);
+      if (options.debug) {
+        console.error(`[analyze_all] Started processing chunk ${chunk.id}/${chunk.total}`);
+      }
+    }
+    if (active.size > 0) {
+      const result = await Promise.race(active);
+      results.push(result);
+      if (options.debug) {
+        console.error(`[analyze_all] Completed chunk ${result.chunk.id}/${result.chunk.total}`);
+      }
+    }
+  }
+  results.sort((a, b) => a.chunk.id - b.chunk.id);
+  return results;
+}
+async function aggregateResults(chunkResults2, aggregation, extractionPrompt, options) {
+  const meaningfulResults = chunkResults2.filter(
+    (r) => r.result && !r.result.toLowerCase().includes("no relevant items found") && r.result.trim().length > 0
+  );
+  if (meaningfulResults.length === 0) {
+    return "No relevant information found across all chunks.";
+  }
+  if (meaningfulResults.length === 1) {
+    return stripResultTags(meaningfulResults[0].result);
+  }
+  const chunkSummaries = meaningfulResults.map((r) => `--- Chunk ${r.chunk.id} ---
+${stripResultTags(r.result)}`).join("\n\n");
+  const completionNote = `
+
+IMPORTANT: When completing, always use the FULL format: <attempt_completion><result>YOUR ANSWER HERE</result></attempt_completion>`;
+  const aggregationPrompts = {
+    summarize: `Synthesize these analyses into a comprehensive summary. Combine related findings, remove redundancy, and present a coherent overview.
+
+Original task: ${extractionPrompt}
+
+Chunk analyses:
+${chunkSummaries}
+
+Provide a unified summary that captures all key findings.${completionNote}`,
+    list_unique: `Combine these lists and remove duplicates. Create a single deduplicated list of all unique items found.
+
+Original task: ${extractionPrompt}
+
+Chunk analyses:
+${chunkSummaries}
+
+Return a deduplicated, organized list of all unique items. Group related items if helpful.${completionNote}`,
+    count: `Count and aggregate the findings from these analyses. Provide total counts and breakdowns.
+
+Original task: ${extractionPrompt}
+
+Chunk analyses:
+${chunkSummaries}
+
+Provide accurate counts and a summary of all occurrences found.${completionNote}`,
+    group_by: `Group and categorize all items from these analyses. Organize findings into logical categories.
+
+Original task: ${extractionPrompt}
+
+Chunk analyses:
+${chunkSummaries}
+
+Organize all findings into clear categories with items listed under each.${completionNote}`
+  };
+  const aggregationTask = aggregationPrompts[aggregation] || aggregationPrompts.summarize;
+  try {
+    const result = await delegate({
+      task: aggregationTask,
+      debug: options.debug,
+      parentSessionId: options.sessionId,
+      path: options.path,
+      allowedFolders: options.allowedFolders,
+      provider: options.provider,
+      model: options.model,
+      tracer: options.tracer,
+      enableBash: false,
+      promptType: "code-researcher",
+      allowedTools: [],
+      maxIterations: 5,
+      timeout: 120
+    });
+    return result;
+  } catch (error) {
+    return `Aggregation failed (${error.message}). Raw results:
+
+${chunkSummaries}`;
+  }
+}
+async function planAnalysis(question, path9, options) {
+  if (options.debug) {
+    console.error(`[analyze_all] Phase 1: Planning analysis strategy...`);
+  }
+  const planningTask = `Create an analysis plan for this question about a codebase:
+
+"${question}"
+
+Search scope: ${path9}
+
+Use attempt_completion to output your plan in this EXACT format:
+
+SEARCH_QUERY: <elasticsearch query using OR for multiple terms, quotes for exact phrases>
+AGGREGATION: <summarize | list_unique | count | group_by>
+EXTRACTION_PROMPT: <what to extract from each search result>
+REASONING: <brief explanation>
+
+Example plan:
+SEARCH_QUERY: export OR function OR class OR tool
+AGGREGATION: list_unique
+EXTRACTION_PROMPT: Extract tool names and their purpose
+REASONING: Using list_unique to deduplicate tool definitions
+
+IMPORTANT: Use attempt_completion immediately with your plan. Do NOT try to search or answer the question - just create the analysis plan.`;
+  try {
+    const result = await delegate({
+      task: planningTask,
+      debug: options.debug,
+      parentSessionId: options.sessionId,
+      path: path9,
+      allowedFolders: [path9],
+      provider: options.provider,
+      model: options.model,
+      tracer: options.tracer,
+      enableBash: false,
+      promptType: "code-researcher",
+      allowedTools: [],
+      // attempt_completion only (default tool)
+      maxIterations: 3,
+      timeout: 60
+    });
+    const plan = parsePlanningResult(stripResultTags(result));
+    if (options.debug) {
+      console.error(`[analyze_all] Planning complete:`);
+      console.error(`[analyze_all]   Search Query: ${plan.searchQuery}`);
+      console.error(`[analyze_all]   Aggregation: ${plan.aggregation}`);
+      console.error(`[analyze_all]   Extraction: ${plan.extractionPrompt?.substring(0, 100)}...`);
+    }
+    return plan;
+  } catch (error) {
+    throw new Error(`Planning phase failed: ${error.message}`);
+  }
+}
+async function synthesizeAnswer(question, aggregatedData, plan, options) {
+  if (options.debug) {
+    console.error(`[analyze_all] Phase 3: Synthesizing final answer...`);
+  }
+  const synthesisTask = `You analyzed a codebase to answer this question:
+
+"${question}"
+
+Analysis Strategy Used:
+- Search Query: ${plan.searchQuery}
+- Aggregation Method: ${plan.aggregation}
+- Extraction Focus: ${plan.extractionPrompt}
+
+Aggregated Analysis Results:
+${aggregatedData}
+
+Now provide a COMPREHENSIVE, DETAILED answer to the original question.
+
+Your answer should:
+1. **Directly answer the question** with a clear summary at the top
+2. **Provide specific evidence** - include actual names, values, file locations where relevant
+3. **Organize the information** logically (use categories, lists, or sections as appropriate)
+4. **Note completeness** - mention if the analysis covered all relevant data or if there might be gaps
+5. **Be thorough** - this is the final answer the user will see, make it complete and useful
+
+Format your response as a well-structured document that fully answers: "${question}"
+
+IMPORTANT: When completing, use the FULL format: <attempt_completion><result>YOUR ANSWER HERE</result></attempt_completion>`;
+  try {
+    const result = await delegate({
+      task: synthesisTask,
+      debug: options.debug,
+      parentSessionId: options.sessionId,
+      path: options.path,
+      allowedFolders: options.allowedFolders,
+      provider: options.provider,
+      model: options.model,
+      tracer: options.tracer,
+      enableBash: false,
+      promptType: "code-researcher",
+      allowedTools: [],
+      maxIterations: 5,
+      timeout: 180
+    });
+    return stripResultTags(result);
+  } catch (error) {
+    return `Analysis Results for: "${question}"
+
+${aggregatedData}`;
+  }
+}
+async function analyzeAll(options) {
+  const {
+    question,
+    path: path9 = ".",
+    sessionId,
+    debug = false,
+    cwd,
+    allowedFolders,
+    provider,
+    model,
+    tracer,
+    chunkSizeTokens = DEFAULT_CHUNK_SIZE_TOKENS,
+    maxChunks = MAX_CHUNKS
+  } = options;
+  if (!question) {
+    throw new Error('The "question" parameter is required.');
+  }
+  const delegateOptions = {
+    debug,
+    sessionId,
+    path: allowedFolders?.[0] || cwd || path9,
+    allowedFolders,
+    provider,
+    model,
+    tracer
+  };
+  if (debug) {
+    console.error(`[analyze_all] Starting analysis`);
+    console.error(`[analyze_all] Question: ${question}`);
+    console.error(`[analyze_all] Path: ${path9}`);
+  }
+  const plan = await planAnalysis(question, path9, delegateOptions);
+  if (!plan.searchQuery) {
+    throw new Error("Planning phase failed to determine a search query.");
+  }
+  if (!plan.extractionPrompt) {
+    throw new Error("Planning phase failed to determine an extraction prompt.");
+  }
+  if (debug) {
+    console.error(`[analyze_all] Phase 2: Processing data with map-reduce...`);
+  }
+  const searchResults = await search({
+    query: plan.searchQuery,
+    path: path9,
+    cwd,
+    maxTokens: null,
+    allowTests: true,
+    session: sessionId
+  });
+  if (!searchResults || searchResults.trim().length === 0) {
+    return `No data found matching the analysis plan for: "${question}"
+
+Search query used: ${plan.searchQuery}
+
+Try rephrasing your question or broadening the scope.`;
+  }
+  const totalTokens = estimateTokens(searchResults);
+  if (debug) {
+    console.error(`[analyze_all] Total search results: ~${totalTokens} tokens`);
+  }
+  let aggregatedData;
+  if (totalTokens <= chunkSizeTokens) {
+    if (debug) {
+      console.error(`[analyze_all] Results fit in single chunk, processing directly`);
+    }
+    const singleChunk = {
+      id: 1,
+      total: 1,
+      content: searchResults,
+      estimatedTokens: totalTokens
+    };
+    const result = await processChunk(singleChunk, plan.extractionPrompt, delegateOptions);
+    aggregatedData = stripResultTags(result.result);
+  } else {
+    const chunks = chunkResults(searchResults, chunkSizeTokens);
+    if (debug) {
+      console.error(`[analyze_all] Split into ${chunks.length} chunks`);
+    }
+    if (chunks.length > maxChunks) {
+      console.error(`[analyze_all] Warning: Truncating from ${chunks.length} to ${maxChunks} chunks`);
+      chunks.length = maxChunks;
+      for (const chunk of chunks) {
+        chunk.total = maxChunks;
+      }
+    }
+    const chunkResultsProcessed = await processChunksParallel(
+      chunks,
+      plan.extractionPrompt,
+      MAX_PARALLEL_WORKERS,
+      delegateOptions
+    );
+    if (debug) {
+      console.error(`[analyze_all] All ${chunks.length} chunks processed, starting aggregation`);
+    }
+    aggregatedData = await aggregateResults(
+      chunkResultsProcessed,
+      plan.aggregation,
+      plan.extractionPrompt,
+      delegateOptions
+    );
+    aggregatedData = stripResultTags(aggregatedData);
+  }
+  const finalAnswer = await synthesizeAnswer(question, aggregatedData, plan, delegateOptions);
+  if (debug) {
+    console.error(`[analyze_all] Analysis complete`);
+  }
+  return finalAnswer;
+}
+var DEFAULT_CHUNK_SIZE_TOKENS, MAX_PARALLEL_WORKERS, MAX_CHUNKS, CHARS_PER_TOKEN;
+var init_analyzeAll = __esm({
+  "src/tools/analyzeAll.js"() {
+    "use strict";
+    init_search();
+    init_delegate();
+    DEFAULT_CHUNK_SIZE_TOKENS = 8e3;
+    MAX_PARALLEL_WORKERS = 3;
+    MAX_CHUNKS = 50;
+    CHARS_PER_TOKEN = 4;
+  }
+});
+
 // node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType;
 var init_util2 = __esm({
@@ -8895,6 +9345,7 @@ function getValidParamsForTool(toolName) {
     query: querySchema,
     extract: extractSchema,
     delegate: delegateSchema,
+    analyze_all: analyzeAllSchema,
     listSkills: listSkillsSchema,
     useSkill: useSkillSchema,
     bash: bashSchema,
@@ -8919,76 +9370,84 @@ function getValidParamsForTool(toolName) {
   return [];
 }
 function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
-  for (const toolName of validTools) {
-    const openTag = `<${toolName}>`;
-    const closeTag = `</${toolName}>`;
-    const openIndex = xmlString.indexOf(openTag);
-    if (openIndex === -1) {
-      continue;
+  let earliestToolName = null;
+  let earliestOpenIndex = Infinity;
+  for (const toolName2 of validTools) {
+    const openTag2 = `<${toolName2}>`;
+    const openIndex2 = xmlString.indexOf(openTag2);
+    if (openIndex2 !== -1 && openIndex2 < earliestOpenIndex) {
+      earliestOpenIndex = openIndex2;
+      earliestToolName = toolName2;
     }
-    let closeIndex;
-    if (toolName === "attempt_completion") {
-      closeIndex = xmlString.lastIndexOf(closeTag);
-      if (closeIndex !== -1 && closeIndex <= openIndex + openTag.length) {
-        closeIndex = -1;
-      }
-    } else {
-      closeIndex = xmlString.indexOf(closeTag, openIndex + openTag.length);
+  }
+  if (earliestToolName === null) {
+    return null;
+  }
+  const toolName = earliestToolName;
+  const openTag = `<${toolName}>`;
+  const closeTag = `</${toolName}>`;
+  const openIndex = earliestOpenIndex;
+  let closeIndex;
+  if (toolName === "attempt_completion") {
+    closeIndex = xmlString.lastIndexOf(closeTag);
+    if (closeIndex !== -1 && closeIndex <= openIndex + openTag.length) {
+      closeIndex = -1;
     }
-    let hasClosingTag = closeIndex !== -1;
-    if (closeIndex === -1) {
-      closeIndex = xmlString.length;
+  } else {
+    closeIndex = xmlString.indexOf(closeTag, openIndex + openTag.length);
+  }
+  let hasClosingTag = closeIndex !== -1;
+  if (closeIndex === -1) {
+    closeIndex = xmlString.length;
+  }
+  const innerContent = xmlString.substring(
+    openIndex + openTag.length,
+    closeIndex
+  );
+  const params = {};
+  const validParams = getValidParamsForTool(toolName);
+  for (const paramName of validParams) {
+    const paramOpenTag = `<${paramName}>`;
+    const paramCloseTag = `</${paramName}>`;
+    const paramOpenIndex = innerContent.indexOf(paramOpenTag);
+    if (paramOpenIndex === -1) {
+      continue;
     }
-    const innerContent = xmlString.substring(
-      openIndex + openTag.length,
-      closeIndex
-    );
-    const params = {};
-    const validParams = getValidParamsForTool(toolName);
-    for (const paramName of validParams) {
-      const paramOpenTag = `<${paramName}>`;
-      const paramCloseTag = `</${paramName}>`;
-      const paramOpenIndex = innerContent.indexOf(paramOpenTag);
-      if (paramOpenIndex === -1) {
-        continue;
-      }
-      let paramCloseIndex = innerContent.indexOf(paramCloseTag, paramOpenIndex + paramOpenTag.length);
-      if (paramCloseIndex === -1) {
-        let nextTagIndex = innerContent.length;
-        for (const nextParam of validParams) {
-          const nextOpenTag = `<${nextParam}>`;
-          const nextIndex = innerContent.indexOf(nextOpenTag, paramOpenIndex + paramOpenTag.length);
-          if (nextIndex !== -1 && nextIndex < nextTagIndex) {
-            nextTagIndex = nextIndex;
-          }
+    let paramCloseIndex = innerContent.indexOf(paramCloseTag, paramOpenIndex + paramOpenTag.length);
+    if (paramCloseIndex === -1) {
+      let nextTagIndex = innerContent.length;
+      for (const nextParam of validParams) {
+        const nextOpenTag = `<${nextParam}>`;
+        const nextIndex = innerContent.indexOf(nextOpenTag, paramOpenIndex + paramOpenTag.length);
+        if (nextIndex !== -1 && nextIndex < nextTagIndex) {
+          nextTagIndex = nextIndex;
         }
-        paramCloseIndex = nextTagIndex;
       }
-      let paramValue = innerContent.substring(
-        paramOpenIndex + paramOpenTag.length,
-        paramCloseIndex
-      ).trim();
-      if (paramValue.toLowerCase() === "true") {
-        paramValue = true;
-      } else if (paramValue.toLowerCase() === "false") {
-        paramValue = false;
-      } else if (!isNaN(paramValue) && paramValue.trim() !== "") {
-        const num = Number(paramValue);
-        if (Number.isFinite(num)) {
-          paramValue = num;
-        }
-      }
-      params[paramName] = paramValue;
+      paramCloseIndex = nextTagIndex;
     }
-    if (toolName === "attempt_completion") {
-      params["result"] = innerContent.trim();
-      if (params.command) {
-        delete params.command;
+    let paramValue = innerContent.substring(
+      paramOpenIndex + paramOpenTag.length,
+      paramCloseIndex
+    ).trim();
+    if (paramValue.toLowerCase() === "true") {
+      paramValue = true;
+    } else if (paramValue.toLowerCase() === "false") {
+      paramValue = false;
+    } else if (!isNaN(paramValue) && paramValue.trim() !== "") {
+      const num = Number(paramValue);
+      if (Number.isFinite(num)) {
+        paramValue = num;
       }
     }
-    return { toolName, params };
+    params[paramName] = paramValue;
   }
-  return null;
+  if (toolName === "attempt_completion") {
+    params["result"] = innerContent.trim();
+    if (params.command) {
+      delete params.command;
+    }
+  }
+  return { toolName, params };
 }
 function createMessagePreview(message, charsPerSide = 200) {
   if (message === null || message === void 0) {
@@ -9113,7 +9572,7 @@ function resolveTargetPath(target, cwd) {
   }
   return filePart + suffix;
 }
-var searchSchema, querySchema, extractSchema, delegateSchema, listSkillsSchema, useSkillSchema, bashSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, delegateToolDefinition, attemptCompletionToolDefinition, bashToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, DEFAULT_VALID_TOOLS;
+var searchSchema, querySchema, extractSchema, delegateSchema, listSkillsSchema, useSkillSchema, bashSchema, analyzeAllSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, delegateToolDefinition, attemptCompletionToolDefinition, analyzeAllToolDefinition, bashToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, analyzeAllDescription, DEFAULT_VALID_TOOLS;
 var init_common = __esm({
   "src/tools/common.js"() {
     "use strict";
@@ -9150,6 +9609,10 @@ var init_common = __esm({
       timeout: external_exports.number().optional().describe("Command timeout in milliseconds (optional)"),
       env: external_exports.record(external_exports.string()).optional().describe("Additional environment variables (optional)")
     });
+    analyzeAllSchema = external_exports.object({
+      question: external_exports.string().min(1).describe('Free-form question to answer (e.g., "What features are customers using?", "List all API endpoints"). The AI will automatically plan the search strategy, process all matching data, and synthesize a comprehensive answer.'),
+      path: external_exports.string().optional().default(".").describe("Directory path to search in")
+    });
     attemptCompletionSchema = {
       // Custom validation that requires result parameter but allows direct XML response
       safeParse: (params) => {
@@ -9359,6 +9822,51 @@ Usage Example:
 <attempt_completion>
 I have refactored the search module according to the requirements and verified the tests pass. The module now uses the new BM25 ranking algorithm and has improved error handling.
 </attempt_completion>
+`;
+    analyzeAllToolDefinition = `
+## analyze_all
+Description: Intelligent bulk data analysis tool. Process ALL data matching your question using a 3-phase approach:
+1. **PLANNING**: AI analyzes your question and determines the optimal search strategy
+2. **PROCESSING**: Map-reduce processes all matching data in parallel chunks
+3. **SYNTHESIS**: Comprehensive answer with evidence and organization
+
+**Use this for questions requiring 100% data coverage:**
+- "What features are customers using?"
+- "List all API endpoints in the codebase"
+- "Summarize the error handling patterns"
+- "Count all TODO comments and their contexts"
+
+**Do NOT use for:**
+- Simple searches where a sample is sufficient
+- Finding a specific function or class
+- Quick exploration (use search instead)
+
+**WARNING:** Makes multiple LLM calls - slower and costlier than search.
+
+Parameters:
+- question: (required) Free-form question to answer - the AI determines the best search strategy automatically
+- path: (optional) Directory to search in (default: current directory)
+
+<examples>
+
+User: What are all the different tools available in this codebase?
+<analyze_all>
+<question>What are all the different tools available in this codebase and what do they do?</question>
+<path>./src</path>
+</analyze_all>
+
+User: I need to understand all the error handling patterns
+<analyze_all>
+<question>What error handling patterns are used throughout the codebase? Include examples.</question>
+</analyze_all>
+
+User: Count and categorize all the environment variables
+<analyze_all>
+<question>What environment variables are used? Categorize them by purpose.</question>
+<path>./src</path>
+</analyze_all>
+
+</examples>
 `;
     bashToolDefinition = `
 ## bash
@@ -9419,11 +9927,13 @@ User: Check system info
     queryDescription = "Search code using ast-grep structural pattern matching. Use this tool to find specific code structures like functions, classes, or methods.";
     extractDescription = "Extract code blocks from files based on file paths and optional line numbers. Use this tool to see complete context after finding relevant files.";
     delegateDescription = "Automatically delegate big distinct tasks to specialized probe subagents within the agentic loop. Used by AI agents to break down complex requests into focused, parallel tasks.";
+    analyzeAllDescription = 'Answer questions that require analyzing ALL matching data in the codebase. Use for aggregate questions like "What features exist?", "List all API endpoints", "Count TODO comments". The AI automatically plans the search strategy, processes all results via map-reduce, and synthesizes a comprehensive answer. WARNING: Slower than search - only use when you need complete coverage.';
     DEFAULT_VALID_TOOLS = [
       "search",
       "query",
       "extract",
       "delegate",
+      "analyze_all",
       "listSkills",
       "useSkill",
       "listFiles",
@@ -9541,7 +10051,7 @@ function buildSearchDelegateTask({ searchQuery, searchPath, exact, language, all
     "Deduplicate targets. Do NOT explain or answer - ONLY return the JSON targets."
   ].join("\n");
 }
-var CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool;
+var CODE_SEARCH_SCHEMA, searchTool, queryTool, extractTool, delegateTool, analyzeAllTool;
 var init_vercel = __esm({
   "src/tools/vercel.js"() {
     "use strict";
@@ -9549,6 +10059,7 @@ var init_vercel = __esm({
     init_query();
     init_extract();
     init_delegate();
+    init_analyzeAll();
     init_common();
     init_error_types();
     CODE_SEARCH_SCHEMA = {
@@ -9566,7 +10077,7 @@ var init_vercel = __esm({
     searchTool = (options = {}) => {
       const {
         sessionId,
-        maxTokens = 1e4,
+        maxTokens = 2e4,
         debug = false,
         outline = false,
         searchDelegate = false
@@ -9791,7 +10302,7 @@ var init_vercel = __esm({
       });
     };
     delegateTool = (options = {}) => {
-      const { debug = false, timeout = 300, cwd, allowedFolders, enableBash = false, bashConfig, architectureFileName } = options;
+      const { debug = false, timeout = 300, cwd, allowedFolders, enableBash = false, bashConfig, architectureFileName, enableMcp = false, mcpConfig = null, mcpConfigPath = null } = options;
       return tool2({
         name: "delegate",
         description: delegateDescription,
@@ -9850,12 +10361,54 @@ var init_vercel = __esm({
             enableBash,
             bashConfig,
             architectureFileName,
-            searchDelegate
+            searchDelegate,
+            enableMcp,
+            mcpConfig,
+            mcpConfigPath
           });
           return result;
         }
       });
     };
+    analyzeAllTool = (options = {}) => {
+      const { sessionId, debug = false } = options;
+      return tool2({
+        name: "analyze_all",
+        description: analyzeAllDescription,
+        inputSchema: analyzeAllSchema,
+        execute: async ({ question, path: path9 }) => {
+          try {
+            let searchPath = path9 || ".";
+            if (path9 && options.cwd) {
+              const resolvedPaths = parseAndResolvePaths(path9, options.cwd);
+              if (resolvedPaths.length > 0) {
+                searchPath = resolvedPaths[0];
+              }
+            }
+            if (debug) {
+              console.error(`[analyze_all] Starting analysis`);
+              console.error(`[analyze_all] Question: ${question}`);
+              console.error(`[analyze_all] Path: ${searchPath}`);
+            }
+            const result = await analyzeAll({
+              question,
+              path: searchPath,
+              sessionId,
+              debug,
+              cwd: options.cwd,
+              allowedFolders: options.allowedFolders,
+              provider: options.provider,
+              model: options.model,
+              tracer: options.tracer
+            });
+            return result;
+          } catch (error) {
+            console.error("Error executing analyze_all:", error);
+            return formatErrorForAI(error);
+          }
+        }
+      });
+    };
   }
 });
 
@@ -10377,6 +10930,38 @@ function parseSimpleCommand(command) {
       isComplex: false
     };
   }
+  const stripQuotedContent = (str) => {
+    let result = "";
+    let inQuotes2 = false;
+    let quoteChar2 = "";
+    for (let i = 0; i < str.length; i++) {
+      const char = str[i];
+      const nextChar = str[i + 1];
+      if (!inQuotes2 && char === "\\" && nextChar !== void 0) {
+        i++;
+        continue;
+      }
+      if (inQuotes2 && quoteChar2 === '"' && char === "\\" && nextChar !== void 0) {
+        i++;
+        continue;
+      }
+      if (!inQuotes2 && (char === '"' || char === "'")) {
+        inQuotes2 = true;
+        quoteChar2 = char;
+        continue;
+      }
+      if (inQuotes2 && char === quoteChar2) {
+        inQuotes2 = false;
+        quoteChar2 = "";
+        continue;
+      }
+      if (!inQuotes2) {
+        result += char;
+      }
+    }
+    return result;
+  };
+  const strippedForOperators = stripQuotedContent(trimmed);
   const complexPatterns = [
     /\|/,
     // Pipes
@@ -10402,7 +10987,7 @@ function parseSimpleCommand(command) {
     // Brace expansion like {a,b} or {1..10} (but not find {} placeholders)
   ];
   for (const pattern of complexPatterns) {
-    if (pattern.test(trimmed)) {
+    if (pattern.test(strippedForOperators)) {
       return {
         success: false,
         error: "Complex shell commands with pipes, operators, or redirections are not supported for security reasons",
@@ -10417,17 +11002,17 @@ function parseSimpleCommand(command) {
   let current = "";
   let inQuotes = false;
   let quoteChar = "";
-  let escaped = false;
   for (let i = 0; i < trimmed.length; i++) {
     const char = trimmed[i];
     const nextChar = i + 1 < trimmed.length ? trimmed[i + 1] : "";
-    if (escaped) {
-      current += char;
-      escaped = false;
+    if (!inQuotes && char === "\\" && nextChar) {
+      current += nextChar;
+      i++;
       continue;
     }
-    if (char === "\\" && !inQuotes) {
-      escaped = true;
+    if (inQuotes && quoteChar === '"' && char === "\\" && nextChar) {
+      current += nextChar;
+      i++;
       continue;
     }
     if (!inQuotes && (char === '"' || char === "'")) {
@@ -10760,8 +11345,97 @@ var init_bashPermissions = __esm({
         });
         return result;
       }
+      /**
+       * Split a complex command into component commands by operators
+       *
+       * ## Escape Handling (Security-Critical)
+       *
+       * This function intentionally PRESERVES escape sequences (both backslash AND
+       * escaped character) in the output. This is step 1 of a 2-step parsing process:
+       *
+       * 1. _splitComplexCommand: Splits by operators, PRESERVES escapes → `echo "test\" && b"`
+       * 2. parseCommand: Interprets escapes in each component → args: ['test" && b']
+       *
+       * This differs from stripQuotedContent() in bashCommandUtils.js which REMOVES
+       * escapes entirely (for operator detection only).
+       *
+       * The security rationale: if we stripped escapes here, `\"` would become `"`,
+       * potentially causing incorrect quote boundary detection and allowing operator
+       * injection. By preserving escapes, parseCommand() can correctly interpret them.
+       *
+       * See bashCommandUtils.js module header for the full escape handling architecture.
+       *
+       * @private
+       * @param {string} command - Complex command to split
+       * @returns {string[]} Array of component commands (with escapes preserved)
+       */
+      _splitComplexCommand(command) {
+        const components = [];
+        let current = "";
+        let inQuotes = false;
+        let quoteChar = "";
+        let i = 0;
+        while (i < command.length) {
+          const char = command[i];
+          const nextChar = command[i + 1] || "";
+          if (!inQuotes && char === "\\") {
+            current += char;
+            if (nextChar) {
+              current += nextChar;
+              i += 2;
+            } else {
+              i++;
+            }
+            continue;
+          }
+          if (inQuotes && quoteChar === '"' && char === "\\" && nextChar) {
+            current += char + nextChar;
+            i += 2;
+            continue;
+          }
+          if (!inQuotes && (char === '"' || char === "'")) {
+            inQuotes = true;
+            quoteChar = char;
+            current += char;
+            i++;
+            continue;
+          }
+          if (inQuotes && char === quoteChar) {
+            inQuotes = false;
+            quoteChar = "";
+            current += char;
+            i++;
+            continue;
+          }
+          if (!inQuotes) {
+            if (char === "&" && nextChar === "&" || char === "|" && nextChar === "|") {
+              if (current.trim()) {
+                components.push(current.trim());
+              }
+              current = "";
+              i += 2;
+              continue;
+            }
+            if (char === "|") {
+              if (current.trim()) {
+                components.push(current.trim());
+              }
+              current = "";
+              i++;
+              continue;
+            }
+          }
+          current += char;
+          i++;
+        }
+        if (current.trim()) {
+          components.push(current.trim());
+        }
+        return components;
+      }
       /**
        * Check a complex command against complex patterns in allow/deny lists
+       * Also supports auto-allowing commands where all components are individually allowed
        * @private
        * @param {string} command - Complex command to check
        * @returns {Object} Permission result
@@ -10816,6 +11490,85 @@ var init_bashPermissions = __esm({
             return result;
           }
         }
+        const components = this._splitComplexCommand(command);
+        if (this.debug) {
+          console.log(`[BashPermissions] Checking ${components.length} command components: ${JSON.stringify(components)}`);
+        }
+        if (components.length > 1) {
+          const componentResults = [];
+          let allAllowed = true;
+          let deniedComponent = null;
+          let deniedReason = null;
+          for (const component of components) {
+            const parsed = parseCommand(component);
+            if (parsed.error || parsed.isComplex) {
+              if (this.debug) {
+                console.log(`[BashPermissions] Component "${component}" is complex or has error: ${parsed.error}`);
+              }
+              allAllowed = false;
+              deniedComponent = component;
+              deniedReason = parsed.error || "Component contains nested complex constructs";
+              break;
+            }
+            if (matchesAnyPattern(parsed, this.denyPatterns)) {
+              if (this.debug) {
+                console.log(`[BashPermissions] Component "${component}" matches deny pattern`);
+              }
+              allAllowed = false;
+              deniedComponent = component;
+              deniedReason = "Component matches deny pattern";
+              break;
+            }
+            if (!matchesAnyPattern(parsed, this.allowPatterns)) {
+              if (this.debug) {
+                console.log(`[BashPermissions] Component "${component}" not in allow list`);
+              }
+              allAllowed = false;
+              deniedComponent = component;
+              deniedReason = "Component not in allow list";
+              break;
+            }
+            componentResults.push({ component, parsed, allowed: true });
+          }
+          if (allAllowed) {
+            if (this.debug) {
+              console.log(`[BashPermissions] ALLOWED - all ${components.length} components passed individual checks`);
+            }
+            const result = {
+              allowed: true,
+              command,
+              isComplex: true,
+              allowedByComponents: true,
+              components: componentResults
+            };
+            this.recordBashEvent("permission.allowed", {
+              command,
+              isComplex: true,
+              allowedByComponents: true,
+              componentCount: components.length
+            });
+            return result;
+          } else {
+            if (this.debug) {
+              console.log(`[BashPermissions] DENIED - component "${deniedComponent}" failed: ${deniedReason}`);
+            }
+            const result = {
+              allowed: false,
+              reason: `Component "${deniedComponent}" not allowed: ${deniedReason}`,
+              command,
+              isComplex: true,
+              failedComponent: deniedComponent
+            };
+            this.recordBashEvent("permission.denied", {
+              command,
+              reason: "component_not_allowed",
+              failedComponent: deniedComponent,
+              componentReason: deniedReason,
+              isComplex: true
+            });
+            return result;
+          }
+        }
         if (this.debug) {
           console.log(`[BashPermissions] DENIED - no matching complex pattern found`);
         }
@@ -18565,6 +19318,13 @@ function createWrappedTools(baseTools) {
       baseTools.delegateTool.execute
     );
   }
+  if (baseTools.analyzeAllTool) {
+    wrappedTools.analyzeAllToolInstance = wrapToolWithEmitter(
+      baseTools.analyzeAllTool,
+      "analyze_all",
+      baseTools.analyzeAllTool.execute
+    );
+  }
   if (baseTools.bashTool) {
     wrappedTools.bashToolInstance = wrapToolWithEmitter(
       baseTools.bashTool,
@@ -19471,6 +20231,9 @@ function createTools(configOptions) {
   if (configOptions.enableDelegate && isToolAllowed("delegate")) {
     tools2.delegateTool = delegateTool(configOptions);
   }
+  if (isToolAllowed("analyze_all")) {
+    tools2.analyzeAllTool = analyzeAllTool(configOptions);
+  }
   if (configOptions.enableBash && isToolAllowed("bash")) {
     tools2.bashTool = bashTool(configOptions);
   }
@@ -67393,14 +68156,14 @@ function calculateCompactionStats(originalMessages, compactedMessages) {
   const compactedCount = compactedMessages.length;
   const removed = originalCount - compactedCount;
   const reductionPercent = originalCount > 0 ? (removed / originalCount * 100).toFixed(1) : 0;
-  const estimateTokens = (msgs) => {
+  const estimateTokens2 = (msgs) => {
     return msgs.reduce((sum, msg) => {
       const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
       return sum + Math.ceil(content.length / 4);
     }, 0);
   };
-  const originalTokens = estimateTokens(originalMessages);
-  const compactedTokens = estimateTokens(compactedMessages);
+  const originalTokens = estimateTokens2(originalMessages);
+  const compactedTokens = estimateTokens2(compactedMessages);
   const tokensSaved = originalTokens - compactedTokens;
   return {
     originalCount,
@@ -67481,7 +68244,7 @@ async function truncateIfNeeded(content, tokenCounter, sessionId, maxTokens) {
   if (tokenCount <= limit) {
     return { truncated: false, content };
   }
-  const maxChars = limit * CHARS_PER_TOKEN;
+  const maxChars = limit * CHARS_PER_TOKEN2;
   const truncatedContent = content.substring(0, maxChars);
   let tempFilePath = null;
   let fileError = null;
@@ -67520,12 +68283,12 @@ ${truncatedContent}
     error: fileError || void 0
   };
 }
-var DEFAULT_MAX_OUTPUT_TOKENS, CHARS_PER_TOKEN;
+var DEFAULT_MAX_OUTPUT_TOKENS, CHARS_PER_TOKEN2;
 var init_outputTruncator = __esm({
   "src/agent/outputTruncator.js"() {
     "use strict";
     DEFAULT_MAX_OUTPUT_TOKENS = 2e4;
-    CHARS_PER_TOKEN = 4;
+    CHARS_PER_TOKEN2 = 4;
   }
 });
 
@@ -69385,6 +70148,9 @@ var init_ProbeAgent = __esm({
         if (this.enableDelegate && wrappedTools.delegateToolInstance && isToolAllowed("delegate")) {
           this.toolImplementations.delegate = wrappedTools.delegateToolInstance;
         }
+        if (wrappedTools.analyzeAllToolInstance && isToolAllowed("analyze_all")) {
+          this.toolImplementations.analyze_all = wrappedTools.analyzeAllToolInstance;
+        }
         if (isToolAllowed("listFiles")) {
           this.toolImplementations.listFiles = listFilesToolInstance;
         }
@@ -70584,6 +71350,10 @@ Workspace: ${this.allowedFolders.join(", ")}`;
         }
         if (this.enableDelegate && isToolAllowed("delegate")) {
           toolDefinitions += `${delegateToolDefinition}
+`;
+        }
+        if (isToolAllowed("analyze_all")) {
+          toolDefinitions += `${analyzeAllToolDefinition}
 `;
         }
         let toolExamples = "";
@@ -70647,6 +71417,9 @@ The configuration is loaded from src/config.js lines 15-25 which contains the da
         if (this.enableDelegate && isToolAllowed("delegate")) {
           availableToolsList += "- delegate: Delegate big distinct tasks to specialized probe subagents.\n";
         }
+        if (isToolAllowed("analyze_all")) {
+          availableToolsList += "- analyze_all: Process ALL data matching a query using map-reduce (for aggregate questions needing 100% coverage).\n";
+        }
         if (this.enableBash && isToolAllowed("bash")) {
           availableToolsList += "- bash: Execute bash commands for system operations.\n";
         }
@@ -71033,6 +71806,9 @@ You are working with a repository located at: ${searchDirectory}
           let lastFormatErrorType = null;
           let sameFormatErrorCount = 0;
           const MAX_REPEATED_FORMAT_ERRORS = 3;
+          let lastNoToolResponse = null;
+          let sameResponseCount = 0;
+          const MAX_REPEATED_IDENTICAL_RESPONSES = 3;
           while (currentIteration < maxIterations && !completionAttempted) {
             currentIteration++;
             if (this.cancelled) throw new Error("Request was cancelled by the user");
@@ -71070,11 +71846,11 @@ You are working with a repository located at: ${searchDirectory}
             let maxResponseTokens = this.maxResponseTokens;
             if (!maxResponseTokens) {
               maxResponseTokens = 4e3;
-              if (this.model.includes("opus") || this.model.includes("sonnet") || this.model.startsWith("gpt-4-")) {
+              if (this.model && this.model.includes("opus") || this.model && this.model.includes("sonnet") || this.model && this.model.startsWith("gpt-4-")) {
                 maxResponseTokens = 8192;
-              } else if (this.model.startsWith("gpt-4o")) {
+              } else if (this.model && this.model.startsWith("gpt-4o")) {
                 maxResponseTokens = 8192;
-              } else if (this.model.startsWith("gemini")) {
+              } else if (this.model && this.model.startsWith("gemini")) {
                 maxResponseTokens = 32e3;
               }
             }
@@ -71514,6 +72290,26 @@ ${errorXml}
                 }
                 break;
               }
+              if (lastNoToolResponse !== null && assistantResponseContent === lastNoToolResponse) {
+                sameResponseCount++;
+                if (sameResponseCount >= MAX_REPEATED_IDENTICAL_RESPONSES) {
+                  let cleanedResponse = assistantResponseContent;
+                  cleanedResponse = cleanedResponse.replace(/<thinking>[\s\S]*?<\/thinking>/gi, "").trim();
+                  cleanedResponse = cleanedResponse.replace(/<thinking>[\s\S]*$/gi, "").trim();
+                  const hasSubstantialContent = cleanedResponse.length > 50 && !cleanedResponse.includes("<api_call>") && !cleanedResponse.includes("<tool_name>") && !cleanedResponse.includes("<function>");
+                  if (hasSubstantialContent) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] Same response repeated ${sameResponseCount} times - accepting as final answer (${cleanedResponse.length} chars)`);
+                    }
+                    finalResult = cleanedResponse;
+                    completionAttempted = true;
+                    break;
+                  }
+                }
+              } else {
+                lastNoToolResponse = assistantResponseContent;
+                sameResponseCount = 1;
+              }
               currentMessages.push({ role: "assistant", content: assistantResponseContent });
               const unrecognizedTool = detectUnrecognizedToolCall(assistantResponseContent, validTools);
               let reminderContent;
@@ -71586,10 +72382,35 @@ Or if your previous response already contains a complete, direct answer (not a t
 
 Note: <attempt_complete></attempt_complete> reuses your PREVIOUS assistant message as the final answer. Only use this if that message was already a valid, complete response to the user's question.`;
               }
-              currentMessages.push({
-                role: "user",
-                content: reminderContent
-              });
+              const prevUserMsgIndex = currentMessages.length - 2;
+              const prevUserMsg = currentMessages[prevUserMsgIndex];
+              const isExistingReminder = prevUserMsg && prevUserMsg.role === "user" && (prevUserMsg.content.includes("Please use one of the available tools") || prevUserMsg.content.includes("<tool_result>"));
+              if (isExistingReminder && sameResponseCount > 1) {
+                const prevAssistantIndex = prevUserMsgIndex - 1;
+                const hasSystemMessage2 = currentMessages.length > 0 && currentMessages[0].role === "system";
+                const minValidIndex = hasSystemMessage2 ? 1 : 0;
+                const canSafelyRemove = prevAssistantIndex >= minValidIndex && currentMessages[prevAssistantIndex] && currentMessages[prevAssistantIndex].role === "assistant" && currentMessages.length - 2 >= (hasSystemMessage2 ? 2 : 1);
+                if (canSafelyRemove) {
+                  currentMessages.splice(prevAssistantIndex, 2);
+                  if (this.debug) {
+                    console.log(`[DEBUG] Removed duplicate assistant+reminder pair (iteration ${currentIteration}, same response #${sameResponseCount})`);
+                  }
+                } else if (this.debug) {
+                  console.log(`[DEBUG] Skipped deduplication: pattern validation failed (prevAssistantIndex=${prevAssistantIndex}, arrayLength=${currentMessages.length})`);
+                }
+                const iterationHint = `
+
+(Attempt #${sameResponseCount}: Your previous ${sameResponseCount} responses were identical. If you have a complete answer, use <attempt_complete></attempt_complete> to finalize it.)`;
+                currentMessages.push({
+                  role: "user",
+                  content: reminderContent + iterationHint
+                });
+              } else {
+                currentMessages.push({
+                  role: "user",
+                  content: reminderContent
+                });
+              }
               if (this.debug) {
                 if (unrecognizedTool) {
                   console.log(`[DEBUG] Unrecognized tool '${unrecognizedTool}' used. Providing error feedback.`);