refactor: Remove unused detect_and_handle_workspace and cache_regular_crate methods

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: snowmead

rust-docs-mcp/src/cache/service.rs

@@ -623,103 +623,6 @@ impl CrateCache {
             .await
     }
 
-    /// Detect and handle workspace crates
-    async fn detect_and_handle_workspace(
-        &self,
-        crate_name: &str,
-        version: &str,
-        source_path: &std::path::Path,
-        source: &CrateSource,
-        source_str: Option<&str>,
-        updated: bool,
-    ) -> Result<CacheResponse> {
-        let cargo_toml_path = source_path.join("Cargo.toml");
-
-        tracing::info!(
-            "detect_and_handle_workspace: checking {}",
-            cargo_toml_path.display()
-        );
-
-        // Read and log the content to debug workspace detection
-        if let Ok(content) = std::fs::read_to_string(&cargo_toml_path) {
-            tracing::info!(
-                "detect_and_handle_workspace: Cargo.toml content preview for {}: {}",
-                crate_name,
-                &content[0..content.len().min(500)]
-            );
-        }
-
-        match WorkspaceHandler::is_workspace(&cargo_toml_path) {
-            Ok(true) => {
-                tracing::info!("detect_and_handle_workspace: {} is a workspace", crate_name);
-                // It's a workspace, get the members
-                let members = WorkspaceHandler::get_workspace_members(&cargo_toml_path)
-                    .context("Failed to get workspace members")?;
-                Ok(self.generate_workspace_response(crate_name, version, members, source, updated))
-            }
-            Ok(false) => {
-                tracing::info!(
-                    "detect_and_handle_workspace: {} is NOT a workspace",
-                    crate_name
-                );
-                // Not a workspace, proceed with normal caching
-                self.cache_regular_crate(crate_name, version, source_str)
-                    .await
-            }
-            Err(e) => {
-                tracing::warn!(
-                    "detect_and_handle_workspace: error checking workspace status for {}: {}",
-                    crate_name,
-                    e
-                );
-                // Error checking workspace status - try to determine if it's likely a workspace
-                // by checking for common workspace indicators to avoid attempting doc generation
-                // on workspace roots
-                let cargo_content = match std::fs::read_to_string(&cargo_toml_path) {
-                    Ok(content) => content,
-                    Err(_) => {
-                        // Can't read Cargo.toml, fall back to normal caching
-                        return self
-                            .cache_regular_crate(crate_name, version, source_str)
-                            .await;
-                    }
-                };
-
-                // Check for workspace indicators even if parsing failed
-                if cargo_content.contains("[workspace]") && cargo_content.contains("members") {
-                    tracing::warn!(
-                        "detect_and_handle_workspace: {} appears to be a workspace based on content analysis, \
-                        but parsing failed. Treating as workspace to avoid doc generation errors",
-                        crate_name
-                    );
-
-                    // Return a generic workspace response indicating we couldn't parse the members
-                    let error_msg = format!(
-                        "Detected workspace but failed to parse members: {e}. \
-                        Please check the Cargo.toml syntax or cache specific members manually."
-                    );
-                    Ok(CacheResponse::error(error_msg))
-                } else {
-                    // Doesn't look like a workspace, try normal caching
-                    self.cache_regular_crate(crate_name, version, source_str)
-                        .await
-                }
-            }
-        }
-    }
-
-    /// Cache a regular (non-workspace) crate
-    async fn cache_regular_crate(
-        &self,
-        crate_name: &str,
-        version: &str,
-        source_str: Option<&str>,
-    ) -> Result<CacheResponse> {
-        self.ensure_crate_docs(crate_name, version, source_str)
-            .await?;
-        Ok(CacheResponse::success(crate_name, version))
-    }
-
     /// Resolve version for local paths
     async fn resolve_local_path_version(
         &self,