Rust Symbol Analyzer
Map a Rust crate or workspace with LSP document and workspace symbols before refactors, onboarding, or agent-driven edits.
Overview
Rust Symbol Analyzer is an agent skill for the Build phase that maps Rust project structure using LSP document and workspace symbols with optional struct, trait, function, and module filters.
Install
npx skills add https://github.com/zhanghandong/rust-skills --skill rust-symbol-analyzerWhat is this skill?
- Document symbols via LSP(documentSymbol) with nested modules, structs, traits, and functions per file
- Workspace-wide symbol search via LSP(workspaceSymbol) across the Rust project
- Optional filters: single file path and --type struct|trait|fn|mod
- Four-step workflow: Glob **/*.rs, LSP on key files, categorize by type, emit structure visualization
- Trigger phrases: /symbols, project structure, list structs, list traits, list functions (EN/ZH)
- Two LSP operations: documentSymbol and workspaceSymbol
- Four-step workflow from Glob through structure visualization
- Symbol type filter flags: struct, trait, fn, mod
Adoption & trust: 665 installs on skills.sh; 1.2k GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
You are about to change a Rust codebase but do not have a reliable inventory of modules, structs, traits, and functions across files.
Who is it for?
Solo builders or small teams on Rust who want LSP-backed structure lists before refactors, reviews, or handing context to an agent.
Skip if: Non-Rust stacks, CI-only workflows with no LSP server, or teams that already maintain up-to-date architecture docs and do not need live symbol passes.
When should I use this skill?
User asks for /symbols, project structure, list structs, traits, or functions, or Chinese triggers 符号分析, 项目结构, 列出所有, 有哪些struct.
What do I get? / Deliverables
You get a categorized symbol map and structure visualization scoped to the whole workspace or a single file, ready for refactors or the next agent task.
- Categorized symbol list (struct, trait, fn, mod) for file or workspace
- Project structure visualization derived from LSP hierarchy
Recommended Skills
Journey fit
Structure discovery happens while you are actively building or changing Rust code, not during idea or launch work. The skill wires the coding agent to LSP symbol APIs (Glob, Read, documentSymbol, workspaceSymbol) rather than shipping or validating the product.
How it compares
Use LSP-backed symbol inventory instead of ripgrep-only scans that miss hierarchy and type boundaries.
Common Questions / FAQ
Who is rust-symbol-analyzer for?
Indie and solo Rust developers and agent users who need a quick, accurate catalog of structs, traits, functions, and modules before editing or delegating work.
When should I use rust-symbol-analyzer?
During Build when onboarding to a crate, planning a refactor, or when triggers like /symbols, project structure, or list all traits apply—after the repo is open with a working Rust LSP.
Is rust-symbol-analyzer safe to install?
It is read-oriented (LSP, Read, Glob) and does not prescribe destructive shell by default; review the Security Audits panel on this Prism page and your agent’s LSP permissions before use.
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 ├