fix: Fix CI workflow failures - formatting and test compilation errors

snowmead · claude · snowmead · commit d42f8dd70bfc · 2025-11-24T07:52:15.000-05:00
- Run cargo fmt --all to fix formatting issues across multiple files - Fix test_user_agent_set: add missing None parameter to download_crate call - Fix test_problematic_crate_download: add missing None parameter to download_crate call Resolves CI failures in both Check and Lint job (formatting) and Unit Tests job (compilation errors). 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
diff --git a/rust-docs-mcp/src/cache/docgen.rs b/rust-docs-mcp/src/cache/docgen.rs
@@ -41,7 +41,12 @@ impl DocGenerator {
     }
 
     /// Generate documentation for a crate
-    pub async fn generate_docs(&self, name: &str, version: &str, progress_callback: Option<ProgressCallback>) -> Result<PathBuf> {
+    pub async fn generate_docs(
+        &self,
+        name: &str,
+        version: &str,
+        progress_callback: Option<ProgressCallback>,
+    ) -> Result<PathBuf> {
         tracing::info!(
             "DocGenerator::generate_docs starting for {}-{}",
             name,
diff --git a/rust-docs-mcp/src/cache/downloader.rs b/rust-docs-mcp/src/cache/downloader.rs
@@ -115,7 +115,12 @@ impl CrateDownloader {
     }
 
     /// Download a crate from crates.io
-    async fn download_crate(&self, name: &str, version: &str, progress_callback: Option<ProgressCallback>) -> Result<PathBuf> {
+    async fn download_crate(
+        &self,
+        name: &str,
+        version: &str,
+        progress_callback: Option<ProgressCallback>,
+    ) -> Result<PathBuf> {
         // Check if already cached
         if self.storage.is_cached(name, version) {
             tracing::info!("Crate {}-{} already cached", name, version);
@@ -582,7 +587,7 @@ mod tests {
 
         // Test that download doesn't fail with 403
         // Note: This is an integration test that requires internet access
-        match downloader.download_crate("serde", "1.0.0").await {
+        match downloader.download_crate("serde", "1.0.0", None).await {
             Ok(path) => {
                 assert!(path.exists());
                 println!("Successfully downloaded crate to: {path:?}");
@@ -608,7 +613,7 @@ mod tests {
         let downloader = CrateDownloader::new(storage);
 
         match downloader
-            .download_crate("google-sheets4", "6.0.0+20240621")
+            .download_crate("google-sheets4", "6.0.0+20240621", None)
             .await
         {
             Ok(path) => {
diff --git a/rust-docs-mcp/src/cache/service.rs b/rust-docs-mcp/src/cache/service.rs
@@ -54,7 +54,8 @@ impl CrateCache {
         // Check if crate is downloaded but docs not generated
         if !self.storage.is_cached(name, version) {
             tracing::info!("Crate {}-{} not cached, downloading", name, version);
-            self.download_or_copy_crate(name, version, source, None).await?;
+            self.download_or_copy_crate(name, version, source, None)
+                .await?;
         } else {
             tracing::info!(
                 "Crate {}-{} already cached, skipping download",
@@ -144,7 +145,8 @@ impl CrateCache {
 
         // Check if crate is downloaded
         if !self.storage.is_cached(name, version) {
-            self.download_or_copy_crate(name, version, source, None).await?;
+            self.download_or_copy_crate(name, version, source, None)
+                .await?;
         }
 
         // Generate documentation for the specific workspace member
@@ -230,8 +232,15 @@ impl CrateCache {
     }
 
     /// Generate JSON documentation for a crate
-    pub async fn generate_docs(&self, name: &str, version: &str, progress_callback: Option<crate::cache::downloader::ProgressCallback>) -> Result<PathBuf> {
-        self.doc_generator.generate_docs(name, version, progress_callback).await
+    pub async fn generate_docs(
+        &self,
+        name: &str,
+        version: &str,
+        progress_callback: Option<crate::cache::downloader::ProgressCallback>,
+    ) -> Result<PathBuf> {
+        self.doc_generator
+            .generate_docs(name, version, progress_callback)
+            .await
     }
 
     /// Generate JSON documentation for a workspace member
@@ -332,7 +341,8 @@ impl CrateCache {
     ) -> Result<PathBuf> {
         // Check if crate is already downloaded
         if !self.storage.is_cached(name, version) {
-            self.download_or_copy_crate(name, version, source, None).await?;
+            self.download_or_copy_crate(name, version, source, None)
+                .await?;
         }
 
         self.storage.source_path(name, version)
@@ -819,27 +829,39 @@ impl CrateCache {
             // It's a workspace, get the members and return workspace response
             match WorkspaceHandler::get_workspace_members(&cargo_toml_path) {
                 Ok(members) => {
-                    let response = self.generate_workspace_response(&crate_name, &version, members, &source, false);
+                    let response = self.generate_workspace_response(
+                        &crate_name,
+                        &version,
+                        members,
+                        &source,
+                        false,
+                    );
                     return response.to_json();
                 }
                 Err(e) => {
-                    return CacheResponse::error(format!("Failed to get workspace members: {e}")).to_json();
+                    return CacheResponse::error(format!("Failed to get workspace members: {e}"))
+                        .to_json();
                 }
             }
         }
 
         // Not a workspace - generate docs
         // Update to doc generation stage
         if let (Some(tm), Some(tid)) = (&task_manager, &task_id) {
-            tm.update_stage(tid, crate::cache::task_manager::CachingStage::GeneratingDocs).await;
+            tm.update_stage(
+                tid,
+                crate::cache::task_manager::CachingStage::GeneratingDocs,
+            )
+            .await;
             tm.update_step(tid, 1, "Running cargo rustdoc").await;
         }
 
         match self.generate_docs(&crate_name, &version, None).await {
             Ok(_) => {
                 // Update to indexing stage
                 if let (Some(tm), Some(tid)) = (&task_manager, &task_id) {
-                    tm.update_stage(tid, crate::cache::task_manager::CachingStage::Indexing).await;
+                    tm.update_stage(tid, crate::cache::task_manager::CachingStage::Indexing)
+                        .await;
                     tm.update_step(tid, 1, "Creating search index").await;
                 }
 
diff --git a/rust-docs-mcp/src/cache/task_formatter.rs b/rust-docs-mcp/src/cache/task_formatter.rs
@@ -80,7 +80,9 @@ pub fn format_single_task(task: &CachingTask) -> String {
             let stage_info = if let Some(stage) = &task.stage {
                 let step_str = if let Some(step) = task.current_step {
                     let total = stage.total_steps();
-                    let desc = task.step_description.as_ref()
+                    let desc = task
+                        .step_description
+                        .as_ref()
                         .map(|d| format!(": {}", d))
                         .unwrap_or_default();
                     format!("\n**Step**: {} of {}{}", step, total, desc)
@@ -263,7 +265,8 @@ pub fn format_task_list(tasks: Vec<CachingTask>) -> String {
         }
     }
 
-    let total = in_progress.len() + completed.len() + failed.len() + cancelled.len() + pending.len();
+    let total =
+        in_progress.len() + completed.len() + failed.len() + cancelled.len() + pending.len();
 
     // Build summary
     let mut output = String::from("# Caching Operations\n\n");
@@ -339,7 +342,9 @@ pub fn format_task_list(tasks: Vec<CachingTask>) -> String {
         output.push_str("- **Cancel tasks**: Use `cache_operations` with task_id and cancel: true for each task\n");
     }
     if !completed.is_empty() || !failed.is_empty() || !cancelled.is_empty() {
-        output.push_str("- **Clear all completed/failed/cancelled**: `cache_operations({clear: true})`\n");
+        output.push_str(
+            "- **Clear all completed/failed/cancelled**: `cache_operations({clear: true})`\n",
+        );
     }
 
     output
@@ -355,7 +360,12 @@ fn format_task_summary(task: &CachingTask) -> String {
 
     let mut output = format!(
         "### Task: `{}`\n**Crate**: {}-{}  \n**Source**: {}{}  \n**Status**: {}  \n",
-        task.task_id, task.crate_name, task.version, task.source_type, source_info, task.status.display()
+        task.task_id,
+        task.crate_name,
+        task.version,
+        task.source_type,
+        source_info,
+        task.status.display()
     );
 
     match task.status {
@@ -365,30 +375,59 @@ fn format_task_summary(task: &CachingTask) -> String {
 
                 if let Some(step) = task.current_step {
                     let total = stage.total_steps();
-                    let desc = task.step_description.as_ref()
+                    let desc = task
+                        .step_description
+                        .as_ref()
                         .map(|d| format!(": {}", d))
                         .unwrap_or_default();
                     output.push_str(&format!("**Step**: {} of {}{}  \n", step, total, desc));
                 }
             }
-            output.push_str(&format!("**Started**: {}  \n", format_timestamp(task.started_at)));
-            output.push_str(&format!("**Elapsed**: {}\n\n", format_duration(task.elapsed_secs())));
+            output.push_str(&format!(
+                "**Started**: {}  \n",
+                format_timestamp(task.started_at)
+            ));
+            output.push_str(&format!(
+                "**Elapsed**: {}\n\n",
+                format_duration(task.elapsed_secs())
+            ));
             output.push_str("**Actions**:\n");
-            output.push_str(&format!("- Cancel: `cache_operations({{task_id: \"{}\", cancel: true}})`\n", task.task_id));
+            output.push_str(&format!(
+                "- Cancel: `cache_operations({{task_id: \"{}\", cancel: true}})`\n",
+                task.task_id
+            ));
         }
         TaskStatus::Pending => {
-            output.push_str(&format!("**Started**: {}  \n", format_timestamp(task.started_at)));
+            output.push_str(&format!(
+                "**Started**: {}  \n",
+                format_timestamp(task.started_at)
+            ));
             output.push_str("\n**Actions**:\n");
-            output.push_str(&format!("- Cancel: `cache_operations({{task_id: \"{}\", cancel: true}})`\n", task.task_id));
+            output.push_str(&format!(
+                "- Cancel: `cache_operations({{task_id: \"{}\", cancel: true}})`\n",
+                task.task_id
+            ));
         }
         TaskStatus::Completed => {
-            output.push_str(&format!("**Duration**: {}  \n", format_duration(task.elapsed_secs())));
-            output.push_str(&format!("**Completed**: {}\n\n", format_timestamp(task.completed_at.unwrap_or(task.started_at))));
+            output.push_str(&format!(
+                "**Duration**: {}  \n",
+                format_duration(task.elapsed_secs())
+            ));
+            output.push_str(&format!(
+                "**Completed**: {}\n\n",
+                format_timestamp(task.completed_at.unwrap_or(task.started_at))
+            ));
             output.push_str("**Actions**:\n");
-            output.push_str(&format!("- Clear: `cache_operations({{task_id: \"{}\", clear: true}})`\n", task.task_id));
+            output.push_str(&format!(
+                "- Clear: `cache_operations({{task_id: \"{}\", clear: true}})`\n",
+                task.task_id
+            ));
         }
         TaskStatus::Failed => {
-            output.push_str(&format!("**Duration**: {}  \n", format_duration(task.elapsed_secs())));
+            output.push_str(&format!(
+                "**Duration**: {}  \n",
+                format_duration(task.elapsed_secs())
+            ));
             if let Some(error) = &task.error {
                 // Truncate long errors for list view
                 let error_preview = if error.len() > 100 {
@@ -399,14 +438,29 @@ fn format_task_summary(task: &CachingTask) -> String {
                 output.push_str(&format!("**Error**: {}\n\n", error_preview));
             }
             output.push_str("**Actions**:\n");
-            output.push_str(&format!("- View details: `cache_operations({{task_id: \"{}\"}})`\n", task.task_id));
-            output.push_str(&format!("- Clear: `cache_operations({{task_id: \"{}\", clear: true}})`\n", task.task_id));
+            output.push_str(&format!(
+                "- View details: `cache_operations({{task_id: \"{}\"}})`\n",
+                task.task_id
+            ));
+            output.push_str(&format!(
+                "- Clear: `cache_operations({{task_id: \"{}\", clear: true}})`\n",
+                task.task_id
+            ));
         }
         TaskStatus::Cancelled => {
-            output.push_str(&format!("**Duration**: {}  \n", format_duration(task.elapsed_secs())));
-            output.push_str(&format!("**Cancelled**: {}\n\n", format_timestamp(task.completed_at.unwrap_or(task.started_at))));
+            output.push_str(&format!(
+                "**Duration**: {}  \n",
+                format_duration(task.elapsed_secs())
+            ));
+            output.push_str(&format!(
+                "**Cancelled**: {}\n\n",
+                format_timestamp(task.completed_at.unwrap_or(task.started_at))
+            ));
             output.push_str("**Actions**:\n");
-            output.push_str(&format!("- Clear: `cache_operations({{task_id: \"{}\", clear: true}})`\n", task.task_id));
+            output.push_str(&format!(
+                "- Clear: `cache_operations({{task_id: \"{}\", clear: true}})`\n",
+                task.task_id
+            ));
         }
     }
 
@@ -434,7 +488,10 @@ pub fn format_clear_result(tasks: Vec<CachingTask>) -> String {
     }
 
     let mut output = String::from("# Tasks Cleared\n\n");
-    output.push_str(&format!("Successfully cleared {} task(s) from memory:\n\n", tasks.len()));
+    output.push_str(&format!(
+        "Successfully cleared {} task(s) from memory:\n\n",
+        tasks.len()
+    ));
 
     for task in tasks {
         let status_str = match task.status {
diff --git a/rust-docs-mcp/src/cache/task_manager.rs b/rust-docs-mcp/src/cache/task_manager.rs
@@ -89,10 +89,10 @@ impl CachingStage {
     /// Get total number of steps for this stage
     pub fn total_steps(&self) -> u8 {
         match self {
-            CachingStage::Downloading => 1,     // Single step: download
-            CachingStage::GeneratingDocs => 2,  // 1. Run rustdoc, 2. Save docs
-            CachingStage::Indexing => 3,        // 1. Load docs, 2. Create index, 3. Commit
-            CachingStage::Completed => 1,       // Single step: complete
+            CachingStage::Downloading => 1,    // Single step: download
+            CachingStage::GeneratingDocs => 2, // 1. Run rustdoc, 2. Save docs
+            CachingStage::Indexing => 3,       // 1. Load docs, 2. Create index, 3. Commit
+            CachingStage::Completed => 1,      // Single step: complete
         }
     }
 }
@@ -277,7 +277,12 @@ impl TaskManager {
     }
 
     /// Update task step
-    pub async fn update_step(&self, task_id: &str, step: u8, description: impl Into<String>) -> bool {
+    pub async fn update_step(
+        &self,
+        task_id: &str,
+        step: u8,
+        description: impl Into<String>,
+    ) -> bool {
         if let Some(mut task) = self.tasks.get_mut(task_id) {
             task.set_step(step, description);
             true
diff --git a/rust-docs-mcp/src/cache/tools.rs b/rust-docs-mcp/src/cache/tools.rs
diff --git a/rust-docs-mcp/tests/integration_tests.rs b/rust-docs-mcp/tests/integration_tests.rs
