zhanghandong/rust-skills
Overview
This skill visualizes Rust function call graphs using the language server call hierarchy. It generates caller, callee, or bidirectional graphs and produces readable ASCII or mermaid outputs to support impact analysis and code exploration. Use it to trace execution paths, find hot paths, and surface high fan-out or frequently-called functions.
How this skill works
The skill locates a function symbol, then calls the LSP prepareCallHierarchy to get the base item. It expands incomingCalls and outgoingCalls via LSP, recursively up to a configured depth, and aggregates results. Finally it renders an ASCII tree, optional box diagram, or Mermaid graph and computes simple analysis like entry points, leaf functions, and hot paths.
When to use it
- Perform impact analysis before changing a function (who calls this?).
- Understand what a function invokes to inspect dependencies and side effects.
- Trace execution paths from main or tests into a target function.
- Document call relationships for code reviews or architecture notes.
- Identify hot paths, high fan-out functions, or potential refactor targets.
Best practices
- Start with depth 2–3 to get a manageable overview, increase for deeper investigation.
- Prefer bidirectional view when you need full context; use incoming or outgoing for focused queries.
- Combine LSP results with grep or workspace symbols if the server misses a location.
- Annotate dynamic dispatch or external crate calls explicitly in the output.
- Export complex graphs to Mermaid for inclusion in docs or deeper visualization tools.
Example use cases
- Show callers and callees for process_request to reveal hot paths and dependencies.
- Run incoming-only analysis on handle_error to see all impact sites before a change.
- Trace from main out to a module with --depth 5 to map a long execution chain.
- Export a service handler graph to Mermaid for architecture documentation.
- Detect functions with unusually high fan-out (many callees) for targeted refactoring.
FAQ
Use --depth N to limit levels and --direction in|out|both to pick callers, callees, or both.
How does it find the function location?
It uses LSP workspaceSymbol or a fallback grep to locate the function and its file/position.
Can it show dynamic dispatch or external crate calls?
Yes—those are included but annotated (for example, [dynamic dispatch] or external crate names) to signal that resolution is incomplete.
31 skills
This skill visualizes Rust function call graphs using LSP, helping you quickly understand callers and callees with depth control.
This skill analyzes a Rust project to reveal structure and symbols using LSP, listing modules, structs, traits, and functions.
This skill helps you explore Rust trait implementations and find all implementors using LSP-driven insights for faster polymorphism understanding.
This skill visualizes Rust project dependencies as ASCII art, helping you quickly understand structure, depth, and feature-driven relationships.
This skill helps navigate large Rust codebases by locating definitions, references, and hover info via LSP.
This skill helps you perform safe Rust refactoring with LSP analysis, providing impact checks and automated changes.
This skill helps you design and implement immutable, precise fintech transactions using rust_decimal, event sourcing, and audit trails for compliance.
This skill helps you design offline-first, power-efficient IoT apps with secure, reliable messaging and safe OTA updates.
This skill helps you design and run cloud-native Rust services with proper observability, health checks, graceful shutdown, and 12-factor config.
This skill helps you build efficient Rust ML apps by applying domain constraints for memory, GPU, and model portability.
This skill helps you implement no_std embedded Rust projects safely by enforcing heapless data structures, interrupt-safe patterns, and clear peripheral
This skill helps you reason about Rust mutability, choose appropriate patterns, and prevent borrow conflicts across single and multi-thread contexts.
This skill helps review unsafe Rust code and FFI usage, highlighting safety concerns, soundness, and proper SAFETY comments to prevent undefined behavior.
This skill fetches and summarizes Rust daily, weekly, and monthly updates from major sources to keep you informed efficiently.
This skill helps you learn Rust concepts by mapping ownership, borrowing, and memory layouts to intuitive mental models and practical analogies.
This skill helps you identify and replace anti-patterns in Rust code, improving idiomatic design and reliability during reviews.
This skill helps you choose the right Rust crate and integration approach for a project by evaluating maintenance, scope, and compatibility.
This skill helps design robust domain error handling by classifying errors, guiding recovery, and applying retry, fallback, and circuit-breaker patterns.
This skill helps you generate dynamic Rust crate and std library skills from documentation URLs, accelerating llms-based skill creation.
This skill guides Rust questions across errors, design, and coding, routing to the right expertise for precise, actionable guidance.
This skill helps you optimize Rust performance by guiding measurement, profiling, and design choices to reduce allocations, improve cache, and parallelize.
This skill helps you design and implement fast, secure web services in Rust using async, state management, and middleware patterns.
This skill helps you assess and apply error handling strategies in Rust, guiding when to use Result, Option, or panic with context.
This skill helps you design robust resource lifecycles in Rust by applying RAII, lazy init, and pooling patterns across scopes.
This skill helps you design robust CLI tools with layered config, strong error handling, and user-friendly prompts.
This skill helps you model domain concepts in Rust by guiding entity vs value object, aggregates, and repository patterns for correct invariants.
This skill helps you select appropriate Rust smart pointers for resource management, guiding ownership, threading, and cycle avoidance.
This skill helps you choose between generics and trait objects for zero-cost abstraction in Rust, optimizing performance and flexibility.
This skill helps you design and reason about Rust concurrency, choosing appropriate primitives and avoiding deadlocks.
This skill helps you diagnose and resolve Rust ownership and lifetime errors by guiding design decisions and refactoring strategies.
This skill helps you design safer Rust APIs by encoding invariants in types, enabling compile-time validation and zero-cost state transitions.
