checkpoint 1, broken

Author: elasticdotventures

README.md

@@ -189,47 +189,38 @@ in `mcp_settings.json`
 ```
 
 
-## License
-
-MIT License
 
-## MCP Tool: `list_crate_items`
+### 4. `list_crate_items`
 
-The `list_crate_items` tool enumerates all items in a specified Rust crate and version, optionally filtering by item type, visibility, or module path. This is useful for quickly exploring the structure of a crate, generating concise listings for LLMs, or programmatically analyzing crate APIs.
+Enumerates all items in a specified Rust crate and version, optionally filtering by item type, visibility, or module path. Useful for exploring crate structure, generating concise listings for LLMs, or programmatically analyzing crate APIs.
 
-### Usage
+**Parameters:**
+- `crate_name` (required): The name of the crate
+- `version` (required): The version of the crate
+- `item_type` (optional): Filter by item type (struct, enum, trait, fn, macro, mod)
+- `visibility` (optional): Filter by visibility (pub, private)
+- `module` (optional): Filter by module path (e.g., serde::de)
 
-```sh
-cargo run --bin cratedocs -- list-crate-items --crate-name serde --version 1.0.0
+**Example:**
+```json
+{
+  "name": "list_crate_items",
+  "arguments": {
+    "crate_name": "serde",
+    "version": "1.0.0",
+    "item_type": "struct"
+  }
+}
 ```
 
-#### With filters:
-
-- Filter by item type (e.g., struct, enum, trait, fn, macro, mod):
-
-  ```sh
-  cargo run --bin cratedocs -- list-crate-items --crate-name serde --version 1.0.0 --item-type struct
-  ```
-
-- Filter by visibility (e.g., pub, private):
-
-  ```sh
-  cargo run --bin cratedocs -- list-crate-items --crate-name serde --version 1.0.0 --visibility pub
-  ```
-
-- Filter by module path:
-
-  ```sh
-  cargo run --bin cratedocs -- list-crate-items --crate-name serde --version 1.0.0 --module serde::de
-  ```
-
-### Output
-
-The output is a concise, categorized list (JSON or markdown) showing each item's name, type, visibility, and module path.
-
-**Example (stub output):**
+**Example Output (stub):**
 ```
 Stub: list_crate_items for crate: serde, version: 1.0.0, filters: Some(ItemListFilters { item_type: Some("struct"), visibility: None, module: None })
 ```
 
 When implemented, the output will be a structured list of items matching the filters.
+
+
+## License
+
+MIT License

src/bin/cratedocs.rs

@@ -84,24 +84,6 @@ enum Commands {
         #[arg(short, long)]
         debug: bool,
     },
-    /// List all items in a crate (using rust-analyzer)
-    ListCrateItems {
-        /// Crate name (e.g., serde)
-        #[arg(long)]
-        crate_name: String,
-        /// Crate version (e.g., 1.0.0)
-        #[arg(long)]
-        version: String,
-        /// Filter by item type (struct, enum, trait, fn, macro, mod)
-        #[arg(long)]
-        item_type: Option<String>,
-        /// Filter by visibility (pub, private)
-        #[arg(long)]
-        visibility: Option<String>,
-        /// Filter by module path (e.g., serde::de)
-        #[arg(long)]
-        module: Option<String>,
-    },
 }
 
 #[tokio::main]
@@ -136,23 +118,6 @@ async fn main() -> Result<()> {
             max_tokens,
             debug
         }).await,
-        Commands::ListCrateItems {
-            crate_name,
-            version,
-            item_type,
-            visibility,
-            module,
-        } => {
-            use cratedocs_mcp::tools::item_list::{list_crate_items, ItemListFilters};
-            let filters = ItemListFilters {
-                item_type,
-                visibility,
-                module,
-            };
-            let result = list_crate_items(&crate_name, &version, Some(filters)).await?;
-            println!("{}", result);
-            Ok(())
-        }
     }
 }
 

src/tools/docs/docs.rs

@@ -1,3 +1,4 @@
+use crate::tools::item_list;
 use std::{future::Future, pin::Pin, sync::Arc};
 
 use mcp_core::{
@@ -321,6 +322,36 @@ impl mcp_server::Router for DocRouter {
                     "required": ["crate_name", "item_path"]
                 }),
             ),
+            Tool::new(
+                "list_crate_items".to_string(),
+                "Enumerate all items in a Rust crate (optionally filtered by type, visibility, or module). Returns a concise, categorized list.".to_string(),
+                json!({
+                    "type": "object",
+                    "properties": {
+                        "crate_name": {
+                            "type": "string",
+                            "description": "The name of the crate"
+                        },
+                        "version": {
+                            "type": "string",
+                            "description": "The version of the crate"
+                        },
+                        "item_type": {
+                            "type": "string",
+                            "description": "Filter by item type (struct, enum, trait, fn, macro, mod)"
+                        },
+                        "visibility": {
+                            "type": "string",
+                            "description": "Filter by visibility (pub, private)"
+                        },
+                        "module": {
+                            "type": "string",
+                            "description": "Filter by module path (e.g., serde::de)"
+                        }
+                    },
+                    "required": ["crate_name", "version"]
+                }),
+            ),
         ]
     }
 
@@ -386,6 +417,43 @@ impl mcp_server::Router for DocRouter {
                     let doc = this.lookup_item(crate_name, item_path, version).await?;
                     Ok(vec![Content::text(doc)])
                 }
+                "list_crate_items" => {
+                    let crate_name = arguments
+                        .get("crate_name")
+                        .and_then(|v| v.as_str())
+                        .ok_or_else(|| ToolError::InvalidParameters("crate_name is required".to_string()))?
+                        .to_string();
+                    let version = arguments
+                        .get("version")
+                        .and_then(|v| v.as_str())
+                        .ok_or_else(|| ToolError::InvalidParameters("version is required".to_string()))?
+                        .to_string();
+                    let item_type = arguments
+                        .get("item_type")
+                        .and_then(|v| v.as_str())
+                        .map(|s| s.to_string());
+                    let visibility = arguments
+                        .get("visibility")
+                        .and_then(|v| v.as_str())
+                        .map(|s| s.to_string());
+                    let module = arguments
+                        .get("module")
+                        .and_then(|v| v.as_str())
+                        .map(|s| s.to_string());
+                    let filters = cratedocs_mcp::tools::item_list::ItemListFilters {
+                        item_type,
+                        visibility,
+                        module,
+                    };
+                    let result = cratedocs_mcp::tools::item_list::list_crate_items(
+                        &crate_name,
+                        &version,
+                        Some(filters),
+                    )
+                    .await
+                    .map_err(|e| ToolError::ExecutionError(format!("list_crate_items failed: {}", e)))?;
+                    Ok(vec![Content::text(result)])
+                }
                 _ => Err(ToolError::NotFound(format!("Tool {} not found", tool_name))),
             }
         })