feat: show deps and available workspace members in crate overview

When listing a crate's items with `rspeek <crate>`, the output now
includes direct dependencies and workspace members that aren't yet
deps. Helps LLMs discover what's already available before writing
code from scratch.

Crate name comparison normalizes hyphens/underscores to avoid
false positives in the available list.

Author: tzneal

README.md

@@ -2,8 +2,9 @@
 
 Inspect type definitions from Rust crate source code without building docs.
 
-Searches dependency crates and workspace member crates — including integration
-tests in `tests/`.
+Searches dependency crates and workspace member crates for structs, enums,
+unions, traits, type aliases, constants, statics, and functions — including
+integration tests in `tests/`.
 
 ## Installation
 
@@ -94,23 +95,31 @@ Found 7 matches for `Error`:
 - struct `serde_json::error::Error` at /home/user/.cargo/.../error.rs:15
 ```
 
-Crate overview — source path and item listing:
+Crate overview — source path, dependencies, and item listing:
 
 ```
-## `anyhow` v1.0.102
-**Source:** `/home/user/.cargo/registry/src/.../anyhow-1.0.102/src`
+## `serde_json` v1.0.149
+**Source:** `/home/user/.cargo/registry/src/.../serde_json-1.0.149/src`
+
+**Dependencies:** itoa, memchr, serde, serde_core, zmij
+
+**Workspace members (not yet deps):** my-utils, my-core
 
 Public items:
 
-- struct `Error`
-- struct `Chain`
-- type `Result`
-- trait `Context`
+- struct `de::Deserializer`
+- fn `de::from_reader`
+- fn `de::from_slice`
+- fn `de::from_str`
+- struct `error::Error`
+- enum `value::Value`
 
-Usage: `rspeek anyhow <Item>`
+Usage: `rspeek serde_json <Item>`
 ```
 
 For workspace members, all items are shown (not just public).
+**Dependencies** and **Workspace members (not yet deps)** help you discover
+what's already usable and what can be added with a one-line Cargo.toml edit.
 
 ### JSON output
 
@@ -160,6 +169,6 @@ Use `--llm-help` for extended usage documentation suitable for tool descriptions
 
 ## Limitations
 
-- Only finds items defined as regular Rust syntax (`struct`, `enum`, `trait`, `type`, `fn`)
+- Only finds items defined as regular Rust syntax (`struct`, `enum`, `union`, `trait`, `type`, `fn`, `const`, `static`)
 - Macro bodies are parsed for item definitions (e.g., syn's `ast_struct!`), but procedural macros and complex `macro_rules!` patterns are not expanded
 - Re-exports: `pub use` within a crate are followed; glob re-exports and cross-crate re-exports are not

src/main.rs

@@ -38,8 +38,9 @@ const LLM_HELP: &str = r#"# rspeek — inspect type definitions from Rust depend
 
 ## Usage
 
-rspeek is designed to be called by LLMs to look up structs, enums, traits,
-type aliases, and functions from Rust crates without building docs.
+rspeek is designed to be called by LLMs to look up structs, enums, unions,
+traits, type aliases, constants, statics, and functions from Rust crates
+without building docs.
 
 Run from any directory containing a Cargo.toml. Searches dependency crates
 and workspace member crates (including integration tests in `tests/`).
@@ -78,12 +79,26 @@ crate version, and the original source in a fenced code block.
 Multiple matches: summary list with kind, qualified path, and location.
 Narrow the search with a crate name or qualified path.
 
+## Crate overview
+
+`rspeek <crate>` lists public items and also shows:
+- **Dependencies**: direct deps of the crate (already in Cargo.toml)
+- **Workspace members (not yet deps)**: sibling crates that can be added
+  with a one-line Cargo.toml edit
+
+Use this to check what's already available before writing code from scratch.
+
 ## JSON output
 
 --json returns an array of objects:
   [{"name", "kind", "module_path", "file", "start_line", "end_line",
     "crate_name", "crate_version", "source", "impls"?}]
 
+Crate overview (rspeek --json <crate>) returns:
+  [{"crate_name", "crate_version", "src_dir", "items": [...],
+    "deps": ["anyhow", ...],
+    "available_workspace_members": ["my-utils", ...]}]
+
 Errors are also JSON: {"error": "...", "suggestions": ["..."]}
 
 ## Did you mean?
@@ -203,6 +218,8 @@ fn run(cli: &Cli) -> std::result::Result<(), NotFound> {
                             module_path: i.module_path,
                         })
                         .collect(),
+                    deps: c.deps.clone(),
+                    available_workspace_members: ws.available_members(&c.name, &c.deps),
                 });
             }
             println!("{}", serde_json::to_string(&overviews).unwrap());
@@ -217,6 +234,16 @@ fn run(cli: &Cli) -> std::result::Result<(), NotFound> {
                         .collect::<Vec<_>>()
                         .join(", ")
                 );
+                if !c.deps.is_empty() {
+                    println!("**Dependencies:** {}\n", c.deps.join(", "));
+                }
+                let available = ws.available_members(&c.name, &c.deps);
+                if !available.is_empty() {
+                    println!(
+                        "**Workspace members (not yet deps):** {}\n",
+                        available.join(", ")
+                    );
+                }
                 let pub_only = !c.is_workspace_member;
                 let items = index::list_items(&c.source_dirs, pub_only, c.out_dir.as_deref())
                     .map_err(|e| NotFound {

src/output.rs

@@ -35,6 +35,10 @@ pub struct JsonCrateOverview {
     pub crate_version: String,
     pub src_dir: String,
     pub items: Vec<JsonItem>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub deps: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub available_workspace_members: Vec<String>,
 }
 
 #[derive(Serialize)]

src/resolve.rs

@@ -13,6 +13,8 @@ pub struct ResolvedCrate {
     pub is_workspace_member: bool,
     /// Build script OUT_DIR, if the crate has been built.
     pub out_dir: Option<PathBuf>,
+    /// Direct dependency crate names.
+    pub deps: Vec<String>,
 }
 
 /// Normalize crate name for comparison (treat `-` and `_` as equivalent).
@@ -97,12 +99,14 @@ impl Workspace {
                     }
                 }
                 let out_dir = find_out_dir(metadata.target_directory.as_std_path(), &pkg.name);
+                let deps: Vec<String> = node.deps.iter().map(|d| d.name.clone()).collect();
                 crates.push(ResolvedCrate {
                     name: pkg.name.to_string(),
                     version: pkg.version.to_string(),
                     source_dirs,
                     is_workspace_member: is_member,
                     out_dir,
+                    deps,
                 });
             }
         }
@@ -128,4 +132,23 @@ impl Workspace {
             .filter(|c| normalize(&c.name) == norm)
             .collect()
     }
+
+    /// Names of all workspace member crates.
+    pub fn member_names(&self) -> Vec<&str> {
+        self.crates
+            .iter()
+            .filter(|c| c.is_workspace_member)
+            .map(|c| c.name.as_str())
+            .collect()
+    }
+
+    /// Workspace members that are not already dependencies of `crate_name`.
+    pub fn available_members(&self, crate_name: &str, deps: &[String]) -> Vec<String> {
+        let dep_set: HashSet<String> = deps.iter().map(|s| normalize(s)).collect();
+        self.member_names()
+            .into_iter()
+            .filter(|&m| m != crate_name && !dep_set.contains(&normalize(m)))
+            .map(|m| m.to_string())
+            .collect()
+    }
 }