Refactor: deduplicate review orchestration, add concurrent LLM calls, fix all clippy warnings

- Extract shared review helpers into state.rs (ReviewEventBuilder, progress callbacks,
  mark_running/complete_review/fail_review, ~200 lines removed from api.rs/github.rs)
- Add concurrent per-file LLM calls via futures::buffer_unordered(5) in pipeline.rs
- Add CliOverrides struct to replace 16-param apply_cli_overrides
- Add WebhookReviewParams struct to fix too_many_arguments in github.rs
- Add Display + as_str() for Severity/Category enums, replace Debug formatting
- Add ReviewListItem for lightweight list endpoint
- Add review_semaphore (tokio::Semaphore) for rate limiting concurrent reviews
- Use url::Url::parse for Ollama port detection instead of string contains
- Use HashSet for O(1) symbol deduplication in extract_symbols_from_diff
- Return JoinHandle from save_reviews_async/save_config_async
- Simplify boolean expression (is_none_or) and fix all map_or → is_some_and
- Fix all dead_code warnings (model_name, resolve_provider, as_str, title)
- 579 tests passing, 0 clippy warnings

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: haasonsaas

Cargo.lock

@@ -40,6 +40,7 @@ hmac = "0.12"
 sha2 = "0.10"
 jsonwebtoken = "9"
 base64 = "0.22"
+futures = "0.3"
 
 [dev-dependencies]
 tempfile = "3.8"

Cargo.toml

@@ -143,7 +143,7 @@ impl LLMAdapter for AnthropicAdapter {
         })
     }
 
-    fn _model_name(&self) -> &str {
+    fn model_name(&self) -> &str {
         &self.config.model_name
     }
 }
@@ -371,10 +371,10 @@ mod tests {
     }
 
     #[test]
-    fn test_model_name() {
+    fn testmodel_name() {
         let config = test_config("http://localhost:8080");
         let adapter = AnthropicAdapter::new(config).unwrap();
-        assert_eq!(adapter._model_name(), "claude-3-5-sonnet-20241022");
+        assert_eq!(adapter.model_name(), "claude-3-5-sonnet-20241022");
     }
 
     #[tokio::test]

src/adapters/anthropic.rs

@@ -65,7 +65,17 @@ pub struct Usage {
 #[async_trait]
 pub trait LLMAdapter: Send + Sync {
     async fn complete(&self, request: LLMRequest) -> Result<LLMResponse>;
-    fn _model_name(&self) -> &str;
+    #[allow(dead_code)]
+    fn model_name(&self) -> &str;
+}
+
+/// Check if a base URL points to an Ollama instance by parsing the port.
+fn is_ollama_url(base_url: &Option<String>) -> bool {
+    base_url.as_ref().is_some_and(|u| {
+        url::Url::parse(u)
+            .map(|parsed| parsed.port() == Some(11434))
+            .unwrap_or(false)
+    })
 }
 
 pub fn create_adapter(config: &ModelConfig) -> Result<Box<dyn LLMAdapter>> {
@@ -118,12 +128,7 @@ pub fn create_adapter(config: &ModelConfig) -> Result<Box<dyn LLMAdapter>> {
         name if name.starts_with("ollama:") => {
             Ok(Box::new(crate::adapters::OllamaAdapter::new(config)?))
         }
-        _name
-            if config
-                .base_url
-                .as_ref()
-                .is_some_and(|u| u.contains("11434")) =>
-        {
+        _name if is_ollama_url(&config.base_url) => {
             Ok(Box::new(crate::adapters::OllamaAdapter::new(config)?))
         }
         // Default to OpenAI for unknown models
@@ -149,42 +154,42 @@ mod tests {
     fn test_create_adapter_claude_dash_prefix() {
         let config = local_config("claude-3-5-sonnet-20241022");
         let adapter = create_adapter(&config).unwrap();
-        assert_eq!(adapter._model_name(), "claude-3-5-sonnet-20241022");
+        assert_eq!(adapter.model_name(), "claude-3-5-sonnet-20241022");
     }
 
     #[test]
     fn test_create_adapter_claude_legacy_prefix() {
         let config = local_config("claude3sonnet");
         let adapter = create_adapter(&config).unwrap();
-        assert_eq!(adapter._model_name(), "claude3sonnet");
+        assert_eq!(adapter.model_name(), "claude3sonnet");
     }
 
     #[test]
     fn test_create_adapter_gpt() {
         let config = local_config("gpt-4o");
         let adapter = create_adapter(&config).unwrap();
-        assert_eq!(adapter._model_name(), "gpt-4o");
+        assert_eq!(adapter.model_name(), "gpt-4o");
     }
 
     #[test]
     fn test_create_adapter_gpt35() {
         let config = local_config("gpt-3.5-turbo");
         let adapter = create_adapter(&config).unwrap();
-        assert_eq!(adapter._model_name(), "gpt-3.5-turbo");
+        assert_eq!(adapter.model_name(), "gpt-3.5-turbo");
     }
 
     #[test]
     fn test_create_adapter_o1() {
         let config = local_config("o1-preview");
         let adapter = create_adapter(&config).unwrap();
-        assert_eq!(adapter._model_name(), "o1-preview");
+        assert_eq!(adapter.model_name(), "o1-preview");
     }
 
     #[test]
     fn test_create_adapter_ollama_prefix() {
         let config = local_config("ollama:codellama");
         let adapter = create_adapter(&config).unwrap();
-        assert_eq!(adapter._model_name(), "ollama:codellama");
+        assert_eq!(adapter.model_name(), "ollama:codellama");
     }
 
     #[test]
@@ -196,15 +201,15 @@ mod tests {
             ..Default::default()
         };
         let adapter = create_adapter(&config).unwrap();
-        assert_eq!(adapter._model_name(), "codellama");
+        assert_eq!(adapter.model_name(), "codellama");
     }
 
     #[test]
     fn test_create_adapter_default_unknown_model() {
         // Unknown model name with a local base_url should default to OpenAI adapter
         let config = local_config("some-custom-model");
         let adapter = create_adapter(&config).unwrap();
-        assert_eq!(adapter._model_name(), "some-custom-model");
+        assert_eq!(adapter.model_name(), "some-custom-model");
     }
 
     #[test]
@@ -218,7 +223,7 @@ mod tests {
         };
         // Even though model_name says "gpt-4o", the override should pick Anthropic
         let adapter = create_adapter(&config).unwrap();
-        assert_eq!(adapter._model_name(), "gpt-4o");
+        assert_eq!(adapter.model_name(), "gpt-4o");
     }
 
     #[test]
@@ -231,7 +236,7 @@ mod tests {
             ..Default::default()
         };
         let adapter = create_adapter(&config).unwrap();
-        assert_eq!(adapter._model_name(), "my-model");
+        assert_eq!(adapter.model_name(), "my-model");
     }
 
     #[test]
@@ -245,7 +250,7 @@ mod tests {
         };
         // Even though model_name says "claude-*", the override should pick OpenAI
         let adapter = create_adapter(&config).unwrap();
-        assert_eq!(adapter._model_name(), "claude-3-5-sonnet-20241022");
+        assert_eq!(adapter.model_name(), "claude-3-5-sonnet-20241022");
     }
 
     #[test]
@@ -259,7 +264,46 @@ mod tests {
         };
         // Unknown adapter override should default to OpenAI
         let adapter = create_adapter(&config).unwrap();
-        assert_eq!(adapter._model_name(), "my-model");
+        assert_eq!(adapter.model_name(), "my-model");
+    }
+
+    #[test]
+    fn test_create_adapter_ollama_by_standard_url() {
+        // Should detect Ollama from standard localhost:11434 URL
+        let config = ModelConfig {
+            model_name: "codellama".to_string(),
+            api_key: None,
+            base_url: Some("http://localhost:11434".to_string()),
+            ..Default::default()
+        };
+        let adapter = create_adapter(&config).unwrap();
+        assert_eq!(adapter.model_name(), "codellama");
+    }
+
+    #[test]
+    fn test_create_adapter_ollama_by_url_with_path() {
+        // Should detect Ollama even with trailing path
+        let config = ModelConfig {
+            model_name: "codellama".to_string(),
+            api_key: None,
+            base_url: Some("http://my-server:11434/api".to_string()),
+            ..Default::default()
+        };
+        let adapter = create_adapter(&config).unwrap();
+        assert_eq!(adapter.model_name(), "codellama");
+    }
+
+    #[test]
+    fn test_create_adapter_port_in_path_not_detected_as_ollama() {
+        // A URL like http://proxy.example.com/service/11434 should NOT trigger Ollama
+        let config = ModelConfig {
+            model_name: "my-model".to_string(),
+            api_key: Some("test-key".to_string()),
+            base_url: Some("http://proxy.example.com/service/11434".to_string()),
+            ..Default::default()
+        };
+        // Should default to OpenAI, not Ollama
+        let _adapter = create_adapter(&config).unwrap();
     }
 
     #[test]

src/adapters/llm.rs

@@ -225,7 +225,7 @@ impl LLMAdapter for OllamaAdapter {
         })
     }
 
-    fn _model_name(&self) -> &str {
+    fn model_name(&self) -> &str {
         &self.config.model_name
     }
 }
@@ -458,17 +458,17 @@ mod tests {
     }
 
     #[test]
-    fn test_model_name_with_prefix() {
+    fn testmodel_name_with_prefix() {
         let config = test_config("http://localhost:11434", "ollama:codellama");
         let adapter = OllamaAdapter::new(config).unwrap();
-        assert_eq!(adapter._model_name(), "ollama:codellama");
+        assert_eq!(adapter.model_name(), "ollama:codellama");
     }
 
     #[test]
-    fn test_model_name_without_prefix() {
+    fn testmodel_name_without_prefix() {
         let config = test_config("http://localhost:11434", "codellama");
         let adapter = OllamaAdapter::new(config).unwrap();
-        assert_eq!(adapter._model_name(), "codellama");
+        assert_eq!(adapter.model_name(), "codellama");
     }
 
     // ---- Chat message construction tests ----
@@ -758,14 +758,14 @@ mod tests {
     // ---- model_name_bare tests ----
 
     #[test]
-    fn test_model_name_bare_with_prefix() {
+    fn testmodel_name_bare_with_prefix() {
         let config = test_config("http://localhost:11434", "ollama:deepseek-coder");
         let adapter = OllamaAdapter::new(config).unwrap();
         assert_eq!(adapter.model_name_bare(), "deepseek-coder");
     }
 
     #[test]
-    fn test_model_name_bare_without_prefix() {
+    fn testmodel_name_bare_without_prefix() {
         let config = test_config("http://localhost:11434", "deepseek-coder");
         let adapter = OllamaAdapter::new(config).unwrap();
         assert_eq!(adapter.model_name_bare(), "deepseek-coder");

src/adapters/ollama.rs

@@ -138,7 +138,7 @@ impl LLMAdapter for OpenAIAdapter {
         self.complete_chat_completions(request).await
     }
 
-    fn _model_name(&self) -> &str {
+    fn model_name(&self) -> &str {
         &self.config.model_name
     }
 }
@@ -579,10 +579,10 @@ mod tests {
     }
 
     #[test]
-    fn test_model_name() {
+    fn testmodel_name() {
         let config = test_config("http://localhost:8080");
         let adapter = OpenAIAdapter::new(config).unwrap();
-        assert_eq!(adapter._model_name(), "gpt-4o");
+        assert_eq!(adapter.model_name(), "gpt-4o");
     }
 
     #[tokio::test]

src/adapters/openai.rs

@@ -779,13 +779,13 @@ impl EvalPattern {
         }
 
         if let Some(severity) = &self.severity {
-            if !format!("{:?}", comment.severity).eq_ignore_ascii_case(severity.trim()) {
+            if !comment.severity.to_string().eq_ignore_ascii_case(severity.trim()) {
                 return false;
             }
         }
 
         if let Some(category) = &self.category {
-            if !format!("{:?}", comment.category).eq_ignore_ascii_case(category.trim()) {
+            if !comment.category.to_string().eq_ignore_ascii_case(category.trim()) {
                 return false;
             }
         }

src/commands/eval.rs

@@ -500,7 +500,7 @@ async fn answer_discussion_question(
     let mut prompt = String::new();
     prompt.push_str("Review comment context:\n");
     prompt.push_str(&format!(
-        "- id: {}\n- file: {}\n- line: {}\n- severity: {:?}\n- category: {:?}\n- confidence: {:.0}%\n- comment: {}\n",
+        "- id: {}\n- file: {}\n- line: {}\n- severity: {}\n- category: {}\n- confidence: {:.0}%\n- comment: {}\n",
         comment.id,
         comment.file_path.display(),
         comment.line_number,

src/commands/misc.rs

@@ -194,7 +194,7 @@ pub async fn review_command(
             if let Some(pc) = path_config {
                 for comment in &mut comments {
                     for (category, severity) in &pc.severity_overrides {
-                        if format!("{:?}", comment.category).to_lowercase()
+                        if comment.category.as_str()
                             == category.to_lowercase()
                         {
                             comment.severity = match severity.to_lowercase().as_str() {