@probelabs/probe 0.6.0-rc102 → 0.6.0-rc104

package/build/agent/probeTool.js

@@ -207,14 +207,24 @@ export function createWrappedTools(baseTools) {
 // Simple file listing tool
 export const listFilesTool = {
   execute: async (params) => {
-    const { directory = '.' } = params;
+    const { directory = '.', workingDirectory } = params;
+    
+    // Use the provided working directory, or fall back to process.cwd()
+    const baseCwd = workingDirectory || process.cwd();
+    
+    // Security: Validate path to prevent traversal attacks
+    const secureBaseDir = path.resolve(baseCwd);
+    const targetDir = path.resolve(secureBaseDir, directory);
+    if (!targetDir.startsWith(secureBaseDir + path.sep) && targetDir !== secureBaseDir) {
+      throw new Error('Path traversal attempt detected. Access denied.');
+    }
     
     try {
       const files = await listFilesByLevel({
-        directory,
+        directory: targetDir,
         maxFiles: 100,
         respectGitignore: !process.env.PROBE_NO_GITIGNORE || process.env.PROBE_NO_GITIGNORE === '',
-        cwd: process.cwd()
+        cwd: secureBaseDir
       });
       
       return files;
@@ -227,15 +237,23 @@ export const listFilesTool = {
 // Simple file search tool
 export const searchFilesTool = {
   execute: async (params) => {
-    const { pattern, directory = '.', recursive = true } = params;
+    const { pattern, directory = '.', recursive = true, workingDirectory } = params;
     
     if (!pattern) {
       throw new Error('Pattern is required for file search');
     }
     
+    // Security: Validate path to prevent traversal attacks
+    const baseCwd = workingDirectory || process.cwd();
+    const secureBaseDir = path.resolve(baseCwd);
+    const targetDir = path.resolve(secureBaseDir, directory);
+    if (!targetDir.startsWith(secureBaseDir + path.sep) && targetDir !== secureBaseDir) {
+      throw new Error('Path traversal attempt detected. Access denied.');
+    }
+    
     try {
       const options = {
-        cwd: directory,
+        cwd: targetDir,
         ignore: ['node_modules/**', '.git/**'],
         absolute: false
       };

package/build/agent/tools.js

@@ -141,12 +141,45 @@ export function parseXmlToolCallWithThinking(xmlString, validTools) {
   // Remove thinking tags and their content from the XML string
   let cleanedXmlString = xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, '').trim();
 
-  // Check for attempt_complete shorthand (single tag with no closing tag and no parameters)
-  const attemptCompleteMatch = cleanedXmlString.match(/^<attempt_complete>\s*$/);
-  if (attemptCompleteMatch) {
-    // Convert shorthand to full attempt_completion format with special marker
+  // Enhanced recovery logic for attempt_complete shorthand
+  // Check for various forms of attempt_complete tags:
+  // 1. Perfect shorthand: <attempt_complete>
+  // 2. Self-closing: <attempt_complete/>  
+  // 3. Empty with closing tag: <attempt_complete></attempt_complete>
+  // 4. Incomplete: <attempt_complete (missing closing bracket)
+  // 5. With trailing content that should be ignored
+  const attemptCompletePatterns = [
+    // Standard shorthand with optional whitespace
+    /^<attempt_complete>\s*$/,
+    // Empty with proper closing tag (common case from the logs)
+    /^<attempt_complete>\s*<\/attempt_complete>\s*$/,
+    // Self-closing variant
+    /^<attempt_complete\s*\/>\s*$/,
+    // Incomplete opening tag (missing closing bracket)
+    /^<attempt_complete\s*$/,
+    // With trailing content (extract just the tag part) - must come after empty tag pattern
+    /^<attempt_complete>(.*)$/s,
+    // Self-closing with trailing content
+    /^<attempt_complete\s*\/>(.*)$/s
+  ];
+
+  for (const pattern of attemptCompletePatterns) {
+    const match = cleanedXmlString.match(pattern);
+    if (match) {
+      // Convert any form of attempt_complete to the standard format
+      return {
+        toolName: 'attempt_completion',
+        params: { result: '__PREVIOUS_RESPONSE__' }
+      };
+    }
+  }
+
+  // Additional recovery: check if the string contains attempt_complete anywhere
+  // and treat the entire response as a completion signal if no other tool tags are found
+  if (cleanedXmlString.includes('<attempt_complete') && !hasOtherToolTags(cleanedXmlString, validTools)) {
+    // This handles malformed cases where attempt_complete appears but is broken
     return {
-      toolName: 'attempt_completion',
+      toolName: 'attempt_completion', 
       params: { result: '__PREVIOUS_RESPONSE__' }
     };
   }
@@ -160,4 +193,23 @@ export function parseXmlToolCallWithThinking(xmlString, validTools) {
   }
 
   return parsedTool;
+}
+
+/**
+ * Helper function to check if the XML string contains other tool tags
+ * @param {string} xmlString - The XML string to check
+ * @param {string[]} validTools - List of valid tool names
+ * @returns {boolean} - True if other tool tags are found
+ */
+function hasOtherToolTags(xmlString, validTools = []) {
+  const defaultTools = ['search', 'query', 'extract', 'listFiles', 'searchFiles', 'implement', 'attempt_completion'];
+  const toolsToCheck = validTools.length > 0 ? validTools : defaultTools;
+  
+  // Check for any tool tags other than attempt_complete variants
+  for (const tool of toolsToCheck) {
+    if (tool !== 'attempt_completion' && xmlString.includes(`<${tool}`)) {
+      return true;
+    }
+  }
+  return false;
 }

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;

package/build/mcp/index.ts

@@ -112,37 +112,19 @@ console.log(`Bin directory: ${binDir}`);
 interface SearchCodeArgs {
   path: string;
   query: string | string[];
-  filesOnly?: boolean;
-  ignore?: string[];
-  excludeFilenames?: boolean;
   exact?: boolean;
   maxResults?: number;
   maxTokens?: number;
   allowTests?: boolean;
   session?: string;
-  timeout?: number;
   noGitignore?: boolean;
 }
 
-interface QueryCodeArgs {
-  path: string;
-  pattern: string;
-  language?: string;
-  ignore?: string[];
-  allowTests?: boolean;
-  maxResults?: number;
-  format?: 'markdown' | 'plain' | 'json' | 'color';
-  timeout?: number;
-  noGitignore?: boolean;
-}
 
 interface ExtractCodeArgs {
   path: string;
   files: string[];
   allowTests?: boolean;
-  contextLines?: number;
-  format?: 'markdown' | 'plain' | 'json';
-  timeout?: number;
   noGitignore?: boolean;
 }
 
@@ -193,38 +175,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)',
@@ -233,50 +199,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.",
@@ -294,22 +216,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',
@@ -323,8 +231,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}`
@@ -356,9 +264,6 @@ class ProbeServer {
           }
           
           result = await this.executeCodeSearch(args);
-        } else if (request.params.name === 'query_code' || request.params.name === 'query') {
-          const args = request.params.arguments as unknown as QueryCodeArgs;
-          result = await this.executeCodeQuery(args);
         } else { // extract_code or extract
           const args = request.params.arguments as unknown as ExtractCodeArgs;
           result = await this.executeCodeExtract(args);
@@ -409,13 +314,15 @@ class ProbeServer {
       };
       
       // 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) options.allowTests = args.allowTests;
+      // 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;
@@ -427,12 +334,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') {
@@ -467,50 +368,6 @@ class ProbeServer {
     }
   }
 
-  private async executeCodeQuery(args: QueryCodeArgs): Promise<string> {
-    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: any = {
-        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: any) {
-      console.error('Error executing code query:', error);
-      throw new McpError(
-        'MethodNotFound' as unknown as ErrorCode,
-        `Error executing code query: ${error.message || String(error)}`
-      );
-    }
-  }
 
   private async executeCodeExtract(args: ExtractCodeArgs): Promise<string> {
     try {
@@ -526,12 +383,16 @@ class ProbeServer {
       const options: any = {
         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;

package/build/utils.js

@@ -43,7 +43,7 @@ export async function getBinaryPath(options = {}) {
 	
 	// Check bin directory
 	const isWindows = process.platform === 'win32';
-	const binaryName = isWindows ? 'probe.exe' : 'probe';
+	const binaryName = isWindows ? 'probe.exe' : 'probe-binary';
 	const binaryPath = path.join(binDir, binaryName);
 
 	if (fs.existsSync(binaryPath) && !forceDownload) {