refactor(complexity): [3.1] Reduce code complexity in model detector

- Split detectOllamaModels into smaller functions: parseOllamaResponse, convertOllamaModels
- Extract ollamaResponse and ollamaModel struct definitions for better organization
- Split detectCloudModels into detectOpenAIModels and detectAnthropicModels
- Refactor GetDefaultModel into selectBestModel and findModelByProvider helper functions
- Reduce cyclomatic complexity from 29 to acceptable levels
- Maintain all existing functionality while improving code maintainability
- All tests pass with 83.1% coverage

Task: 3.1 - Optimize model detector code complexity
Phase: Refactoring

Author: KariHall619

pkg/testing/model_detector.go

@@ -89,26 +89,29 @@ func (d *ModelDetector) detectOllamaModels(ctx context.Context) ([]DetectedModel
 		return nil, fmt.Errorf("ollama API returned status %d", resp.StatusCode)
 	}
 
-	var result struct {
-		Models []struct {
-			Name       string    `json:"name"`
-			ModifiedAt time.Time `json:"modified_at"`
-			Size       int64     `json:"size"`
-			Details    struct {
-				Format            string `json:"format"`
-				Family            string `json:"family"`
-				ParameterSize     string `json:"parameter_size"`
-				QuantizationLevel string `json:"quantization_level"`
-			} `json:"details"`
-		} `json:"models"`
+	// Parse the response
+	result, err := d.parseOllamaResponse(resp)
+	if err != nil {
+		return nil, err
 	}
 
+	// Convert to DetectedModel format
+	return d.convertOllamaModels(result.Models), nil
+}
+
+// parseOllamaResponse parses the Ollama API response
+func (d *ModelDetector) parseOllamaResponse(resp *http.Response) (*ollamaResponse, error) {
+	var result ollamaResponse
 	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
 		return nil, fmt.Errorf("failed to decode ollama response: %w", err)
 	}
+	return &result, nil
+}
 
+// convertOllamaModels converts Ollama models to DetectedModel format
+func (d *ModelDetector) convertOllamaModels(ollamaModels []ollamaModel) []DetectedModel {
 	var models []DetectedModel
-	for _, m := range result.Models {
+	for _, m := range ollamaModels {
 		model := DetectedModel{
 			Name:     m.Name,
 			Provider: "ollama",
@@ -123,8 +126,25 @@ func (d *ModelDetector) detectOllamaModels(ctx context.Context) ([]DetectedModel
 		}
 		models = append(models, model)
 	}
+	return models
+}
 
-	return models, nil
+// ollamaResponse represents the response from Ollama API
+type ollamaResponse struct {
+	Models []ollamaModel `json:"models"`
+}
+
+// ollamaModel represents a single model from Ollama API
+type ollamaModel struct {
+	Name       string    `json:"name"`
+	ModifiedAt time.Time `json:"modified_at"`
+	Size       int64     `json:"size"`
+	Details    struct {
+		Format            string `json:"format"`
+		Family            string `json:"family"`
+		ParameterSize     string `json:"parameter_size"`
+		QuantizationLevel string `json:"quantization_level"`
+	} `json:"details"`
 }
 
 // detectLocalModels detects other local model files
@@ -163,45 +183,49 @@ func (d *ModelDetector) detectCloudModels() []DetectedModel {
 	var models []DetectedModel
 
 	// Check for OpenAI configuration
+	models = append(models, d.detectOpenAIModels()...)
+
+	// Check for Anthropic configuration
+	models = append(models, d.detectAnthropicModels()...)
+
+	return models
+}
+
+// detectOpenAIModels detects OpenAI models if API key is configured
+func (d *ModelDetector) detectOpenAIModels() []DetectedModel {
+	var models []DetectedModel
 	if apiKey := getEnvAny("OPENAI_API_KEY", "AI_OPENAI_KEY"); apiKey != "" {
-		models = append(models, DetectedModel{
-			Name:     "gpt-4",
-			Provider: "openai",
-			Metadata: map[string]string{
-				"type": "cloud",
-				"auth": "configured",
-			},
-		})
-		models = append(models, DetectedModel{
-			Name:     "gpt-3.5-turbo",
-			Provider: "openai",
-			Metadata: map[string]string{
-				"type": "cloud",
-				"auth": "configured",
-			},
-		})
+		openAIModels := []string{"gpt-4", "gpt-3.5-turbo"}
+		for _, modelName := range openAIModels {
+			models = append(models, DetectedModel{
+				Name:     modelName,
+				Provider: "openai",
+				Metadata: map[string]string{
+					"type": "cloud",
+					"auth": "configured",
+				},
+			})
+		}
 	}
+	return models
+}
 
-	// Check for Anthropic configuration
+// detectAnthropicModels detects Anthropic models if API key is configured
+func (d *ModelDetector) detectAnthropicModels() []DetectedModel {
+	var models []DetectedModel
 	if apiKey := getEnvAny("ANTHROPIC_API_KEY", "AI_ANTHROPIC_KEY"); apiKey != "" {
-		models = append(models, DetectedModel{
-			Name:     "claude-3-opus",
-			Provider: "anthropic",
-			Metadata: map[string]string{
-				"type": "cloud",
-				"auth": "configured",
-			},
-		})
-		models = append(models, DetectedModel{
-			Name:     "claude-3-sonnet",
-			Provider: "anthropic",
-			Metadata: map[string]string{
-				"type": "cloud",
-				"auth": "configured",
-			},
-		})
+		anthropicModels := []string{"claude-3-opus", "claude-3-sonnet"}
+		for _, modelName := range anthropicModels {
+			models = append(models, DetectedModel{
+				Name:     modelName,
+				Provider: "anthropic",
+				Metadata: map[string]string{
+					"type": "cloud",
+					"auth": "configured",
+				},
+			})
+		}
 	}
-
 	return models
 }
 
@@ -216,23 +240,36 @@ func (d *ModelDetector) GetDefaultModel(ctx context.Context) (*DetectedModel, er
 		return nil, fmt.Errorf("no models available")
 	}
 
+	// Find the best model using preference order
+	return d.selectBestModel(models), nil
+}
+
+// selectBestModel selects the best model based on preference order
+func (d *ModelDetector) selectBestModel(models []DetectedModel) *DetectedModel {
 	// Preference order: Local models first (privacy), then cloud
+	
 	// 1. Prefer Ollama models
-	for _, m := range models {
-		if m.Provider == "ollama" {
-			return &m, nil
-		}
+	if model := d.findModelByProvider(models, "ollama"); model != nil {
+		return model
 	}
 
 	// 2. Then local models
-	for _, m := range models {
-		if m.Provider == "llama.cpp" {
-			return &m, nil
-		}
+	if model := d.findModelByProvider(models, "llama.cpp"); model != nil {
+		return model
 	}
 
 	// 3. Finally cloud models
-	return &models[0], nil
+	return &models[0]
+}
+
+// findModelByProvider finds the first model with the specified provider
+func (d *ModelDetector) findModelByProvider(models []DetectedModel, provider string) *DetectedModel {
+	for _, m := range models {
+		if m.Provider == provider {
+			return &m
+		}
+	}
+	return nil
 }
 
 // formatBytes formats bytes to human readable string