Rust Code Navigator
Jump to definitions, find references, and read types in large Rust codebases via LSP instead of manual ripgrep tours.
Overview
rust-code-navigator is an agent skill for the Build phase that navigates Rust symbols using LSP go-to-definition, find-references, and hover from a symbol or file:line anchor.
Install
npx skills add https://github.com/actionbook/rust-skills --skill rust-code-navigatorWhat is this skill?
- LSP goToDefinition for where a symbol is defined (Ctrl+click equivalent)
- findReferences before refactors to see blast radius across the crate or workspace
- hover for quick type and documentation without leaving the agent session
- Argument hint: symbol plus optional file:line anchor for disambiguation
- Triggers: /navigate, go to definition, find references, 跳转定义, 查找引用
- Three LSP operations documented: goToDefinition, findReferences, hover
Adoption & trust: 880 installs on skills.sh; 1.2k GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
You are lost in a large Rust crate and need definition sites and callers without manually grep-hopping across modules.
Who is it for?
Solo Rust developers using LSP-enabled agents who refactor or onboard to unfamiliar modules quickly.
Skip if: Greenfield scaffolds with no LSP server, non-Rust codebases, or tasks that need compile fixes rather than navigation.
When should I use this skill?
Triggers on /navigate, go to definition, find references, where is defined, 跳转定义, 查找引用, 定义在哪, 谁用了这个.
What do I get? / Deliverables
You land on the defining location, a reference list for refactors, or hover type and docs for the symbol you named.
- Definition location for the requested symbol
- Reference list or hover type and documentation summary
Recommended Skills
Journey fit
Rust navigation is a Build-phase activity while implementing or refactoring backend and systems code. Backend is the canonical shelf because LSP go-to-definition and find-references serve Rust libraries, services, and CLIs—not frontend CSS or launch distribution.
How it compares
Use instead of text-only search when you need semantic cross-file references rust-analyzer understands.
Common Questions / FAQ
Who is rust-code-navigator for?
Solo and indie builders working in Rust who want agent-driven LSP navigation comparable to IDE go-to-definition and find-all-references.
When should I use rust-code-navigator?
During Build/backend implementation when you ask where a struct or function is defined, who calls it, or what type hover shows—especially before refactors in large workspaces.
Is rust-code-navigator safe to install?
It uses LSP and file reads on your repo, not arbitrary network APIs in the skill text; review the Security Audits panel on this Prism page before enabling LSP in your agent.
SKILL.md
READMESKILL.md - Rust Code Navigator
# 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 |