Rust Symbol Analyzer
Survey a Rust crate or workspace quickly by listing structs, traits, functions, and modules via LSP instead of manually opening every file.
Overview
Rust Symbol Analyzer is an agent skill for the Build phase that lists and categorizes Rust structs, traits, functions, and modules using LSP document and workspace symbols.
Install
npx skills add https://github.com/actionbook/rust-skills --skill rust-symbol-analyzerWhat is this skill?
- LSP documentSymbol for single-file nested modules, structs, and functions
- LSP workspaceSymbol for project-wide symbol search
- Optional filters: --type struct|trait|fn|mod
- Workflow: Glob **/*.rs → documentSymbol on key files → categorized structure visualization
- Triggers on /symbols, 项目结构, list traits, and similar structure queries
- 2 primary LSP operations: documentSymbol and workspaceSymbol
- 4 filterable symbol types: struct, trait, fn, mod
Adoption & trust: 868 installs on skills.sh; 1.2k GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
You inherited or generated a Rust codebase and cannot see how modules, traits, and types connect without tedious manual file hopping.
Who is it for?
Agents and developers with rust-analyzer LSP wired up who need fast structural orientation before edits or code review.
Skip if: Non-Rust projects, environments without LSP support, or deep semantic call-graph analysis (use dedicated static analysis tools).
When should I use this skill?
User asks for project structure, /symbols, list structs/traits/functions, or 符号分析/项目结构; optional file path and --type filter.
What do I get? / Deliverables
You receive a categorized symbol map and project-structure visualization grounded in LSP hierarchy for the files or types you asked about.
- Categorized symbol listing
- Project structure visualization from key files
Recommended Skills
Journey fit
Symbol analysis is a Build-phase backend/dev skill: it helps you navigate and reason about Rust code structure while implementing or refactoring. Backend is the shelf for Rust library/service structure; the skill targets lib.rs/main.rs hierarchies and type-level navigation typical of server and CLI crates.
How it compares
Complements ripgrep with hierarchical LSP symbols—structure trees, not text matches alone.
Common Questions / FAQ
Who is rust-symbol-analyzer for?
Solo builders and agent users working in Rust who need trait/struct inventories and module trees during Build or review.
When should I use rust-symbol-analyzer?
Use it in Build when exploring backend crate layout, before refactors, or when asked to list all traits or project structure—including Chinese triggers like 符号分析.
Is rust-symbol-analyzer safe to install?
It is read-only LSP/Read/Glob per SKILL.md—confirm rust-analyzer trust and review the Security Audits panel on this Prism page.
SKILL.md
READMESKILL.md - Rust Symbol Analyzer
# Rust Symbol Analyzer Analyze project structure by examining symbols across your Rust codebase. ## Usage ``` /rust-symbol-analyzer [file.rs] [--type struct|trait|fn|mod] ``` **Examples:** - `/rust-symbol-analyzer` - Analyze entire project - `/rust-symbol-analyzer src/lib.rs` - Analyze single file - `/rust-symbol-analyzer --type trait` - List all traits in project ## LSP Operations ### 1. Document Symbols (Single File) Get all symbols in a file with their hierarchy. ``` LSP( operation: "documentSymbol", filePath: "src/lib.rs", line: 1, character: 1 ) ``` **Returns:** Nested structure of modules, structs, functions, etc. ### 2. Workspace Symbols (Entire Project) Search for symbols across the workspace. ``` LSP( operation: "workspaceSymbol", filePath: "src/lib.rs", line: 1, character: 1 ) ``` **Note:** Query is implicit in the operation context. ## Workflow ``` User: "What's the structure of this project?" │ ▼ [1] Find all Rust files Glob("**/*.rs") │ ▼ [2] Get symbols from each key file LSP(documentSymbol) for lib.rs, main.rs │ ▼ [3] Categorize by type │ ▼ [4] Generate structure visualization ``` ## Output Format ### Project Overview ``` ## Project Structure: my-project ### Modules ├── src/ │ ├── lib.rs (root) │ ├── config/ │ │ ├── mod.rs │ │ └── parser.rs │ ├── handlers/ │ │ ├── mod.rs │ │ ├── auth.rs │ │ └── api.rs │ └── models/ │ ├── mod.rs │ ├── user.rs │ └── order.rs └── tests/ └── integration.rs ``` ### By Symbol Type ``` ## Symbols by Type ### Structs (12) | Name | Location | Fields | Derives | |------|----------|--------|---------| | Config | src/config.rs:10 | 5 | Debug, Clone | | User | src/models/user.rs:8 | 4 | Debug, Serialize | | Order | src/models/order.rs:15 | 6 | Debug, Serialize | | ... | | | | ### Traits (4) | Name | Location | Methods | Implementors | |------|----------|---------|--------------| | Handler | src/handlers/mod.rs:5 | 3 | AuthHandler, ApiHandler | | Repository | src/db/mod.rs:12 | 5 | UserRepo, OrderRepo | | ... | | | | ### Functions (25) | Name | Location | Visibility | Async | |------|----------|------------|-------| | main | src/main.rs:10 | pub | yes | | parse_config | src/config.rs:45 | pub | no | | ... | | | | ### Enums (6) | Name | Location | Variants | |------|----------|----------| | Error | src/error.rs:5 | 8 | | Status | src/models/order.rs:5 | 4 | | ... | | | ``` ### Single File Analysis ``` ## src/handlers/auth.rs ### Symbols Hierarchy mod auth ├── struct AuthHandler │ ├── field: config: Config │ ├── field: db: Pool │ └── impl AuthHandler │ ├── fn new(config, db) -> Self │ ├── fn authenticate(&self, token) -> Result<User> │ └── fn refresh_token(&self, user) -> Result<Token> ├── struct Token │ ├── field: value: String │ └── field: expires: DateTime ├── enum AuthError │ ├── InvalidToken │ ├── Expired │ └── Unauthorized └── impl Handler for AuthHandler ├── fn handle(&self, req) -> Response └── fn name(&self) -> &str ``` ## Analysis Features ### Complexity Metrics ``` ## Complexity Analysis | File | Structs | Functions | Lines | Complexity | |------|---------|-----------|-------|------------| | src/handlers/auth.rs | 2 | 8 | 150 | Medium | | src/models/user.rs | 3 | 12 | 200 | High | | src/config.rs | 1 | 3 | 50 | Low | **Hotspots:** Files with high complexity that may need refactoring - src/handlers/api.rs (15 functions, 300 lines) ``` ### Dependency Analysis ``` ## Internal Dependencies auth.rs ├── imports from: config.rs, models/user.rs, db/mod.rs └── imported by: main.rs, handlers/mod.rs user.rs ├