Crate Map

Map Rust crate structures, dependencies, and file locations in the stupid-db workspace.

Updated Feb 13, 2026
One-click install
npx skills add https://github.com/FrancisVarga/stupid-db --skill crate-map
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: Crate Map
Source: https://github.com/FrancisVarga/stupid-db/tree/main/packages/stupid-claude-agent/.claude/skills/crate-map
Command: npx skills add https://github.com/FrancisVarga/stupid-db --skill crate-map

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps developers understand the complex architecture of the stupid-db project by providing a clear overview of its internal crates, their responsibilities, and dependencies.

Core Features & Use Cases

  • Codebase Navigation: Quickly locate the relevant crate for a specific feature or component.
  • Dependency Understanding: Visualize how different parts of the system connect and rely on each other.
  • New Code Integration: Identify the best crate to add new functionality to, based on existing structures.
  • Use Case: When asked to implement a new graph algorithm, this Skill can identify that the compute crate is the correct place to add the code, and that it depends on the graph crate.

Quick Start

Use the Crate Map skill to find the crate responsible for embedding generation.

Frequently Asked Questions about Crate Map

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

FAQPage Schema
How do I navigate a Rust Cargo workspace codebase with multiple crates?

To navigate a Rust Cargo workspace codebase, you need a map detailing each crate's responsibilities, dependencies, key types, and file locations. This provides a clear overview of internal architecture and facilitates locating the correct crate for specific features.

How do I identify crate dependencies before adding new code to a Rust project?

Identifying crate dependencies before adding new code requires analyzing interdependencies within the Cargo workspace. This reveals how different system parts connect and rely on each other, guiding you to the correct crate for new functionality integration.

What is the best way to understand crate boundaries in a complex Rust architecture?

Understanding crate boundaries in a complex Rust architecture involves mapping each crate's specific responsibilities and dependencies. This clarifies the separation of concerns within the codebase and helps identify the appropriate crate for adding new functionality.

Where should I add new functionality when working with interdependent Rust crates?

When adding new functionality to interdependent Rust crates, you should locate the crate whose existing responsibilities align with the new feature. Mapping the workspace dependencies ensures the new code integrates cleanly into the correct crate boundaries.

Can I find which crate handles embedding generation in a Cargo workspace?

Yes, you can find which crate handles embedding generation in a Cargo workspace by using a crate map. It identifies the specific crate responsible for that feature and highlights its dependencies on other workspace crates.

Does mapping a Rust codebase structure require external dependencies?

No, mapping a Rust codebase structure does not require external dependencies. The analysis relies solely on examining the existing Cargo workspace crate structures and their internal interdependencies to generate the map.