Enable VSCode LSP APIs: 100-1000x Performance Improvement for Code Navigation

Feature Request: VSCode API Integration for Claude Code Extension

Summary

The Claude Code extension should expose VSCode's built-in search and code navigation APIs to dramatically improve efficiency when working with codebases. Currently, Claude relies on text-based grep/glob searches which miss the semantic understanding that VSCode already has through its Language Server Protocol (LSP) integration.

Current Limitation

Claude currently uses:

• Grep tool for text-based pattern matching
• Glob tool for file pattern matching
• Manual file reading to understand code structure

This approach is inefficient because:

1. It requires multiple searches to find related code
2. It misses semantic relationships (imports, exports, type definitions)
3. It can't distinguish between strings, comments, and actual code
4. It requires reading entire files to understand context

Proposed VSCode APIs to Expose

1. Symbol and Navigation APIs

Go to Definition

vscode.commands.executeCommand('vscode.executeDefinitionProvider', uri, position)

• Use Case: When user asks "where is X defined?", instantly jump to definition
• Benefit: No need to grep through files looking for function/class definitions

Find All References

vscode.commands.executeCommand('vscode.executeReferenceProvider', uri, position)

• Use Case: Find all usages of a function, variable, or type
• Benefit: Instantly see impact of changes, understand code relationships

Workspace Symbol Search

vscode.commands.executeCommand('vscode.executeWorkspaceSymbolProvider', query)

• Use Case: Find any class, function, interface, or constant by name
• Benefit: Direct navigation to symbols without text searching

Document Symbols

vscode.commands.executeCommand('vscode.executeDocumentSymbolProvider', uri)

• Use Case: Get outline of a file (classes, methods, properties)
• Benefit: Understand file structure without parsing

2. Type and Implementation APIs

Go to Type Definition

vscode.commands.executeCommand('vscode.executeTypeDefinitionProvider', uri, position)

• Use Case: Navigate to type definitions for understanding data structures
• Benefit: Quickly understand TypeScript types and interfaces

Find Implementations

vscode.commands.executeCommand('vscode.executeImplementationProvider', uri, position)

• Use Case: Find all implementations of an interface or abstract class
• Benefit: Understand inheritance and polymorphism in the codebase

3. Search and File APIs

Find Files with Smart Filtering

vscode.workspace.findFiles(include: GlobPattern, exclude?: GlobPattern)

• Use Case: Find files by pattern with .gitignore respect
• Benefit: More efficient than current Glob tool

Text Search with Context

vscode.workspace.findTextInFiles(query: TextSearchQuery, options: FindTextInFilesOptions)

• Use Case: Search with file type filtering, regex, and context lines
• Benefit: Richer search than current grep with VSCode's optimizations

4. Code Intelligence APIs

Hover Information

vscode.commands.executeCommand('vscode.executeHoverProvider', uri, position)

• Use Case: Get type information, documentation, and signatures
• Benefit: Understand code without reading entire files

Call Hierarchy

vscode.commands.executeCommand('vscode.prepareCallHierarchy', uri, position)
vscode.commands.executeCommand('vscode.provideIncomingCalls', item)
vscode.commands.executeCommand('vscode.provideOutgoingCalls', item)

• Use Case: Understand what calls a function and what it calls
• Benefit: Trace execution flow without manual searching

Rename Symbol

vscode.commands.executeCommand('vscode.executeDocumentRenameProvider', uri, position, newName)

• Use Case: Safely rename variables, functions, classes across entire codebase
• Benefit: Automated refactoring with LSP understanding

5. Diagnostic and Problem APIs

Get Problems/Diagnostics

vscode.languages.getDiagnostics(uri?)

• Use Case: Get TypeScript errors, linting issues for files
• Benefit: Proactively fix issues without running separate commands
• Note: This appears to already be partially implemented as mcp__ide__getDiagnostics

6. Code Action APIs

Get Available Code Actions

vscode.commands.executeCommand('vscode.executeCodeActionProvider', uri, range, kind?)

• Use Case: Get available quick fixes, refactorings
• Benefit: Suggest and apply automated fixes

Example Usage Scenarios

Scenario 1: Understanding a Function

Current approach (inefficient):

1. Grep for function name
2. Read multiple files
3. Grep for usages
4. Try to understand relationships

With VSCode APIs (efficient):

1. Find symbol → Go to definition
2. Find all references
3. Get call hierarchy
4. View hover information for types

Scenario 2: Refactoring

Current approach (error-prone):

1. Grep for all occurrences
2. Manually edit each file
3. Hope nothing was missed

With VSCode APIs (safe):

1. Use rename symbol API
2. VSCode handles all references including imports
3. Guaranteed consistency

Scenario 3: Finding Related Code

Current approach (incomplete):

1. Search for class name
2. Try to find implementations
3. Search for imports

With VSCode APIs (complete):

1. Find implementations
2. Find references
3. Navigate through type hierarchy

Implementation Suggestion

The MCP server for Claude Code could expose these as tools similar to the existing:

• mcp__ide__getDiagnostics
• mcp__ide__executeCode

New tools could include:

• mcp__ide__findSymbol
• mcp__ide__findReferences
• mcp__ide__goToDefinition
• mcp__ide__findImplementations
• mcp__ide__getCallHierarchy
• mcp__ide__renameSymbol
• mcp__ide__getDocumentSymbols
• mcp__ide__searchWorkspace

Benefits Summary

1. 100-1000x faster code navigation - Instant symbol lookup vs text searching

• Current: Multiple grep searches taking 10-30 seconds each
• With APIs: Instant results in milliseconds

1. Semantic understanding - Distinguish code from comments/strings

• Current: Can't tell if "Task" is a type, variable, or comment
• With APIs: Knows exactly what each symbol represents

1. Type awareness - Understand TypeScript relationships

• Current: No understanding of type relationships
• With APIs: Full type graph navigation

1. Safer refactoring - LSP-powered renames and changes

• Current: Error-prone manual search and replace
• With APIs: Guaranteed consistency across entire codebase

1. Reduced token usage - Less file reading, more precise results

• Current: Read hundreds of files to understand structure
• With APIs: Precise queries return only relevant information

1. Better user experience - Faster responses, more accurate changes

• Current: Users wait while Claude searches repeatedly
• With APIs: Near-instant responses, like using VSCode directly

Priority Recommendations

High Priority (Most impactful):

1. Find symbol in workspace
2. Find all references
3. Go to definition
4. Get document symbols (file outline)

Medium Priority (Very useful):

1. Find implementations
2. Rename symbol
3. Call hierarchy
4. Smart file search

Lower Priority (Nice to have):

1. Hover information
2. Code actions
3. Type hierarchy

Performance Impact: Orders of Magnitude Difference

Consider a real example from my own codebase:

• Task: "Find all places where the Task type is used"
• Current approach: 5-10 grep searches, reading 20+ files, ~45 seconds total
• With VSCode APIs: Single "Find All References" call, ~50ms
• Performance gain: 900x faster

This isn't an edge case - this is EVERY code navigation task. The difference between grep and LSP is like the difference between searching a library by reading every book versus using the card catalog.

Conclusion

VSCode already has deep semantic understanding of the codebase through LSP. By exposing these APIs to Claude Code, we can leverage this intelligence instead of relying on text-based searching. This would transform Claude Code from a tool that searches for text patterns to one that truly understands code structure - providing orders of magnitude performance improvements.

The integration would be similar to how VSCode extensions like "Go to Definition" or "Find All References" work - instant, accurate, and context-aware. This isn't just an improvement - it's a fundamental transformation of how AI assistants interact with code.

Without this integration, Claude Code is like a brilliant programmer who has to work blindfolded, feeling around for code by text patterns. With it, Claude Code would have the same instant code intelligence that human developers rely on every day.