PluginBench
Skill
Fail
Audit score 45

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
Prerequisites
  • rust-analyzer installed (via `rustup component add rust-analyzer`)
  • LSP server running in your editor or environment
Claude Code
Cursor
Windsurf
Cline

How to use rust-code-navigator

  1. 1.Invoke the skill with `/rust-code-navigator <symbol>` or `/navigate <symbol>`
  2. 2.Optionally specify a file and line: `/rust-code-navigator MyStruct in src/lib.rs:42`
  3. 3.Review the definition location and surrounding code context
  4. 4.Use find references to see all usages in a table format
  5. 5.Check hover information for type signatures and documentation

Use cases

Good for
  • 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
Who it's for
  • 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

What if the symbol is not found?

The skill will attempt a workspace symbol search first. If still not found, verify the symbol name is spelled correctly and is in scope.

How does this handle generics and macros?

When multiple definitions exist due to generics or macros, the skill shows all candidates and lets you choose which one to navigate to.

Can I use this without rust-analyzer?

No, rust-analyzer must be installed and running. Install it with `rustup component add rust-analyzer`.

What languages does this support?

This skill is specific to Rust code navigation via rust-analyzer LSP.

How do I find all structs in my project?

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 SaysLSP 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

ErrorCauseSolution
"No LSP server"rust-analyzer not runningSuggest: rustup component add rust-analyzer
"Symbol not found"Typo or not in scopeSearch with workspaceSymbol first
"Multiple definitions"Generics or macrosShow all and let user choose

Related Skills

WhenSee
Call relationshipsrust-call-graph
Project structurerust-symbol-analyzer
Trait implementationsrust-trait-explorer
Safe refactoringrust-refactor-helper