@probelabs/probe 0.6.0-rc102 → 0.6.0-rc103

package/build/agent/index.js

@@ -1821,7 +1821,7 @@ async function delegate({ task, timeout = 300, debug = false, currentIteration =
       console.error(`[DELEGATE] Using binary at: ${binaryPath}`);
       console.error(`[DELEGATE] Command args: ${args.join(" ")}`);
     }
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const delegationSpan = tracer ? tracer.createDelegationSpan(sessionId, task) : null;
       const process2 = spawn(binaryPath, args, {
         stdio: ["pipe", "pipe", "pipe"],
@@ -1886,7 +1886,7 @@ async function delegate({ task, timeout = 300, debug = false, currentIteration =
               delegationSpan.end();
             }
           }
-          resolve2(response);
+          resolve3(response);
         } else {
           const errorMessage = stderr.trim() || `Delegate process failed with exit code ${code}`;
           if (debug) {
@@ -2516,20 +2516,20 @@ var init_simpleTelemetry = __esm({
       }
       async flush() {
         if (this.stream) {
-          return new Promise((resolve2) => {
-            this.stream.once("drain", resolve2);
+          return new Promise((resolve3) => {
+            this.stream.once("drain", resolve3);
             if (!this.stream.writableNeedDrain) {
-              resolve2();
+              resolve3();
             }
           });
         }
       }
       async shutdown() {
         if (this.stream) {
-          return new Promise((resolve2) => {
+          return new Promise((resolve3) => {
             this.stream.end(() => {
               console.log(`[SimpleTelemetry] File stream closed: ${this.filePath}`);
-              resolve2();
+              resolve3();
             });
           });
         }
@@ -2975,7 +2975,7 @@ function createMockProvider() {
       provider: "mock",
       // Mock the doGenerate method used by Vercel AI SDK
       doGenerate: async ({ messages, tools: tools2 }) => {
-        await new Promise((resolve2) => setTimeout(resolve2, 10));
+        await new Promise((resolve3) => setTimeout(resolve3, 10));
         return {
           text: "This is a mock response for testing",
           toolCalls: [],
@@ -4865,7 +4865,10 @@ import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { streamText } from "ai";
 import { randomUUID as randomUUID4 } from "crypto";
 import { EventEmitter as EventEmitter2 } from "events";
-var MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, ProbeAgent;
+import { existsSync as existsSync3 } from "fs";
+import { readFile, stat } from "fs/promises";
+import { resolve, isAbsolute } from "path";
+var MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, SUPPORTED_IMAGE_EXTENSIONS, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
     "use strict";
@@ -4879,6 +4882,8 @@ var init_ProbeAgent = __esm({
     init_mcp();
     MAX_TOOL_ITERATIONS = parseInt(process.env.MAX_TOOL_ITERATIONS || "30", 10);
     MAX_HISTORY_MESSAGES = 100;
+    SUPPORTED_IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "webp", "gif", "bmp", "svg"];
+    MAX_IMAGE_FILE_SIZE = 20 * 1024 * 1024;
     ProbeAgent = class {
       /**
        * Create a new ProbeAgent instance
@@ -4922,6 +4927,8 @@ var init_ProbeAgent = __esm({
         }
         this.initializeTools();
         this.history = [];
+        this.pendingImages = /* @__PURE__ */ new Map();
+        this.currentImages = [];
         this.events = new EventEmitter2();
         this.enableMcp = !!options.enableMcp || process.env.ENABLE_MCP === "1";
         this.mcpConfigPath = options.mcpConfigPath || null;
@@ -5047,6 +5054,175 @@ var init_ProbeAgent = __esm({
           console.log(`Using Google API with model: ${this.model}${apiUrl ? ` (URL: ${apiUrl})` : ""}`);
         }
       }
+      /**
+       * Process assistant response content and detect/load image references
+       * @param {string} content - The assistant's response content
+       * @returns {Promise<void>}
+       */
+      async processImageReferences(content) {
+        if (!content) return;
+        const extensionsPattern = `(?:${SUPPORTED_IMAGE_EXTENSIONS.join("|")})`;
+        const imagePatterns = [
+          // Direct file path mentions: "./screenshot.png", "/path/to/image.jpg", etc.
+          new RegExp(`(?:\\.?\\.\\/)?[^\\s"'<>\\[\\]]+\\.${extensionsPattern}(?!\\w)`, "gi"),
+          // Contextual mentions: "look at image.png", "the file screenshot.jpg shows"
+          new RegExp(`(?:image|file|screenshot|diagram|photo|picture|graphic)\\s*:?\\s*([^\\s"'<>\\[\\]]+\\.${extensionsPattern})(?!\\w)`, "gi"),
+          // Tool result mentions: often contain file paths
+          new RegExp(`(?:found|saved|created|generated).*?([^\\s"'<>\\[\\]]+\\.${extensionsPattern})(?!\\w)`, "gi")
+        ];
+        const foundPaths = /* @__PURE__ */ new Set();
+        for (const pattern of imagePatterns) {
+          let match;
+          while ((match = pattern.exec(content)) !== null) {
+            const imagePath = match[1] || match[0];
+            if (imagePath && imagePath.length > 0) {
+              foundPaths.add(imagePath.trim());
+            }
+          }
+        }
+        if (foundPaths.size === 0) return;
+        if (this.debug) {
+          console.log(`[DEBUG] Found ${foundPaths.size} potential image references:`, Array.from(foundPaths));
+        }
+        for (const imagePath of foundPaths) {
+          await this.loadImageIfValid(imagePath);
+        }
+      }
+      /**
+       * Load and cache an image if it's valid and accessible
+       * @param {string} imagePath - Path to the image file
+       * @returns {Promise<boolean>} - True if image was loaded successfully
+       */
+      async loadImageIfValid(imagePath) {
+        try {
+          if (this.pendingImages.has(imagePath)) {
+            if (this.debug) {
+              console.log(`[DEBUG] Image already loaded: ${imagePath}`);
+            }
+            return true;
+          }
+          const allowedDirs = this.allowedFolders && this.allowedFolders.length > 0 ? this.allowedFolders : [process.cwd()];
+          let absolutePath;
+          let isPathAllowed = false;
+          if (isAbsolute(imagePath)) {
+            absolutePath = imagePath;
+            isPathAllowed = allowedDirs.some((dir) => absolutePath.startsWith(resolve(dir)));
+          } else {
+            for (const dir of allowedDirs) {
+              const resolvedPath = resolve(dir, imagePath);
+              if (resolvedPath.startsWith(resolve(dir))) {
+                absolutePath = resolvedPath;
+                isPathAllowed = true;
+                break;
+              }
+            }
+          }
+          if (!isPathAllowed) {
+            if (this.debug) {
+              console.log(`[DEBUG] Image path outside allowed directories: ${imagePath}`);
+            }
+            return false;
+          }
+          let fileStats;
+          try {
+            fileStats = await stat(absolutePath);
+          } catch (error) {
+            if (this.debug) {
+              console.log(`[DEBUG] Image file not found: ${absolutePath}`);
+            }
+            return false;
+          }
+          if (fileStats.size > MAX_IMAGE_FILE_SIZE) {
+            if (this.debug) {
+              console.log(`[DEBUG] Image file too large: ${absolutePath} (${fileStats.size} bytes, max: ${MAX_IMAGE_FILE_SIZE})`);
+            }
+            return false;
+          }
+          const extension = absolutePath.toLowerCase().split(".").pop();
+          if (!SUPPORTED_IMAGE_EXTENSIONS.includes(extension)) {
+            if (this.debug) {
+              console.log(`[DEBUG] Unsupported image format: ${extension}`);
+            }
+            return false;
+          }
+          const mimeTypes = {
+            "png": "image/png",
+            "jpg": "image/jpeg",
+            "jpeg": "image/jpeg",
+            "webp": "image/webp",
+            "gif": "image/gif",
+            "bmp": "image/bmp",
+            "svg": "image/svg+xml"
+          };
+          const mimeType = mimeTypes[extension];
+          const fileBuffer = await readFile(absolutePath);
+          const base64Data = fileBuffer.toString("base64");
+          const dataUrl = `data:${mimeType};base64,${base64Data}`;
+          this.pendingImages.set(imagePath, dataUrl);
+          if (this.debug) {
+            console.log(`[DEBUG] Successfully loaded image: ${imagePath} (${fileBuffer.length} bytes)`);
+          }
+          return true;
+        } catch (error) {
+          if (this.debug) {
+            console.log(`[DEBUG] Failed to load image ${imagePath}: ${error.message}`);
+          }
+          return false;
+        }
+      }
+      /**
+       * Get all currently loaded images as an array for AI model consumption
+       * @returns {Array<string>} - Array of base64 data URLs
+       */
+      getCurrentImages() {
+        return Array.from(this.pendingImages.values());
+      }
+      /**
+       * Clear loaded images (useful for new conversations)
+       */
+      clearLoadedImages() {
+        this.pendingImages.clear();
+        this.currentImages = [];
+        if (this.debug) {
+          console.log("[DEBUG] Cleared all loaded images");
+        }
+      }
+      /**
+       * Prepare messages for AI consumption, adding images to the latest user message if available
+       * @param {Array} messages - Current conversation messages
+       * @returns {Array} - Messages formatted for AI SDK with potential image content
+       */
+      prepareMessagesWithImages(messages) {
+        const loadedImages = this.getCurrentImages();
+        if (loadedImages.length === 0) {
+          return messages;
+        }
+        const messagesWithImages = [...messages];
+        const lastUserMessageIndex = messagesWithImages.map((m) => m.role).lastIndexOf("user");
+        if (lastUserMessageIndex === -1) {
+          if (this.debug) {
+            console.log("[DEBUG] No user messages found to attach images to");
+          }
+          return messages;
+        }
+        const lastUserMessage = messagesWithImages[lastUserMessageIndex];
+        if (typeof lastUserMessage.content === "string") {
+          messagesWithImages[lastUserMessageIndex] = {
+            ...lastUserMessage,
+            content: [
+              { type: "text", text: lastUserMessage.content },
+              ...loadedImages.map((imageData) => ({
+                type: "image",
+                image: imageData
+              }))
+            ]
+          };
+          if (this.debug) {
+            console.log(`[DEBUG] Added ${loadedImages.length} images to the latest user message`);
+          }
+        }
+        return messagesWithImages;
+      }
       /**
        * Initialize mock model for testing
        */
@@ -5428,9 +5604,10 @@ You are working with a repository located at: ${searchDirectory}
             let assistantResponseContent = "";
             try {
               const executeAIRequest = async () => {
+                const messagesForAI = this.prepareMessagesWithImages(currentMessages);
                 const result = await streamText({
                   model: this.provider(this.model),
-                  messages: currentMessages,
+                  messages: messagesForAI,
                   maxTokens: maxResponseTokens,
                   temperature: 0.3
                 });
@@ -5464,6 +5641,9 @@ You are working with a repository located at: ${searchDirectory}
               const assistantPreview = createMessagePreview(assistantResponseContent);
               console.log(`[DEBUG] Assistant response (${assistantResponseContent.length} chars): ${assistantPreview}`);
             }
+            if (assistantResponseContent) {
+              await this.processImageReferences(assistantResponseContent);
+            }
             const validTools = [
               "search",
               "query",
@@ -5588,12 +5768,17 @@ ${toolResultContent}
                       throw toolError;
                     }
                     currentMessages.push({ role: "assistant", content: assistantResponseContent });
+                    const toolResultContent = typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult, null, 2);
+                    const toolResultMessage = `<tool_result>
+${toolResultContent}
+</tool_result>`;
                     currentMessages.push({
                       role: "user",
-                      content: `<tool_result>
-${typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult, null, 2)}
-</tool_result>`
+                      content: toolResultMessage
                     });
+                    if (toolResultContent) {
+                      await this.processImageReferences(toolResultContent);
+                    }
                     if (this.debug) {
                       console.log(`[DEBUG] Tool ${toolName} executed successfully. Result length: ${typeof toolResult === "string" ? toolResult.length : JSON.stringify(toolResult).length}`);
                     }
@@ -6094,8 +6279,8 @@ import {
   ListToolsRequestSchema,
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
-import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
-import { resolve } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync4 } from "fs";
+import { resolve as resolve2 } from "path";
 
 // src/agent/acp/server.js
 import { randomUUID as randomUUID5 } from "crypto";
@@ -6354,8 +6539,8 @@ var ACPConnection = class extends EventEmitter3 {
     if (params !== null) {
       message.params = params;
     }
-    return new Promise((resolve2, reject) => {
-      this.pendingRequests.set(id, { resolve: resolve2, reject });
+    return new Promise((resolve3, reject) => {
+      this.pendingRequests.set(id, { resolve: resolve3, reject });
       this.sendMessage(message);
       setTimeout(() => {
         if (this.pendingRequests.has(id)) {
@@ -6763,8 +6948,8 @@ import { randomUUID as randomUUID6 } from "crypto";
 function readInputContent(input) {
   if (!input) return null;
   try {
-    const resolvedPath = resolve(input);
-    if (existsSync3(resolvedPath)) {
+    const resolvedPath = resolve2(input);
+    if (existsSync4(resolvedPath)) {
       return readFileSync2(resolvedPath, "utf-8").trim();
     }
   } catch (error) {
@@ -6772,7 +6957,7 @@ function readInputContent(input) {
   return input;
 }
 function readFromStdin() {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let data = "";
     let hasReceivedData = false;
     let dataChunks = [];
@@ -6797,7 +6982,7 @@ function readFromStdin() {
       if (!trimmed && dataChunks.length === 0) {
         reject(new Error("No input received from stdin"));
       } else {
-        resolve2(trimmed);
+        resolve3(trimmed);
       }
     });
     process.stdin.on("error", (error) => {
@@ -6964,6 +7149,7 @@ var ProbeAgentMcpServer = class {
         }
       }
     );
+    this.agent = null;
     this.setupToolHandlers();
     this.server.onerror = (error) => console.error("[MCP Error]", error);
     process.on("SIGINT", async () => {
@@ -7075,18 +7261,24 @@ var ProbeAgentMcpServer = class {
             throw new Error("Schema could not be read");
           }
         }
-        const agentConfig = {
-          path: args.path || process.cwd(),
-          promptType: args.prompt || "code-explorer",
-          customPrompt: systemPrompt,
-          provider: args.provider,
-          model: args.model,
-          allowEdit: !!args.allow_edit,
-          debug: process.env.DEBUG === "1",
-          maxResponseTokens: args.max_response_tokens,
-          disableMermaidValidation: !!args.no_mermaid_validation
-        };
-        const agent = new ProbeAgent(agentConfig);
+        if (!this.agent) {
+          if (process.env.DEBUG === "1") {
+            console.error("[DEBUG] Initializing AI agent on first MCP tool call");
+          }
+          const agentConfig2 = {
+            path: args.path || process.cwd(),
+            promptType: args.prompt || "code-explorer",
+            customPrompt: systemPrompt,
+            provider: args.provider,
+            model: args.model,
+            allowEdit: !!args.allow_edit,
+            debug: process.env.DEBUG === "1",
+            maxResponseTokens: args.max_response_tokens,
+            disableMermaidValidation: !!args.no_mermaid_validation
+          };
+          this.agent = new ProbeAgent(agentConfig2);
+        }
+        const agent = this.agent;
         let result = await agent.answer(query2, [], { schema });
         if (schema) {
           const schemaPrompt = `Now you need to respond according to this schema:
@@ -7147,7 +7339,7 @@ Please reformat your previous response to match this schema exactly. Only return
           } catch (error) {
           }
         }
-        const tokenUsage = agent.getTokenUsage();
+        const tokenUsage = this.agent.getTokenUsage();
         console.error(`Token usage: ${JSON.stringify(tokenUsage)}`);
         return {
           content: [
@@ -7272,7 +7464,7 @@ async function main() {
         process.exit(1);
       }
     }
-    const agentConfig = {
+    const agentConfig2 = {
       path: config.path,
       promptType: config.prompt,
       customPrompt: systemPrompt,
@@ -7283,7 +7475,7 @@ async function main() {
       maxResponseTokens: config.maxResponseTokens,
       disableMermaidValidation: config.noMermaidValidation
     };
-    const agent = new ProbeAgent(agentConfig);
+    const agent = new ProbeAgent(agentConfig2);
     let result;
     if (appTracer) {
       const sessionSpan = appTracer.createSessionSpan({

package/build/mcp/index.js

@@ -8,7 +8,7 @@ import path from 'path';
 import fs from 'fs-extra';
 import { fileURLToPath } from 'url';
 // Import from parent package
-import { search, query, extract } from '../index.js';
+import { search, extract } from '../index.js';
 // Parse command-line arguments
 function parseArgs() {
     const args = process.argv.slice(2);
@@ -128,38 +128,22 @@ class ProbeServer {
                             },
                             query: {
                                 type: 'string',
-                                description: 'Elastic search query. Supports logical operators (AND, OR, NOT), and grouping with parentheses. Examples: "config", "(term1 OR term2) AND term3". Use quotes for exact matches, like function or type names.',
-                            },
-                            filesOnly: {
-                                type: 'boolean',
-                                description: 'Skip AST parsing and just output unique files',
-                            },
-                            ignore: {
-                                type: 'array',
-                                items: { type: 'string' },
-                                description: 'Custom patterns to ignore (in addition to .gitignore and common patterns)'
-                            },
-                            excludeFilenames: {
-                                type: 'boolean',
-                                description: 'Exclude filenames from being used for matching'
+                                description: 'Elastic search query. Supports logical operators (AND, OR, NOT), and grouping with parentheses. For exact matches of specific identifiers, use quotes: "MyFunction", "SpecificStruct", "exact_variable_name". Examples: "config", "(term1 OR term2) AND term3", "getUserData", "struct Config".',
                             },
                             exact: {
                                 type: 'boolean',
-                                description: 'Perform exact search without tokenization (case-insensitive)'
+                                description: 'When you exactly know what you are looking for, like known function name, struct name, or variable name, set this flag for precise matching'
                             },
                             allowTests: {
                                 type: 'boolean',
-                                description: 'Allow test files and test code blocks in results (disabled by default)'
+                                description: 'Allow test files and test code blocks in results (enabled by default)',
+                                default: true
                             },
                             session: {
                                 type: 'string',
                                 description: 'Session identifier for caching. Set to "new" if unknown, or want to reset cache. Re-use session ID returned from previous searches',
                                 default: "new",
                             },
-                            timeout: {
-                                type: 'number',
-                                description: 'Timeout for the search operation in seconds (default: 30)',
-                            },
                             noGitignore: {
                                 type: 'boolean',
                                 description: 'Skip .gitignore files (will use PROBE_NO_GITIGNORE environment variable if not set)',
@@ -168,50 +152,6 @@ class ProbeServer {
                         required: ['path', 'query']
                     },
                 },
-                {
-                    name: 'query_code',
-                    description: "Search code using ast-grep structural pattern matching. Use this tool to find specific code structures like functions, classes, or methods.",
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            path: {
-                                type: 'string',
-                                description: 'Absolute path to the directory to search in (e.g., "/Users/username/projects/myproject").',
-                            },
-                            pattern: {
-                                type: 'string',
-                                description: 'The ast-grep pattern to search for. Examples: "fn $NAME($$$PARAMS) $$$BODY" for Rust functions, "def $NAME($$$PARAMS): $$$BODY" for Python functions.',
-                            },
-                            language: {
-                                type: 'string',
-                                description: 'The programming language to search in. If not specified, the tool will try to infer the language from file extensions. Supported languages: rust, javascript, typescript, python, go, c, cpp, java, ruby, php, swift, csharp, yaml.',
-                            },
-                            ignore: {
-                                type: 'array',
-                                items: { type: 'string' },
-                                description: 'Custom patterns to ignore (in addition to common patterns)',
-                            },
-                            maxResults: {
-                                type: 'number',
-                                description: 'Maximum number of results to return'
-                            },
-                            format: {
-                                type: 'string',
-                                enum: ['markdown', 'plain', 'json', 'color'],
-                                description: 'Output format for the query results'
-                            },
-                            timeout: {
-                                type: 'number',
-                                description: 'Timeout for the query operation in seconds (default: 30)',
-                            },
-                            noGitignore: {
-                                type: 'boolean',
-                                description: 'Skip .gitignore files (will use PROBE_NO_GITIGNORE environment variable if not set)',
-                            }
-                        },
-                        required: ['path', 'pattern']
-                    },
-                },
                 {
                     name: 'extract_code',
                     description: "Extract code blocks from files based on line number, or symbol name. Fetch full file when line number is not provided.",
@@ -229,22 +169,8 @@ class ProbeServer {
                             },
                             allowTests: {
                                 type: 'boolean',
-                                description: 'Allow test files and test code blocks in results (disabled by default)',
-                            },
-                            contextLines: {
-                                type: 'number',
-                                description: 'Number of context lines to include before and after the extracted block when AST parsing fails to find a suitable node',
-                                default: 0
-                            },
-                            format: {
-                                type: 'string',
-                                enum: ['markdown', 'plain', 'json'],
-                                description: 'Output format for the extracted code',
-                                default: 'markdown'
-                            },
-                            timeout: {
-                                type: 'number',
-                                description: 'Timeout for the extract operation in seconds (default: 30)',
+                                description: 'Allow test files and test code blocks in results (enabled by default)',
+                                default: true
                             },
                             noGitignore: {
                                 type: 'boolean',
@@ -257,8 +183,8 @@ class ProbeServer {
             ],
         }));
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            if (request.params.name !== 'search_code' && request.params.name !== 'query_code' && request.params.name !== 'extract_code' &&
-                request.params.name !== 'probe' && request.params.name !== 'query' && request.params.name !== 'extract') {
+            if (request.params.name !== 'search_code' && request.params.name !== 'extract_code' &&
+                request.params.name !== 'probe' && request.params.name !== 'extract') {
                 throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
             }
             try {
@@ -282,10 +208,6 @@ class ProbeServer {
                     }
                     result = await this.executeCodeSearch(args);
                 }
-                else if (request.params.name === 'query_code' || request.params.name === 'query') {
-                    const args = request.params.arguments;
-                    result = await this.executeCodeQuery(args);
-                }
                 else { // extract_code or extract
                     const args = request.params.arguments;
                     result = await this.executeCodeExtract(args);
@@ -331,20 +253,19 @@ class ProbeServer {
                 query: args.query
             };
             // Add optional parameters only if they exist
-            if (args.filesOnly !== undefined)
-                options.filesOnly = args.filesOnly;
-            if (args.ignore !== undefined)
-                options.ignore = args.ignore;
-            if (args.excludeFilenames !== undefined)
-                options.excludeFilenames = args.excludeFilenames;
             if (args.exact !== undefined)
                 options.exact = args.exact;
             if (args.maxResults !== undefined)
                 options.maxResults = args.maxResults;
             if (args.maxTokens !== undefined)
                 options.maxTokens = args.maxTokens;
-            if (args.allowTests !== undefined)
+            // Set allowTests to true by default if not specified
+            if (args.allowTests !== undefined) {
                 options.allowTests = args.allowTests;
+            }
+            else {
+                options.allowTests = true;
+            }
             // Use noGitignore from args, or fall back to PROBE_NO_GITIGNORE environment variable
             if (args.noGitignore !== undefined) {
                 options.noGitignore = args.noGitignore;
@@ -358,13 +279,6 @@ class ProbeServer {
             else {
                 options.session = "new";
             }
-            // Use timeout from args, or fall back to instance default
-            if (args.timeout !== undefined) {
-                options.timeout = args.timeout;
-            }
-            else if (this.defaultTimeout !== undefined) {
-                options.timeout = this.defaultTimeout;
-            }
             // Handle format options
             if (this.defaultFormat === 'outline-xml') {
                 // For outline-xml format, we pass it as a format flag to the search command
@@ -394,45 +308,6 @@ class ProbeServer {
             throw new McpError('MethodNotFound', `Error executing code search: ${error.message || String(error)}`);
         }
     }
-    async executeCodeQuery(args) {
-        try {
-            // Validate required parameters
-            if (!args.path) {
-                throw new Error("Path is required");
-            }
-            if (!args.pattern) {
-                throw new Error("Pattern is required");
-            }
-            // Create a single options object with both pattern and path
-            const options = {
-                path: args.path,
-                pattern: args.pattern,
-                language: args.language,
-                ignore: args.ignore,
-                allowTests: args.allowTests,
-                maxResults: args.maxResults,
-                format: args.format,
-                timeout: args.timeout || this.defaultTimeout
-            };
-            // Use noGitignore from args, or fall back to PROBE_NO_GITIGNORE environment variable
-            if (args.noGitignore !== undefined) {
-                options.noGitignore = args.noGitignore;
-            }
-            else if (process.env.PROBE_NO_GITIGNORE) {
-                options.noGitignore = process.env.PROBE_NO_GITIGNORE === 'true';
-            }
-            console.log("Executing query with options:", JSON.stringify({
-                path: options.path,
-                pattern: options.pattern
-            }));
-            const result = await query(options);
-            return result;
-        }
-        catch (error) {
-            console.error('Error executing code query:', error);
-            throw new McpError('MethodNotFound', `Error executing code query: ${error.message || String(error)}`);
-        }
-    }
     async executeCodeExtract(args) {
         try {
             // Validate required parameters
@@ -446,11 +321,15 @@ class ProbeServer {
             const options = {
                 files: args.files,
                 path: args.path,
-                allowTests: args.allowTests,
-                contextLines: args.contextLines,
-                format: args.format,
-                timeout: args.timeout || this.defaultTimeout
+                format: 'xml'
             };
+            // Set allowTests to true by default if not specified
+            if (args.allowTests !== undefined) {
+                options.allowTests = args.allowTests;
+            }
+            else {
+                options.allowTests = true;
+            }
             // Use noGitignore from args, or fall back to PROBE_NO_GITIGNORE environment variable
             if (args.noGitignore !== undefined) {
                 options.noGitignore = args.noGitignore;