rust-code-navigator
actionbook/rust-skills
Navigate Rust code with LSP: go to definition, find references, and explore symbols efficiently.
What is rust-code-navigator?
Rust Code Navigator uses Language Server Protocol to help you explore large Rust codebases. Use it to find where symbols are defined, see all usages, get type information, and understand code relationships without manual searching.
- Go to definition: locate where a symbol is declared
- Find references: discover all usages of a symbol across the codebase
- Hover information: retrieve type signatures and documentation
- Workspace symbol search: find symbols by name across the project
- Document symbol listing: view all symbols in a file
How to install rust-code-navigator
npx skills add https://github.com/actionbook/rust-skills --skill rust-code-navigator- rust-analyzer installed (via `rustup component add rust-analyzer`)
- LSP server running in your editor or environment
How to use rust-code-navigator
- 1.Invoke the skill with `/rust-code-navigator <symbol>` or `/navigate <symbol>`
- 2.Optionally specify a file and line: `/rust-code-navigator MyStruct in src/lib.rs:42`
- 3.Review the definition location and surrounding code context
- 4.Use find references to see all usages in a table format
- 5.Check hover information for type signatures and documentation
Use cases
- Understanding a new codebase by jumping to struct and function definitions
- Refactoring safely by finding all references before renaming
- Checking the impact of changes by seeing where a symbol is used
- Exploring type hierarchies and trait implementations
- Navigating between related code across multiple files
- Rust developers exploring unfamiliar codebases
- Teams performing code reviews and refactoring
- Contributors onboarding to large Rust projects
- Developers using LSP-compatible editors
rust-code-navigator FAQ
The skill will attempt a workspace symbol search first. If still not found, verify the symbol name is spelled correctly and is in scope.
When multiple definitions exist due to generics or macros, the skill shows all candidates and lets you choose which one to navigate to.
No, rust-analyzer must be installed and running. Install it with `rustup component add rust-analyzer`.
This skill is specific to Rust code navigation via rust-analyzer LSP.
Use the workspace symbol operation to search for struct names, or use the document symbol operation to list all symbols in a specific file.
Full instructions (SKILL.md)
Source of truth, from actionbook/rust-skills.
name: rust-code-navigator description: "Navigate Rust code using LSP. Triggers on: /navigate, go to definition, find references, where is defined, 跳转定义, 查找引用, 定义在哪, 谁用了这个" argument-hint: "<symbol> [in file.rs:line]" allowed-tools: ["LSP", "Read", "Glob"]
Rust Code Navigator
Navigate large Rust codebases efficiently using Language Server Protocol.
Usage
/rust-code-navigator <symbol> [in file.rs:line]
Examples:
/rust-code-navigator parse_config- Find definition of parse_config/rust-code-navigator MyStruct in src/lib.rs:42- Navigate from specific location
LSP Operations
1. Go to Definition
Find where a symbol is defined.
LSP(
operation: "goToDefinition",
filePath: "src/main.rs",
line: 25,
character: 10
)
Use when:
- User asks "where is X defined?"
- User wants to understand a type/function
- Ctrl+click equivalent
2. Find References
Find all usages of a symbol.
LSP(
operation: "findReferences",
filePath: "src/lib.rs",
line: 15,
character: 8
)
Use when:
- User asks "who uses X?"
- Before refactoring/renaming
- Understanding impact of changes
3. Hover Information
Get type and documentation for a symbol.
LSP(
operation: "hover",
filePath: "src/main.rs",
line: 30,
character: 15
)
Use when:
- User asks "what type is X?"
- User wants documentation
- Quick type checking
Workflow
User: "Where is the Config struct defined?"
│
▼
[1] Search for "Config" in workspace
LSP(operation: "workspaceSymbol", ...)
│
▼
[2] If multiple results, ask user to clarify
│
▼
[3] Go to definition
LSP(operation: "goToDefinition", ...)
│
▼
[4] Show file path and context
Read surrounding code for context
Output Format
Definition Found
## Config (struct)
**Defined in:** `src/config.rs:15`
```rust
#[derive(Debug, Clone)]
pub struct Config {
pub name: String,
pub port: u16,
pub debug: bool,
}
```
**Documentation:** Configuration for the application server.
References Found
## References to `Config` (5 found)
| Location | Context |
|----------|---------|
| src/main.rs:10 | `let config = Config::load()?;` |
| src/server.rs:25 | `fn new(config: Config) -> Self` |
| src/server.rs:42 | `self.config.port` |
| src/tests.rs:15 | `Config::default()` |
| src/cli.rs:8 | `config: Option<Config>` |
Common Patterns
| User Says | LSP Operation |
|---|---|
| "Where is X defined?" | goToDefinition |
| "Who uses X?" | findReferences |
| "What type is X?" | hover |
| "Find all structs" | workspaceSymbol |
| "What's in this file?" | documentSymbol |
Error Handling
| Error | Cause | Solution |
|---|---|---|
| "No LSP server" | rust-analyzer not running | Suggest: rustup component add rust-analyzer |
| "Symbol not found" | Typo or not in scope | Search with workspaceSymbol first |
| "Multiple definitions" | Generics or macros | Show all and let user choose |
Related Skills
| When | See |
|---|---|
| Call relationships | rust-call-graph |
| Project structure | rust-symbol-analyzer |
| Trait implementations | rust-trait-explorer |
| Safe refactoring | rust-refactor-helper |
Related skills
More from actionbook/rust-skills and the wider catalog.

rust-daily
Fetch Rust community news and updates filtered by time range (daily, weekly, or monthly).

rust-deps-visualizer
Visualize Rust project dependencies as ASCII art trees with optional feature flags.

rust-learner
Fetch Rust versions, crate info, and API documentation from official sources.

rust-refactor-helper
Safe Rust refactoring with LSP-powered impact analysis and dry-run preview.

rust-router
Router skill for all Rust questions—directs to specialized language, design, and domain skills.

rust-skill-creator
Create dynamic skills for Rust crates and standard library documentation.