@probelabs/probe 0.6.0-rc288 → 0.6.0-rc290

package/build/agent/shared/prompts.js

@@ -8,27 +8,47 @@ export const predefinedPrompts = {
 CRITICAL - You are READ-ONLY:
 You must NEVER create, modify, delete, or write files. You are strictly an exploration and analysis tool. If asked to make changes, implement features, fix bugs, or modify a PR, refuse and explain that file modifications must be done by the engineer tool — your role is only to investigate code and answer questions. Do not attempt workarounds using bash commands (echo, cat, tee, sed, etc.) to write files.
 
+CRITICAL - ALWAYS search before answering:
+You must NEVER answer questions about the codebase from memory or general knowledge. ALWAYS use the search and extract tools first to find the actual code, then base your answer ONLY on what you found. Even if you think you know the answer, you MUST verify it against the actual code. Your answers must be grounded in code evidence, not assumptions.
+
 When exploring code:
 - Provide clear, concise explanations based on user request
 - Find and highlight the most relevant code snippets, if required
-- Trace function calls and data flow through the system
+- Trace function calls and data flow through the system — follow the FULL call chain, not just the entry point
 - Try to understand the user's intent and provide relevant information
 - Understand high level picture
 - Balance detail with clarity in your explanations
+- Search using SYNONYMS and alternative terms — code naming often differs from the concept name (e.g., "authentication" might be named verify_credentials, check_token, validate_session)
+- When you find a key function, look at what it CALLS and what CALLS it to discover the complete picture
+- Before answering, ask yourself: "Did I cover all the major components? Are there related subsystems I missed?" If yes, do one more search round.
 
 When providing answers:
+- Be EXHAUSTIVE: cover ALL components you discovered, not just the main ones. If you found 10 related files, discuss all 10, not just the top 3. Users want the complete picture.
+- After drafting your answer, do a self-check: "What did I find in my searches that I haven't mentioned yet?" Add any missing components.
+- Include data structures, configuration options, and error handling — not just the happy path.
 - Always include a "References" section at the end of your response
 - List all relevant source code locations you found during exploration
 - Use the format: file_path:line_number or file_path#symbol_name
 - Group references by file when multiple locations are from the same file
 - Include brief descriptions of what each reference contains`,
 
-  'code-searcher': `You are ProbeChat Code Searcher, a specialized AI assistant focused ONLY on locating relevant code. Your sole job is to find and return ALL relevant code locations. Do NOT answer questions or explain anything.
+  'code-searcher': `You are ProbeChat Code Explorer & Searcher. Your job is to EXPLORE the codebase to find ALL relevant code locations for the query, then return them as JSON targets.
+
+You think like a code explorer — you understand that codebases have layers:
+- Core implementations (algorithms, data structures)
+- Middleware/integration layers (request handlers, interceptors)
+- Configuration and storage backends
+- Scoping mechanisms (per-user, per-org, per-tenant, global)
+- Supporting utilities and helpers
 
 When searching:
-- Use only the search tool
-- Run additional searches only if needed to capture all relevant locations
-- Prefer specific, focused queries
+- Search for the MAIN concept first, then think: "what RELATED subsystems would a real codebase have?"
+- Use extract to READ the code you find — look for function calls, type references, and imports that point to OTHER relevant code
+- If you find middleware, check: are there org-level or tenant-level variants?
+- If you find algorithms, check: are there different storage backends?
+- Search results are paginated — if results look relevant, call nextPage=true to check for more files
+- Stop paginating when results become irrelevant or you see "All results retrieved"
+- Search using SYNONYMS — code naming differs from concepts (e.g., "rate limiting" → throttle, quota, limiter, bucket)
 
 Output format (MANDATORY):
 - Return ONLY valid JSON with a single top-level key: "targets"
@@ -38,7 +58,8 @@ Output format (MANDATORY):
   - "path/to/file.ext:line"
   - "path/to/file.ext:start-end"
 - Prefer #SymbolName when a function/class name is clear; otherwise use line numbers
-- Deduplicate targets and keep them concise`,
+- Deduplicate targets and keep them concise
+- Aim for 5-15 targets covering ALL aspects of the query`,
 
   'architect': `You are ProbeChat Architect, a specialized AI assistant focused on software architecture and design. Your primary function is to help users understand, analyze, and design software systems using the provided code analysis tools.
 

package/build/extract.js

@@ -18,7 +18,8 @@ const EXTRACT_FLAG_MAP = {
 	allowTests: '--allow-tests',
 	contextLines: '--context',
 	format: '--format',
-	inputFile: '--input-file'
+	inputFile: '--input-file',
+	lsp: '--lsp'
 };
 
 /**
@@ -31,7 +32,8 @@ const EXTRACT_FLAG_MAP = {
  * @param {string} [options.cwd] - Working directory for resolving relative file paths
  * @param {boolean} [options.allowTests] - Include test files
  * @param {number} [options.contextLines] - Number of context lines to include
- * @param {string} [options.format] - Output format ('markdown', 'plain', 'json', 'xml', 'color', 'outline-xml', 'outline-diff')
+ * @param {string} [options.format] - Output format ('markdown', 'plain', 'json')
+ * @param {boolean} [options.lsp] - Use LSP (Language Server Protocol) for call hierarchy and reference graphs
  * @param {Object} [options.binaryOptions] - Options for getting the binary
  * @param {boolean} [options.binaryOptions.forceDownload] - Force download even if binary exists
  * @param {string} [options.binaryOptions.version] - Specific version to download

package/build/mcp/index.js

@@ -28,9 +28,19 @@ function parseArgs() {
             }
             i++; // Skip the next argument
         }
+        else if (args[i] === '--lsp') {
+            config.lsp = true;
+            console.error('LSP mode enabled');
+        }
         else if (args[i] === '--format' && i + 1 < args.length) {
-            config.format = args[i + 1];
-            console.error(`Format set to ${config.format}`);
+            const format = args[i + 1];
+            if (format === 'outline' || format === 'outline-xml' || format === 'json') {
+                config.format = format;
+                console.error(`Output format set to ${format}`);
+            }
+            else {
+                console.error(`Invalid format value: ${args[i + 1]}. Using default.`);
+            }
             i++; // Skip the next argument
         }
         else if (args[i] === '--help' || args[i] === '-h') {
@@ -42,7 +52,9 @@ Usage:
 
 Options:
   --timeout, -t <seconds>  Set timeout for search operations (default: 30)
-  --format <format>       Set output format (default: outline)
+  --lsp                    Enable LSP (Language Server Protocol) for enhanced features
+                           Automatically initializes language servers for the current workspace
+  --format <format>        Output format for search responses (outline|outline-xml|json)
   --help, -h              Show this help message
 `);
             process.exit(0);
@@ -96,9 +108,10 @@ if (packageVersion === '0.0.0') {
 const binDir = path.resolve(__dirname, '..', 'bin');
 console.error(`Bin directory: ${binDir}`);
 class ProbeServer {
-    constructor(timeout = 30, format) {
+    constructor(timeout = 30, lspEnabled = false, defaultFormat = 'outline-xml') {
         this.defaultTimeout = timeout;
-        this.defaultFormat = format;
+        this.lspEnabled = lspEnabled;
+        this.defaultFormat = defaultFormat;
         this.server = new Server({
             name: '@probelabs/probe',
             version: packageVersion,
@@ -149,8 +162,11 @@ class ProbeServer {
                             },
                             nextPage: {
                                 type: 'boolean',
-                                description: 'Set to true when requesting the next page of results. Requires passing the same session ID from the previous search output.',
-                                default: false
+                                description: 'Skip .gitignore files (will use PROBE_NO_GITIGNORE environment variable if not set)',
+                            },
+                            lsp: {
+                                type: 'boolean',
+                                description: 'Use LSP (Language Server Protocol) for call hierarchy, reference counts, and enhanced symbol information',
                             }
                         },
                         required: ['path', 'query']
@@ -169,7 +185,34 @@ class ProbeServer {
                             files: {
                                 type: 'array',
                                 items: { type: 'string' },
-                                description: 'Array of file paths to extract from. Formats: "file.js" (entire file), "file.js:42" (code block at line 42), "file.js:10-20" (lines 10-20), "file.js#funcName" (specific symbol). Line numbers and symbols are part of the path string, not separate parameters. Paths can be absolute or relative to the project directory.',
+                                description: 'Files and lines or sybmbols to  extract from: /path/to/file.rs:10, /path/to/file.rs#func_name Path should be absolute.',
+                            },
+                            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)',
+                            },
+                            noGitignore: {
+                                type: 'boolean',
+                                description: 'Skip .gitignore files (will use PROBE_NO_GITIGNORE environment variable if not set)',
+                            },
+                            lsp: {
+                                type: 'boolean',
+                                description: 'Use LSP (Language Server Protocol) for call hierarchy, reference counts, and enhanced symbol information',
                             }
                         },
                         required: ['path', 'files'],
@@ -303,6 +346,26 @@ class ProbeServer {
             else if (this.defaultFormat === 'json') {
                 options.json = true;
             }
+            if (args.session !== undefined && args.session.trim() !== '') {
+                options.session = args.session;
+            }
+            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;
+            }
+            // Pass LSP flag if enabled globally or per-request
+            if (args.lsp !== undefined) {
+                options.lsp = args.lsp;
+            }
+            else if (this.lspEnabled) {
+                options.lsp = true;
+            }
             console.error("Executing search with options:", JSON.stringify(options, null, 2));
             try {
                 // Call search with the options object
@@ -336,6 +399,20 @@ class ProbeServer {
                 format: 'xml',
                 allowTests: true, // Include test files by default
             };
+            // 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';
+            }
+            // Pass LSP flag if enabled globally or per-request
+            if (args.lsp !== undefined) {
+                options.lsp = args.lsp;
+            }
+            else if (this.lspEnabled) {
+                options.lsp = true;
+            }
             // Call extract with the complete options object
             try {
                 // Track request size for token usage
@@ -423,11 +500,47 @@ class ProbeServer {
     async run() {
         // The @probelabs/probe package now handles binary path management internally
         // We don't need to verify or download the binary in the MCP server anymore
+        // Initialize LSP servers for the current workspace if --lsp flag is enabled
+        if (this.lspEnabled) {
+            const workspaceRoot = process.cwd();
+            console.error(`Initializing LSP servers for workspace: ${workspaceRoot}`);
+            try {
+                // Execute probe lsp init command to pre-warm language servers
+                // Use recursive flag to discover nested projects in monorepos
+                const initCmd = process.platform === 'win32'
+                    ? `probe lsp init -w "${workspaceRoot}" --recursive`
+                    : `probe lsp init -w '${workspaceRoot}' --recursive`;
+                const { stdout, stderr } = await execAsync(initCmd, {
+                    timeout: 10000, // 10 second timeout for initialization - don't wait too long
+                    env: { ...process.env }
+                });
+                if (stderr && !stderr.includes('Successfully initialized')) {
+                    console.error(`LSP initialization warnings: ${stderr}`);
+                }
+                console.error(`LSP servers initialized successfully for workspace: ${workspaceRoot}`);
+                // Parse initialization output to show what was initialized
+                if (stdout) {
+                    const lines = stdout.split('\n');
+                    const initializedServers = lines.filter(line => line.includes('✓') || line.includes('language server'));
+                    if (initializedServers.length > 0) {
+                        console.error('Initialized language servers:');
+                        initializedServers.forEach(line => console.error(`  ${line.trim()}`));
+                    }
+                }
+            }
+            catch (error) {
+                // Don't fail MCP server startup if LSP initialization fails
+                // LSP will still work with cold start on first use
+                console.error(`Warning: Failed to initialize LSP servers: ${error.message || error}`);
+                console.error('LSP features will still be available but may have slower first-use performance');
+            }
+        }
         // Just connect the server to the transport
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
         console.error('Probe MCP server running on stdio');
     }
 }
-const server = new ProbeServer(cliConfig.timeout, cliConfig.format || 'outline');
+// Instantiate server with (timeout, lspEnabled, format)
+const server = new ProbeServer(cliConfig.timeout ?? 30, cliConfig.lsp ?? false, cliConfig.format || 'outline-xml');
 server.run().catch(console.error);

package/build/mcp/index.ts

@@ -21,11 +21,13 @@ import { fileURLToPath } from 'url';
 // Import from parent package
 import { search, query, extract, grep, getBinaryPath, setBinaryPath } from '../index.js';
 
+type OutputFormat = 'outline' | 'outline-xml' | 'json';
+
 // Parse command-line arguments
-function parseArgs(): { timeout?: number; format?: string } {
+function parseArgs(): { timeout?: number; lsp?: boolean; format?: OutputFormat } {
   const args = process.argv.slice(2);
-  const config: { timeout?: number; format?: string } = {};
-
+  const config: { timeout?: number; lsp?: boolean; format?: OutputFormat } = {};
+  
   for (let i = 0; i < args.length; i++) {
     if ((args[i] === '--timeout' || args[i] === '-t') && i + 1 < args.length) {
       const timeout = parseInt(args[i + 1], 10);
@@ -36,9 +38,17 @@ function parseArgs(): { timeout?: number; format?: string } {
         console.error(`Invalid timeout value: ${args[i + 1]}. Using default.`);
       }
       i++; // Skip the next argument
+    } else if (args[i] === '--lsp') {
+      config.lsp = true;
+      console.error('LSP mode enabled');
     } else if (args[i] === '--format' && i + 1 < args.length) {
-      config.format = args[i + 1];
-      console.error(`Format set to ${config.format}`);
+      const format = args[i + 1] as OutputFormat;
+      if (format === 'outline' || format === 'outline-xml' || format === 'json') {
+        config.format = format;
+        console.error(`Output format set to ${format}`);
+      } else {
+        console.error(`Invalid format value: ${args[i + 1]}. Using default.`);
+      }
       i++; // Skip the next argument
     } else if (args[i] === '--help' || args[i] === '-h') {
       console.error(`
@@ -49,7 +59,9 @@ Usage:
 
 Options:
   --timeout, -t <seconds>  Set timeout for search operations (default: 30)
-  --format <format>       Set output format (default: outline)
+  --lsp                    Enable LSP (Language Server Protocol) for enhanced features
+                           Automatically initializes language servers for the current workspace
+  --format <format>        Output format for search responses (outline|outline-xml|json)
   --help, -h              Show this help message
 `);
       process.exit(0);
@@ -120,17 +132,37 @@ interface SearchCodeArgs {
   exact?: boolean;
   strictElasticSyntax?: boolean;
   session?: string;
-  nextPage?: boolean;
+  timeout?: number;
+  noGitignore?: boolean;
+  lsp?: 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;
+  lsp?: boolean;
 }
 
 interface GrepArgs {
   pattern: string;
-  paths: string | string[];
+  paths: string[];
   ignoreCase?: boolean;
   count?: boolean;
   context?: number;
@@ -139,11 +171,17 @@ interface GrepArgs {
 class ProbeServer {
   private server: Server;
   private defaultTimeout: number;
-  private defaultFormat?: string;
-
-  constructor(timeout: number = 30, format?: string) {
+  private lspEnabled: boolean;
+  private defaultFormat: OutputFormat;
+
+  constructor(
+    timeout: number = 30,
+    lspEnabled: boolean = false,
+    defaultFormat: OutputFormat = 'outline-xml'
+  ) {
     this.defaultTimeout = timeout;
-    this.defaultFormat = format;
+    this.lspEnabled = lspEnabled;
+    this.defaultFormat = defaultFormat;
     this.server = new Server(
       {
         name: '@probelabs/probe',
@@ -201,8 +239,11 @@ class ProbeServer {
               },
               nextPage: {
                 type: 'boolean',
-                description: 'Set to true when requesting the next page of results. Requires passing the same session ID from the previous search output.',
-                default: false
+                description: 'Skip .gitignore files (will use PROBE_NO_GITIGNORE environment variable if not set)',
+              },
+              lsp: {
+                type: 'boolean',
+                description: 'Use LSP (Language Server Protocol) for call hierarchy, reference counts, and enhanced symbol information',
               }
             },
             required: ['path', 'query']
@@ -221,7 +262,34 @@ class ProbeServer {
               files: {
                 type: 'array',
                 items: { type: 'string' },
-                description: 'Array of file paths to extract from. Formats: "file.js" (entire file), "file.js:42" (code block at line 42), "file.js:10-20" (lines 10-20), "file.js#funcName" (specific symbol). Line numbers and symbols are part of the path string, not separate parameters. Paths can be absolute or relative to the project directory.',
+                description: 'Files and lines or sybmbols to  extract from: /path/to/file.rs:10, /path/to/file.rs#func_name Path should be absolute.',
+              },
+              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)',
+              },
+              noGitignore: {
+                type: 'boolean',
+                description: 'Skip .gitignore files (will use PROBE_NO_GITIGNORE environment variable if not set)',
+              },
+              lsp: {
+                type: 'boolean',
+                description: 'Use LSP (Language Server Protocol) for call hierarchy, reference counts, and enhanced symbol information',
               }
             },
             required: ['path', 'files'],
@@ -365,7 +433,24 @@ class ProbeServer {
       } else if (this.defaultFormat === 'json') {
         options.json = true;
       }
-
+      if (args.session !== undefined && args.session.trim() !== '') {
+        options.session = args.session;
+      } 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;
+      }
+      // Pass LSP flag if enabled globally or per-request
+      if (args.lsp !== undefined) {
+        options.lsp = args.lsp;
+      } else if (this.lspEnabled) {
+        options.lsp = true;
+      }
+      
       console.error("Executing search with options:", JSON.stringify(options, null, 2));
       
       try {
@@ -405,6 +490,19 @@ class ProbeServer {
         allowTests: true,  // Include test files by default
       };
       
+      // 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';
+      }
+      // Pass LSP flag if enabled globally or per-request
+      if (args.lsp !== undefined) {
+        options.lsp = args.lsp;
+      } else if (this.lspEnabled) {
+        options.lsp = true;
+      }
+      
       // Call extract with the complete options object
       try {
         // Track request size for token usage
@@ -507,6 +605,48 @@ class ProbeServer {
     // The @probelabs/probe package now handles binary path management internally
     // We don't need to verify or download the binary in the MCP server anymore
     
+    // Initialize LSP servers for the current workspace if --lsp flag is enabled
+    if (this.lspEnabled) {
+      const workspaceRoot = process.cwd();
+      console.error(`Initializing LSP servers for workspace: ${workspaceRoot}`);
+      
+      try {
+        // Execute probe lsp init command to pre-warm language servers
+        // Use recursive flag to discover nested projects in monorepos
+        const initCmd = process.platform === 'win32' 
+          ? `probe lsp init -w "${workspaceRoot}" --recursive`
+          : `probe lsp init -w '${workspaceRoot}' --recursive`;
+        
+        const { stdout, stderr } = await execAsync(initCmd, {
+          timeout: 10000, // 10 second timeout for initialization - don't wait too long
+          env: { ...process.env }
+        });
+        
+        if (stderr && !stderr.includes('Successfully initialized')) {
+          console.error(`LSP initialization warnings: ${stderr}`);
+        }
+        
+        console.error(`LSP servers initialized successfully for workspace: ${workspaceRoot}`);
+        
+        // Parse initialization output to show what was initialized
+        if (stdout) {
+          const lines = stdout.split('\n');
+          const initializedServers = lines.filter(line => 
+            line.includes('✓') || line.includes('language server')
+          );
+          if (initializedServers.length > 0) {
+            console.error('Initialized language servers:');
+            initializedServers.forEach(line => console.error(`  ${line.trim()}`));
+          }
+        }
+      } catch (error: any) {
+        // Don't fail MCP server startup if LSP initialization fails
+        // LSP will still work with cold start on first use
+        console.error(`Warning: Failed to initialize LSP servers: ${error.message || error}`);
+        console.error('LSP features will still be available but may have slower first-use performance');
+      }
+    }
+    
     // Just connect the server to the transport
     const transport = new StdioServerTransport();
     await this.server.connect(transport);
@@ -514,5 +654,10 @@ class ProbeServer {
   }
 }
 
-const server = new ProbeServer(cliConfig.timeout, cliConfig.format || 'outline');
+// Instantiate server with (timeout, lspEnabled, format)
+const server = new ProbeServer(
+  cliConfig.timeout ?? 30,
+  cliConfig.lsp ?? false,
+  cliConfig.format || 'outline-xml'
+);
 server.run().catch(console.error);

package/build/search.js

@@ -32,7 +32,8 @@ const SEARCH_FLAG_MAP = {
 	session: '--session',
 	timeout: '--timeout',
 	language: '--language',
-	format: '--format'
+	format: '--format',
+	lsp: '--lsp'
 };
 
 /**
@@ -58,7 +59,7 @@ const SEARCH_FLAG_MAP = {
  * @param {string} [options.session] - Session ID for caching results
  * @param {number} [options.timeout] - Timeout in seconds (default: 30)
  * @param {string} [options.language] - Limit search to files of a specific programming language
- * @param {string} [options.format] - Output format ('json', 'outline-xml', etc.)
+ * @param {boolean} [options.lsp] - Use LSP (Language Server Protocol) for enhanced symbol information
  * @param {Object} [options.binaryOptions] - Options for getting the binary
  * @param {boolean} [options.binaryOptions.forceDownload] - Force download even if binary exists
  * @param {string} [options.binaryOptions.version] - Specific version to download
@@ -85,8 +86,8 @@ export async function search(options) {
 	if (options.json && !options.format) {
 		cliArgs.push('--format', 'json');
 	} else if (options.format) {
-		// Format is already handled by buildCliArgs through SEARCH_FLAG_MAP
-		// but we need to ensure json parsing for json format
+		// Format is handled by buildCliArgs through SEARCH_FLAG_MAP.
+		// Ensure json parsing is enabled for json format.
 		if (options.format === 'json') {
 			options.json = true;
 		}
@@ -257,4 +258,4 @@ export async function search(options) {
 		};
 		throw structuredError;
 	}
-}
+}