rust-call-graph

Visualize Rust function call graphs via LSP call hierarchy operations.

1|Updated May 29, 2026
One-click install
npx skills add https://github.com/simorgh3196/tsuzulint --skill rust-call-graph
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rust-call-graph
Source: https://github.com/simorgh3196/tsuzulint/tree/main/.agents/skills/rust-call-graph
Command: npx skills add https://github.com/simorgh3196/tsuzulint --skill rust-call-graph

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps developers understand complex Rust codebases by visualizing function call relationships using the Language Server Protocol (LSP) call hierarchy, enabling quicker debugging and safer refactoring.

Core Features & Use Cases

  • LSP-based call hierarchy exploration for Rust projects to identify callers, callees, and call paths.
  • Depth-limited traversal with options to show both incoming and outgoing calls.
  • ASCII-style visualization of call graphs and quick navigation from function to related calls.
  • Use Case: a developer investigates why a performance regression occurs by tracing high-traffic call paths.

Quick Start

Invoke the skill with a Rust function name, for example: /rust-call-graph process_request --depth 4 --direction both

Frequently Asked Questions about rust-call-graph

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I visualize a Rust function call graph to understand code relationships?

This Skill generates an ASCII visualization of a Rust function call graph by querying the Language Server Protocol. It reveals function relationships and call hierarchies by applying prepareCallHierarchy, incomingCalls, and outgoingCalls operations to your Rust project.

Can I trace incoming and outgoing calls for a specific Rust function during debugging?

Yes, you can trace both incoming and outgoing calls for a specific Rust function during debugging. The Skill applies LSP incomingCalls and outgoingCalls operations to traverse the call hierarchy and outputs the relationships in an ASCII visualization.

How do I limit the traversal depth when exploring a Rust call hierarchy?

You can limit the traversal depth when exploring a Rust call hierarchy by invoking the Skill with a depth parameter. This restricts the LSP call graph traversal to a specified number of levels, preventing overly complex ASCII visualizations in large Rust projects.

Does this LSP call graph visualization work with large Rust projects?

Yes, this LSP call graph visualization works with Rust projects of varying sizes. It enables exploration of callers and callees with depth-limited traversal, allowing you to navigate complex codebases without being overwhelmed by the full call hierarchy.

What is the best way to trace high-traffic call paths causing a performance regression in Rust?

The best way to trace high-traffic call paths is by visualizing the Rust function call graph with LSP. By exploring the outgoing calls and call hierarchy of the affected function, you can quickly identify the performance regression source.