@probelabs/probe 0.6.0-rc288 → 0.6.0-rc291

package/src/agent/ProbeAgent.js

@@ -1444,11 +1444,13 @@ export class ProbeAgent {
         result = await this._executeWithVercelProvider(options, controller);
       }
 
-      // Wrap textStream so limiter slot is held until stream completes
+      // Wrap textStream so limiter slot is held until stream completes.
+      // result.textStream is a read-only getter on DefaultStreamTextResult,
+      // so we wrap the result in a Proxy that intercepts the textStream property.
       if (limiter && result.textStream) {
         const originalStream = result.textStream;
         const debug = this.debug;
-        result.textStream = (async function* () {
+        const wrappedStream = (async function* () {
           try {
             for await (const chunk of originalStream) {
               yield chunk;
@@ -1461,6 +1463,13 @@ export class ProbeAgent {
             }
           }
         })();
+        return new Proxy(result, {
+          get(target, prop) {
+            if (prop === 'textStream') return wrappedStream;
+            const value = target[prop];
+            return typeof value === 'function' ? value.bind(target) : value;
+          }
+        });
       } else if (limiter) {
         // No textStream (shouldn't happen, but release just in case)
         limiter.release(null);
@@ -2976,9 +2985,9 @@ ${extractGuidance2}
 Follow these instructions carefully:
 1. Analyze the user's request.
 2. Use the available tools step-by-step to fulfill the request.
-3. You should always prefer the search tool for code-related questions.${this.searchDelegate ? ' Ask natural language questions — the search subagent handles keyword formulation and returns extracted code blocks. Use extract only to expand context or read full files.' : ' Search handles stemming and case variations automatically — do NOT try keyword variations manually. Read full files only if really necessary.'}
-4. Ensure to get really deep and understand the full picture before answering.
-5. Once the task is fully completed, provide your final answer directly as text.
+3. You MUST use the search tool before answering ANY code-related question. NEVER answer from memory or general knowledge — your answers must be grounded in actual code found via search/extract.${this.searchDelegate ? ' Ask natural language questions — the search subagent handles keyword formulation and returns extracted code blocks. Use extract only to expand context or read full files.' : ' Search handles stemming and case variations automatically — do NOT try keyword variations manually. Read full files only if really necessary.'}
+4. Ensure to get really deep and understand the full picture before answering. Follow call chains — if function A calls B, search for B too. Look for related subsystems (e.g., if asked about rate limiting, also check for quota, throttling, smoothing).
+5. Once the task is fully completed, provide your final answer directly as text. Always cite specific files and line numbers as evidence. Do NOT output planning or thinking text — go straight to the answer.
 6. ${this.searchDelegate ? 'Ask clear, specific questions when searching. Each search should target a distinct concept or question.' : 'Prefer concise and focused search queries. Use specific keywords and phrases to narrow down results.'}
 7. NEVER use bash for code exploration (no grep, cat, find, head, tail, awk, sed) — always use search and extract tools instead. Bash is only for system operations like building, running tests, or git commands.${this.allowEdit ? `
 7. When modifying files, choose the appropriate tool:
@@ -3483,6 +3492,25 @@ Follow these instructions carefully:
                 if (recentTexts.every(t => detectStuckResponse(t))) return true;
               }
 
+              // Circuit breaker: repeated identical tool calls (e.g. model ignores dedup message)
+              if (steps.length >= 3) {
+                const last3 = steps.slice(-3);
+                const allHaveTools = last3.every(s => s.toolCalls?.length === 1);
+                if (allHaveTools) {
+                  const signatures = last3.map(s => {
+                    const tc = s.toolCalls[0];
+                    return `${tc.toolName}::${JSON.stringify(tc.args ?? tc.input)}`;
+                  });
+                  if (signatures[0] === signatures[1] && signatures[1] === signatures[2]) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] Circuit breaker: 3 consecutive identical tool calls detected (${last3[0].toolCalls[0].toolName}), forcing stop`);
+                    }
+                    return true;
+                  }
+                }
+
+              }
+
               return false;
             },
             prepareStep: ({ steps, stepNumber }) => {
@@ -3493,6 +3521,42 @@ Follow these instructions carefully:
                 };
               }
 
+              // Force text-only response after 2 consecutive identical tool calls
+              if (steps.length >= 2) {
+                const last2 = steps.slice(-2);
+                if (last2.every(s => s.toolCalls?.length === 1)) {
+                  const tc1 = last2[0].toolCalls[0];
+                  const tc2 = last2[1].toolCalls[0];
+                  const sig1 = `${tc1.toolName}::${JSON.stringify(tc1.args ?? tc1.input)}`;
+                  const sig2 = `${tc2.toolName}::${JSON.stringify(tc2.args ?? tc2.input)}`;
+                  if (sig1 === sig2) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] prepareStep: 2 consecutive identical tool calls (${tc1.toolName}), forcing toolChoice=none`);
+                      console.log(`[DEBUG]   sig: ${sig1.substring(0, 200)}`);
+                    }
+                    return { toolChoice: 'none' };
+                  }
+                }
+              }
+
+              // Force text-only response after 3 consecutive tool errors
+              // (e.g. workspace deleted mid-run — let the model produce its answer)
+              if (steps.length >= 3) {
+                const last3 = steps.slice(-3);
+                const allErrors = last3.every(s =>
+                  s.toolResults?.length > 0 && s.toolResults.every(tr => {
+                    const r = typeof tr.result === 'string' ? tr.result : '';
+                    return r.includes('<error ') || r.includes('does not exist');
+                  })
+                );
+                if (allErrors) {
+                  if (this.debug) {
+                    console.log(`[DEBUG] prepareStep: 3 consecutive tool errors, forcing toolChoice=none`);
+                  }
+                  return { toolChoice: 'none' };
+                }
+              }
+
               const lastStep = steps[steps.length - 1];
               const modelJustStopped = lastStep?.finishReason === 'stop'
                 && (!lastStep?.toolCalls || lastStep.toolCalls.length === 0);
@@ -3529,10 +3593,12 @@ Here is the result to review:
 ${resultToReview}
 </result>
 
-Double-check your response based on the criteria above. If everything looks good, respond with your previous answer exactly as-is. If something needs to be fixed or is missing, do it now, then respond with the COMPLETE updated answer (everything you did in total, not just the fix).`;
+IMPORTANT: First review ALL completed work in the conversation above before taking any action.
+Double-check your response based on the criteria above. If everything looks good, respond with your previous answer exactly as-is. If your text has inaccuracies, fix the text. Only call a tool if you find a genuinely MISSING action — NEVER redo work that was already completed successfully. Respond with the COMPLETE corrected answer.`;
 
                   return {
-                    userMessage: completionPromptMessage
+                    userMessage: completionPromptMessage,
+                    toolChoice: 'none' // Force text-only review — no tool calls
                   };
                 }
               }
@@ -3585,7 +3651,13 @@ Double-check your response based on the criteria above. If everything looks good
               }
 
               if (this.debug) {
-                console.log(`[DEBUG] Step ${currentIteration}/${maxIterations} finished (reason: ${finishReason}, tools: ${toolResults?.length || 0})`);
+                const toolSummary = toolCalls?.length
+                  ? toolCalls.map(tc => {
+                      const args = tc.args ? JSON.stringify(tc.args) : '';
+                      return args ? `${tc.toolName}(${debugTruncate(args, 120)})` : tc.toolName;
+                    }).join(', ')
+                  : 'none';
+                console.log(`[DEBUG] Step ${currentIteration}/${maxIterations} finished (reason: ${finishReason}, tools: [${toolSummary}])`);
                 if (text) {
                   console.log(`[DEBUG]   model text: ${debugTruncate(text)}`);
                 }
@@ -3627,11 +3699,20 @@ Double-check your response based on the criteria above. If everything looks good
           const executeAIRequest = async () => {
             const result = await this.streamTextWithRetryAndFallback(streamOptions);
 
-            // Collect the final text
-            const finalText = await result.text;
+            // Use only the last step's text as the final answer.
+            // result.text concatenates ALL steps (including intermediate planning text),
+            // but the user should only see the final answer from the last step.
+            const steps = await result.steps;
+            let finalText;
+            if (steps && steps.length > 1) {
+              // Multi-step: use last step's text (the actual answer after tool calls)
+              const lastStepText = steps[steps.length - 1].text;
+              finalText = lastStepText || await result.text;
+            } else {
+              finalText = await result.text;
+            }
 
             if (this.debug) {
-              const steps = await result.steps;
               console.log(`[DEBUG] streamText completed: ${steps?.length || 0} steps, finalText=${finalText?.length || 0} chars`);
             }
 
@@ -3722,16 +3803,16 @@ Here is the result to review:
 ${finalResult}
 </result>
 
-Double-check your response based on the criteria above. If everything looks good, respond with your previous answer exactly as-is. If something needs to be fixed or is missing, do it now, then respond with the COMPLETE updated answer (everything you did in total, not just the fix).`;
+IMPORTANT: First review ALL completed work in the conversation above before taking any action.
+Double-check your response based on the criteria above. If everything looks good, respond with your previous answer exactly as-is. If your text has inaccuracies, fix the text. Only call a tool if you find a genuinely MISSING action — NEVER redo work that was already completed successfully. Respond with the COMPLETE corrected answer.`;
 
             currentMessages.push({ role: 'user', content: completionPromptMessage });
 
-            const completionMaxIterations = 5;
             const completionStreamOptions = {
               model: this.provider ? this.provider(this.model) : this.model,
               messages: this.prepareMessagesWithImages(currentMessages),
               tools,
-              stopWhen: stepCountIs(completionMaxIterations),
+              toolChoice: 'none', // Force text-only response — no tool calls during review
               maxTokens: maxResponseTokens,
               temperature: 0.3,
               onStepFinish: ({ toolResults, text, finishReason, usage }) => {

package/src/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/src/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/src/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/src/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;
 	}
-}
+}