Rust Call Graph
Map who calls and what a Rust function calls via LSP when navigating an unfamiliar crate or debugging control flow.
Overview
rust-call-graph is an agent skill for the Build phase that visualizes Rust function call relationships using LSP call hierarchy with configurable depth and direction.
Install
npx skills add https://github.com/actionbook/rust-skills --skill rust-call-graphWhat is this skill?
- Slash command `/rust-call-graph <function>` with optional `--depth N` and `--direction in|out|both`
- LSP prepareCallHierarchy, incomingCalls, and outgoingCalls operations
- Default traversal depth of 3 with deep callee analysis up to depth 5 in examples
- Workspace symbol or grep fallback to locate the function before hierarchy prep
- Bilingual trigger phrases including call hierarchy and 调用图 / 谁调用了
- Default graph depth 3
- Direction modes: in, out, both
- Three LSP operations: prepareCallHierarchy, incomingCalls, outgoingCalls
Adoption & trust: 870 installs on skills.sh; 1.2k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You found a Rust function but cannot quickly see upstream callers or downstream callees across the workspace.
Who is it for?
Indie Rust authors using LSP-enabled agents to explore crates, handlers, and error paths before changing signatures.
Skip if: Non-Rust codebases, runtime profiling, or environments without a working Rust LSP/rust-analyzer setup.
When should I use this skill?
User asks for /call-graph, call hierarchy, who calls, what calls, or Chinese 调用图 / 调用关系 / 谁调用了 / 调用了谁 for a Rust function.
What do I get? / Deliverables
You get a structured call graph from LSP incoming/outgoing hierarchy so refactors and bugfixes target the right dependency chain.
- Call hierarchy report for the target function
- Traversed caller and/or callee tree per depth and direction flags
Recommended Skills
Journey fit
Call-graph exploration is a backend comprehension task while implementing or refactoring Rust services and CLIs. Backend subphase covers Rust modules, handlers, and service layers where LSP call hierarchy answers dependency questions.
How it compares
Use for LSP call hierarchy in-editor, not a standalone static-analysis binary or production tracing system.
Common Questions / FAQ
Who is rust-call-graph for?
Solo developers and small teams shipping Rust APIs, CLIs, or agent tools who rely on IDE LSP from coding agents.
When should I use rust-call-graph?
During Build backend work when you need callers-only, callees-only, or bidirectional graphs for a named function before editing Rust modules.
Is rust-call-graph safe to install?
It uses read-oriented LSP and file tools; review the Security Audits panel on this Prism page and confirm your agent’s LSP permissions match your repo policy.
SKILL.md
READMESKILL.md - Rust Call Graph
# Rust Call Graph Visualize function call relationships using LSP call hierarchy. ## Usage ``` /rust-call-graph <function_name> [--depth N] [--direction in|out|both] ``` **Options:** - `--depth N`: How many levels to traverse (default: 3) - `--direction`: `in` (callers), `out` (callees), `both` **Examples:** - `/rust-call-graph process_request` - Show both callers and callees - `/rust-call-graph handle_error --direction in` - Show only callers - `/rust-call-graph main --direction out --depth 5` - Deep callee analysis ## LSP Operations ### 1. Prepare Call Hierarchy Get the call hierarchy item for a function. ``` LSP( operation: "prepareCallHierarchy", filePath: "src/handler.rs", line: 45, character: 8 ) ``` ### 2. Incoming Calls (Who calls this?) ``` LSP( operation: "incomingCalls", filePath: "src/handler.rs", line: 45, character: 8 ) ``` ### 3. Outgoing Calls (What does this call?) ``` LSP( operation: "outgoingCalls", filePath: "src/handler.rs", line: 45, character: 8 ) ``` ## Workflow ``` User: "Show call graph for process_request" │ ▼ [1] Find function location LSP(workspaceSymbol) or Grep │ ▼ [2] Prepare call hierarchy LSP(prepareCallHierarchy) │ ▼ [3] Get incoming calls (callers) LSP(incomingCalls) │ ▼ [4] Get outgoing calls (callees) LSP(outgoingCalls) │ ▼ [5] Recursively expand to depth N │ ▼ [6] Generate ASCII visualization ``` ## Output Format ### Incoming Calls (Who calls this?) ``` ## Callers of `process_request` main └── run_server └── handle_connection └── process_request ◄── YOU ARE HERE ``` ### Outgoing Calls (What does this call?) ``` ## Callees of `process_request` process_request ◄── YOU ARE HERE ├── parse_headers │ └── validate_header ├── authenticate │ ├── check_token │ └── load_user ├── execute_handler │ └── [dynamic dispatch] └── send_response └── serialize_body ``` ### Bidirectional (Both) ``` ## Call Graph for `process_request` ┌─────────────────┐ │ main │ └────────┬────────┘ │ ┌────────▼────────┐ │ run_server │ └────────┬────────┘ │ ┌────────▼────────┐ │handle_connection│ └────────┬────────┘ │ ┌────────────────────┼────────────────────┐ │ │ │ ┌───────▼───────┐ ┌───────▼───────┐ ┌───────▼───────┐ │ parse_headers │ │ authenticate │ │send_response │ └───────────────┘ └───────┬───────┘ └───────────────┘ │ ┌───────┴───────┐ │ │ ┌──────▼──────┐ ┌──────▼──────┐ │ check_token │ │ load_user │ └─────────────┘ └─────────────┘ ``` ## Analysis Insights After generating the call graph, provide insights: ``` ## Analysis **Entry Points:** main, test_process_request **Leaf Functions:** validate_header, serialize_body **Hot Path:** main → run_server → handle_connection → process_request **Complexity:** 12 functions, 3 levels deep **Potential Issues:** - `authenticate` has high fan-out (4 callees) - `process_request` is called from 3 places (consider if this is intentional) ``` ## Common Patterns | User Says | Direction | Use Case | |-----------|-----------|----------| | "Who calls X?" | incoming | Impact analysis | | "What does X call?" | outgoing | Understanding implementation | | "Show call graph" | both | Full picture | | "Tr