IDE Codebase Explorer

Prerequisites

1. Check if the getToolCapabilities MCP tool is available to you.

• Not available (no MCP tool by that name): stop and tell the user:

"This skill requires the Claude IDE Bridge with a connected VS Code extension. It uses LSP tools (type hierarchy, call hierarchy, references, hover, inlay hints) that have no CLI equivalent.

To use this skill:

1. Start the bridge: npm run start-all (in claude-ide-bridge/)
2. Ensure the Claude IDE Bridge extension is installed in your IDE
3. Use the claude --ide session (not remote-control)"

• Available: call it. If extensionConnected is false: show the same message. If true: proceed.

Explore and explain a codebase using the IDE bridge's full LSP capabilities. Produces a structured architectural overview.

Workflow

Phase 1: Overview

1. Use getProjectInfo to understand the project type, languages, and frameworks
2. Use getFileTree with depth 3 to see the directory structure
3. Use getToolCapabilities to see what language tooling is available
4. Identify the focus area from the argument: $ARGUMENTS

• If a specific file: explore that file and its connections
• If a module/directory: explore the module's public API and internal structure
• If a question: search for relevant code to answer it

Phase 2: Entry points and architecture

1. Use searchWorkspace to find entry points (main, index, app.listen, export default, etc.)
2. Use getDocumentSymbols on key files to list classes, functions, and exports
3. For the focus area, use getTypeHierarchy on major classes to understand inheritance
4. Use getCallHierarchy (outgoing) on entry points to trace the startup flow

Phase 3: Dependency mapping

1. For the focus area's main exports:

• Use findReferences to see who depends on them
• Use goToDefinition on imports to trace dependencies
• Use getHover on key functions to read their type signatures

1. Use searchWorkspaceSymbols to find related types and interfaces
2. Build a dependency map: what depends on what

Phase 4: Code intelligence deep-dive

1. Use getInlayHints on complex functions to see inferred types
2. Use getCallHierarchy (incoming) on critical functions to understand data flow
3. Use getHover on any unfamiliar types or functions
4. Check getAIComments for any developer notes or TODOs in the focus area

Phase 5: Report

Produce a structured overview:

## Architecture Overview

### Project: [name] ([type])
Languages: [list]
Frameworks: [list]

### Module: [focus area]

#### Purpose
[One paragraph explaining what this module does]

#### Key Files
- file.ts — [role]
- ...

#### Public API
- functionName(args): ReturnType — [description]
- ...

#### Internal Structure
[ASCII diagram showing relationships between key components]

#### Dependencies
- Depends on: [list of modules this imports from]
- Used by: [list of modules that import from this]

#### Call Flow
[Step-by-step trace of a typical operation through this module]

#### Notable Patterns
- [Pattern 1: description]
- ...

#### AI Comments / TODOs
- [Any AI: directives found]

Guidelines

• Use LSP tools (hover, definitions, references) as your primary source of truth — don't guess
• Include file paths and line numbers for all references
• Draw ASCII diagrams for complex relationships
• If the codebase is too large, focus on the requested area and note what was excluded