Update app.py

app.py

@@ -1,534 +1,20 @@
 import gradio as gr
-import os
-import time
-import requests
 import json
 import plotly.express as px
 import pandas as pd
-import re
-import hashlib
-from functools import lru_cache
-from typing import Dict, Tuple, Optional, List
-import logging
+from typing import Tuple, Dict, Optional, List
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# Import from our modules
+from utils import (
+    validate_apex_syntax, perform_skeptical_evaluation, extract_code_blocks,
+    format_structured_explanation, format_object_conversion_explanation,
+    extract_validation_metrics, normalize_metrics, generate_test_cases,
+    VALIDATION_SCHEMA, B2B_COMMERCE_PATTERNS, logger
+)
 
-# Model options for dropdown with both Together AI and Anthropic models
-together_models = [
-    "Qwen/Qwen2.5-Coder-32B-Instruct",
-    "nvidia/Llama-3.1-Nemotron-70B-Instruct-HF",
-    "deepseek-ai/DeepSeek-R1-Distill-Llama-70B",
-    "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free"
-]
-
-anthropic_models = [
-    "claude-3-7-sonnet-20250219",
-    "claude-3-haiku-20240307",
-    "claude-opus-4-20250514", 
-    "claude-sonnet-4-20250514"
-]
-
-all_models = together_models + anthropic_models
-
-VALIDATION_SCHEMA = {
-    "quality_rating": "int (1–10)",
-    "accuracy": "float (0.0–1.0)",
-    "completeness": "float (0.0–1.0)",
-    "best_practices_alignment": "float (0.0–1.0)",
-    "syntax_validity": "float (0.0–1.0)",
-    "security_score": "float (0.0–1.0)",
-    "performance_score": "float (0.0–1.0)",
-    "explanations": {
-        "quality_rating": "string",
-        "accuracy": "string",
-        "completeness": "string",
-        "best_practices_alignment": "string",
-        "syntax_validity": "string",
-        "security_score": "string",
-        "performance_score": "string"
-    },
-    "errors": ["list of syntax errors"],
-    "warnings": ["list of potential issues"],
-    "suggestions": ["list of improvement suggestions"]
-}
-
-# Apex syntax patterns for validation
-APEX_PATTERNS = {
-    "class_declaration": r"(?:public|private|global|protected)\s+(?:virtual|abstract|with sharing|without sharing|inherited sharing)?\s*class\s+\w+",
-    "trigger_declaration": r"trigger\s+\w+\s+on\s+\w+\s*\([^)]+\)",
-    "method_declaration": r"(?:public|private|global|protected)\s+(?:static)?\s*(?:void|\w+)\s+\w+\s*\([^)]*\)",
-    "soql_query": r"(?:\[|Database\.query\s*\()\s*SELECT\s+.*?\s+FROM\s+\w+.*?(?:\]|\))",
-    "dml_operation": r"(?:insert|update|delete|undelete|upsert|merge)\s+\w+",
-    "bulkification_issue": r"for\s*\([^)]+\)\s*{[^}]*(?:insert|update|delete|undelete)\s+",
-    "hardcoded_id": r"(?:\'[a-zA-Z0-9]{15}\'|\'[a-zA-Z0-9]{18}\')",
-    "missing_null_check": r"(\w+)\.(\w+)(?!\s*(?:!=|==)\s*null)",
-    "governor_limit_risk": r"(?:for\s*\([^)]+\)\s*{[^}]*\[SELECT|Database\.query)",
-}
-
-# Common Apex errors and their fixes
-APEX_ERRORS = {
-    "missing_semicolon": {
-        "pattern": r"[^{};]\s*\n\s*(?:public|private|global|protected|if|for|while|try)",
-        "message": "Missing semicolon at end of statement",
-        "severity": "error"
-    },
-    "unclosed_bracket": {
-        "pattern": r"(?:\{(?:[^{}]|(?:\{[^{}]*\}))*$)|(?:^[^{}]*\})",
-        "message": "Unclosed or extra bracket detected",
-        "severity": "error"
-    },
-    "invalid_soql": {
-        "pattern": r"\[\s*SELECT\s+FROM\s+\w+",
-        "message": "Invalid SOQL: Missing field selection",
-        "severity": "error"
-    },
-    "missing_try_catch_dml": {
-        "pattern": r"(?<!try\s{[^}]*)(insert|update|delete|upsert)\s+(?!.*catch)",
-        "message": "DML operation without try-catch block",
-        "severity": "warning"
-    }
-}
-
-# B2B Commerce specific patterns
-B2B_COMMERCE_PATTERNS = {
-    "cloudcraze_reference": r"(?:ccrz__|E_\w+|CC_\w+)",
-    "b2b_lex_object": r"(?:OrderSummary|CartItem|WebCart|ProductCatalog|BuyerGroup|CommerceEntitlementPolicy)",
-    "deprecated_method": r"(?:ccrz\.cc_CallContext|ccrz\.ccAPI|cc_bean_\w+)",
-    "migration_required": r"(?:E_Product__|E_Cart__|E_Order__|CC_Promotions__|CC_Tax__)"
-}
-
-def get_api_key(provider: str) -> str:
-    """Securely retrieve API key for the specified provider."""
-    try:
-        if provider == "together":
-            api_key = os.getenv("TOGETHER_API_KEY")
-            if not api_key:
-                raise ValueError("API key not configured. Please contact administrator.")
-            return api_key
-        elif provider == "anthropic":
-            api_key = os.getenv("ANTHROPIC_API_KEY")
-            if not api_key:
-                raise ValueError("API key not configured. Please contact administrator.")
-            return api_key
-        else:
-            raise ValueError(f"Unknown provider: {provider}")
-    except Exception as e:
-        logger.error(f"Error retrieving API key: {e}")
-        raise
-
-def get_provider(model: str) -> str:
-    """Determine the provider for a given model."""
-    if model in together_models:
-        return "together"
-    elif model in anthropic_models:
-        return "anthropic"
-    else:
-        raise ValueError(f"Unknown model: {model}")
-
-def handle_api_error(status_code: int, response_text: str) -> str:
-    """Handle API errors with appropriate user-friendly messages."""
-    if status_code == 401:
-        return "Authentication failed. Please check API configuration."
-    elif status_code == 429:
-        return "Rate limit exceeded. Please try again later."
-    elif status_code == 403:
-        return "Access forbidden. Please check your permissions."
-    elif status_code >= 500:
-        return "Service temporarily unavailable. Please try again."
-    else:
-        return f"Request failed with status {status_code}"
-
-def call_api_with_retry(api_func, *args, max_retries: int = 3, timeout: int = 30, **kwargs):
-    """Call API with retry logic and timeout."""
-    for attempt in range(max_retries):
-        try:
-            kwargs['timeout'] = timeout
-            return api_func(*args, **kwargs)
-        except requests.Timeout:
-            if attempt == max_retries - 1:
-                return "Request timed out. Please try again with a shorter input."
-        except requests.ConnectionError:
-            if attempt == max_retries - 1:
-                return "Connection error. Please check your internet connection."
-        except Exception as e:
-            if attempt == max_retries - 1:
-                return f"Error: {str(e)}"
-        time.sleep(2 ** attempt)  # Exponential backoff
-
-def call_together_api(model: str, prompt: str, temperature: float = 0.7, max_tokens: int = 1500) -> str:
-    """Call Together AI API with enhanced error handling."""
-    api_key = get_api_key("together")
-    system_message = (
-        "You are a Salesforce B2B Commerce expert. Be CONCISE and PRECISE. "
-        "Focus on CODE QUALITY over explanations. Use structured formats when requested. "
-        "Always check for syntax errors, security issues, and performance problems."
-    )
-    
-    def make_request():
-        headers = {
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json"
-        }
-        payload = {
-            "model": model,
-            "messages": [
-                {"role": "system", "content": system_message},
-                {"role": "user", "content": prompt}
-            ],
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-            "top_p": 0.9
-        }
-        resp = requests.post(
-            "https://api.together.xyz/v1/chat/completions",
-            headers=headers,
-            json=payload,
-            timeout=30
-        )
-        if resp.status_code != 200:
-            return handle_api_error(resp.status_code, resp.text)
-        data = resp.json()
-        return data["choices"][0]["message"]["content"]
-    
-    return call_api_with_retry(make_request)
-
-def call_anthropic_api(model: str, prompt: str, temperature: float = 0.7, max_tokens: int = 1500) -> str:
-    """Call Anthropic API with enhanced error handling."""
-    api_key = get_api_key("anthropic")
-    system_message = (
-        "You are a Salesforce B2B Commerce expert. Be CONCISE and PRECISE. "
-        "Focus on CODE QUALITY over explanations. Use structured formats when requested. "
-        "Always check for syntax errors, security issues, and performance problems."
-    )
-    
-    def make_request():
-        headers = {
-            "x-api-key": api_key,
-            "anthropic-version": "2023-06-01",
-            "content-type": "application/json"
-        }
-        payload = {
-            "model": model,
-            "system": system_message,
-            "messages": [
-                {"role": "user", "content": prompt}
-            ],
-            "temperature": temperature,
-            "max_tokens": max_tokens
-        }
-        resp = requests.post(
-            "https://api.anthropic.com/v1/messages",
-            headers=headers,
-            json=payload,
-            timeout=30
-        )
-        if resp.status_code != 200:
-            return handle_api_error(resp.status_code, resp.text)
-        data = resp.json()
-        return data["content"][0]["text"]
-    
-    return call_api_with_retry(make_request)
-
-@lru_cache(maxsize=100)
-def cached_llm_call(model_hash: str, prompt_hash: str, model: str, prompt: str, temperature: float = 0.7, max_tokens: int = 1500) -> str:
-    """Cached LLM call to avoid repeated API calls for same inputs."""
-    provider = get_provider(model)
-    if provider == "together":
-        return call_together_api(model, prompt, temperature, max_tokens)
-    elif provider == "anthropic":
-        return call_anthropic_api(model, prompt, temperature, max_tokens)
-    else:
-        return f"Error: Unknown provider for model {model}"
-
-def call_llm(model: str, prompt: str, temperature: float = 0.7, max_tokens: int = 1500) -> str:
-    """Call LLM with caching support."""
-    model_hash = hashlib.md5(model.encode()).hexdigest()
-    prompt_hash = hashlib.md5(prompt.encode()).hexdigest()
-    return cached_llm_call(model_hash, prompt_hash, model, prompt, temperature, max_tokens)
-
-def validate_apex_syntax(code: str) -> Tuple[bool, List[Dict[str, str]]]:
-    """Validate Apex syntax and return errors/warnings."""
-    issues = []
-    
-    # Check for basic syntax errors
-    for error_type, error_info in APEX_ERRORS.items():
-        matches = re.finditer(error_info["pattern"], code, re.MULTILINE | re.DOTALL)
-        for match in matches:
-            issues.append({
-                "type": error_info["severity"],
-                "message": error_info["message"],
-                "line": code[:match.start()].count('\n') + 1,
-                "position": match.start()
-            })
-    
-    # Check for Apex-specific patterns
-    if not re.search(APEX_PATTERNS["class_declaration"], code) and \
-       not re.search(APEX_PATTERNS["trigger_declaration"], code):
-        issues.append({
-            "type": "error",
-            "message": "No valid Apex class or trigger declaration found",
-            "line": 1,
-            "position": 0
-        })
-    
-    # Check for bulkification issues
-    bulk_issues = re.finditer(APEX_PATTERNS["bulkification_issue"], code, re.DOTALL)
-    for match in bulk_issues:
-        issues.append({
-            "type": "error",
-            "message": "DML operation inside loop - violates bulkification best practices",
-            "line": code[:match.start()].count('\n') + 1,
-            "position": match.start()
-        })
-    
-    # Check for hardcoded IDs
-    hardcoded_ids = re.finditer(APEX_PATTERNS["hardcoded_id"], code)
-    for match in hardcoded_ids:
-        issues.append({
-            "type": "warning",
-            "message": "Hardcoded Salesforce ID detected - use Custom Settings or Custom Metadata",
-            "line": code[:match.start()].count('\n') + 1,
-            "position": match.start()
-        })
-    
-    # Check for governor limit risks
-    gov_limit_risks = re.finditer(APEX_PATTERNS["governor_limit_risk"], code, re.DOTALL)
-    for match in gov_limit_risks:
-        issues.append({
-            "type": "warning",
-            "message": "SOQL query inside loop - potential governor limit issue",
-            "line": code[:match.start()].count('\n') + 1,
-            "position": match.start()
-        })
-    
-    has_errors = any(issue["type"] == "error" for issue in issues)
-    return not has_errors, issues
-
-def extract_code_blocks(text: str) -> str:
-    """Enhanced code extraction with multiple strategies."""
-    # Strategy 1: Standard code blocks with language markers
-    pattern = r"```(?:apex|java|Apex|Java|APEX|JAVA)?\s*(.*?)```"
-    matches = re.findall(pattern, text, re.DOTALL | re.IGNORECASE)
-    
-    code_blocks = []
-    for block in matches:
-        cleaned_block = block.strip()
-        if cleaned_block:
-            code_blocks.append(cleaned_block)
-    
-    # Strategy 2: Improved fallback detection for Apex-specific patterns
-    if not code_blocks:
-        apex_patterns = [
-            # Class declarations (including inner classes)
-            r"((?:public|private|global|protected)\s+(?:virtual|abstract|with sharing|without sharing|inherited sharing)?\s*class\s+\w+(?:\s+extends\s+\w+)?(?:\s+implements\s+[\w\s,]+)?\s*\{(?:[^{}]|\{[^{}]*\})*\})",
-            # Trigger declarations
-            r"(trigger\s+\w+\s+on\s+\w+\s*\([^)]+\)\s*\{(?:[^{}]|\{[^{}]*\})*\})",
-            # Interface declarations
-            r"((?:public|private|global)\s+interface\s+\w+(?:\s+extends\s+[\w\s,]+)?\s*\{(?:[^{}]|\{[^{}]*\})*\})",
-            # Enum declarations
-            r"((?:public|private|global)\s+enum\s+\w+\s*\{[^}]+\})",
-            # Annotated methods or classes
-            r"(@\w+(?:\([^)]*\))?\s*(?:public|private|global|protected).*?(?:\{(?:[^{}]|\{[^{}]*\})*\}|;))"
-        ]
-        
-        for pattern in apex_patterns:
-            found = re.findall(pattern, text, re.DOTALL | re.MULTILINE)
-            code_blocks.extend(found)
-    
-    # Strategy 3: Look for code between specific markers
-    if not code_blocks:
-        # Look for code after phrases like "corrected code:", "here's the code:", etc.
-        marker_patterns = [
-            r"(?:corrected|fixed|updated|converted|modified)\s+code\s*:\s*\n((?:(?:public|private|global|trigger).*?)(?=\n\n|\Z))",
-            r"(?:here'?s?|below is)\s+(?:the|your)\s+(?:corrected|fixed|updated)\s+\w+\s*:\s*\n((?:(?:public|private|global|trigger).*?)(?=\n\n|\Z))"
-        ]
-        
-        for pattern in marker_patterns:
-            found = re.findall(pattern, text, re.DOTALL | re.IGNORECASE)
-            code_blocks.extend(found)
-    
-    return '\n\n'.join(filter(None, code_blocks))
-
-def format_structured_explanation(response: str, code_output: str) -> str:
-    """Format the explanation in a structured, brief manner."""
-    # Extract key sections using regex
-    sections = {
-        "key_changes": "",
-        "critical_issues": "",
-        "warnings": ""
-    }
-    
-    # Extract KEY CHANGES section
-    key_match = re.search(r"##\s*KEY CHANGES.*?\n((?:[-•]\s*.*?\n)+)", response, re.IGNORECASE | re.DOTALL)
-    if key_match:
-        sections["key_changes"] = key_match.group(1).strip()
-    
-    # Extract CRITICAL ISSUES section
-    critical_match = re.search(r"##\s*CRITICAL ISSUES.*?\n((?:\d+\..*?\n)+)", response, re.IGNORECASE | re.DOTALL)
-    if critical_match:
-        sections["critical_issues"] = critical_match.group(1).strip()
-    
-    # Extract WARNINGS section
-    warning_match = re.search(r"##\s*REMAINING WARNINGS.*?\n((?:[-•]\s*.*?\n)*)", response, re.IGNORECASE | re.DOTALL)
-    if warning_match:
-        sections["warnings"] = warning_match.group(1).strip()
-    
-    # Build formatted explanation
-    formatted = "### Summary of Changes\n\n"
-    
-    if sections["key_changes"]:
-        formatted += "**Key Changes:**\n" + sections["key_changes"] + "\n\n"
-    
-    if sections["critical_issues"]:
-        formatted += "**Critical Issues Fixed:**\n" + sections["critical_issues"] + "\n\n"
-    
-    if sections["warnings"]:
-        formatted += "**⚠️ Remaining Warnings:**\n" + sections["warnings"]
-    
-    # If structured extraction failed, provide a brief summary
-    if not any(sections.values()):
-        # Fall back to a simple extraction
-        formatted = "### Code Correction Summary\n\n"
-        formatted += "The code has been corrected and optimized. "
-        formatted += "Check the code output for inline comments explaining specific changes.\n\n"
-        formatted += "For detailed analysis, see the Full Model Response."
-    
-    return formatted.strip()
-
-def perform_skeptical_evaluation(code: str, context: str = "trigger") -> Dict[str, any]:
-    """Perform skeptical evaluation of code looking for common issues."""
-    evaluation = {
-        "syntax_issues": [],
-        "security_concerns": [],
-        "performance_issues": [],
-        "best_practice_violations": [],
-        "b2b_commerce_issues": []
-    }
-    
-    # Syntax validation
-    is_valid, syntax_issues = validate_apex_syntax(code)
-    evaluation["syntax_issues"] = syntax_issues
-    
-    # Security checks
-    if re.search(r"without\s+sharing", code, re.IGNORECASE):
-        evaluation["security_concerns"].append({
-            "type": "warning",
-            "message": "Class declared 'without sharing' - ensure this is intentional"
-        })
-    
-    if not re.search(r"\.stripInaccessible\(", code) and re.search(r"(insert|update)\s+", code):
-        evaluation["security_concerns"].append({
-            "type": "warning",
-            "message": "DML operations without stripInaccessible - potential FLS violation"
-        })
-    
-    # Performance checks
-    nested_loops = re.findall(r"for\s*\([^)]+\)\s*\{[^}]*for\s*\([^)]+\)", code, re.DOTALL)
-    if nested_loops:
-        evaluation["performance_issues"].append({
-            "type": "warning",
-            "message": f"Nested loops detected ({len(nested_loops)} occurrences) - review for O(n²) complexity"
-        })
-    
-    # Check for missing test assertions (if it's a test class)
-    if re.search(r"@isTest|testMethod", code, re.IGNORECASE):
-        if not re.search(r"System\.assert|Assert\.", code):
-            evaluation["best_practice_violations"].append({
-                "type": "error",
-                "message": "Test class without assertions - tests must verify behavior"
-            })
-    
-    # B2B Commerce specific checks
-    cloudcraze_refs = re.findall(B2B_COMMERCE_PATTERNS["cloudcraze_reference"], code)
-    if cloudcraze_refs:
-        evaluation["b2b_commerce_issues"].append({
-            "type": "error",
-            "message": f"CloudCraze references found ({len(set(cloudcraze_refs))} unique) - must be migrated to B2B LEX"
-        })
-    
-    deprecated_methods = re.findall(B2B_COMMERCE_PATTERNS["deprecated_method"], code)
-    if deprecated_methods:
-        evaluation["b2b_commerce_issues"].append({
-            "type": "error",
-            "message": f"Deprecated CloudCraze methods found: {', '.join(set(deprecated_methods))}"
-        })
-    
-    return evaluation
-
-def generate_test_cases(code_type: str, code: str) -> str:
-    """Generate test cases for the given code."""
-    if code_type == "trigger":
-        return f"""
-// Test class for the trigger
-@isTest
-private class Test_MigratedTrigger {{
-    @TestSetup
-    static void setup() {{
-        // Create test data
-        // TODO: Add specific test data setup
-    }}
-    
-    @isTest
-    static void testBulkInsert() {{
-        // Test bulk insert scenario
-        List<SObject> testRecords = new List<SObject>();
-        for(Integer i = 0; i < 200; i++) {{
-            // TODO: Create test records
-        }}
-        
-        Test.startTest();
-        insert testRecords;
-        Test.stopTest();
-        
-        // TODO: Add assertions
-        System.assert(true, 'Bulk insert test needs implementation');
-    }}
-    
-    @isTest
-    static void testBulkUpdate() {{
-        // Test bulk update scenario
-        // TODO: Implement bulk update test
-    }}
-    
-    @isTest
-    static void testErrorHandling() {{
-        // Test error scenarios
-        // TODO: Test validation rules, required fields, etc.
-    }}
-    
-    @isTest
-    static void testGovernorLimits() {{
-        // Test near governor limits
-        // TODO: Test with large data volumes
-    }}
-}}
-"""
-    else:  # object conversion
-        return f"""
-// Test data creation for migrated object
-@isTest
-public class Test_MigratedObjectData {{
-    public static SObject createTestRecord() {{
-        // TODO: Create and return test instance
-        return null;
-    }}
-    
-    public static List<SObject> createBulkTestRecords(Integer count) {{
-        List<SObject> records = new List<SObject>();
-        for(Integer i = 0; i < count; i++) {{
-            // TODO: Create test records
-        }}
-        return records;
-    }}
-    
-    public static void validateMigrationMapping() {{
-        // Validate that all fields are properly mapped
-        // TODO: Add field mapping validation
-    }}
-}}
-"""
+from api_client import (
+    all_models, together_models, anthropic_models, call_llm
+)
 
 def correct_apex_trigger(model: str, trigger_code: str, progress=None) -> Tuple[str, str, str]:
     """Correct Apex Trigger with skeptical evaluation."""
@@ -640,6 +126,7 @@ def convert_cc_object(model: str, cc_object_code: str, progress=None) -> Tuple[s
         progress(0.3, desc="Analyzing CloudCraze structure...")
     
     # Check for CloudCraze patterns
+    import re
     has_cc_pattern = bool(re.search(B2B_COMMERCE_PATTERNS["cloudcraze_reference"], cc_object_code))
     if not has_cc_pattern:
         logger.warning("No obvious CloudCraze patterns found in input")
@@ -711,116 +198,6 @@ BE CONCISE. FOCUS ON ACTIONABLE INFORMATION.
     
     return response, code_output, explanation
 
-def extract_validation_metrics(validation_text: str) -> Optional[Dict[str, float]]:
-    """Enhanced JSON extraction for validation metrics."""
-    try:
-        # Strategy 1: Look for JSON after specific markers
-        json_patterns = [
-            r'(?:json|JSON|assessment|Assessment)[\s:]*({[^{}]*(?:{[^{}]*}[^{}]*)*})',
-            r'```json\s*({[^`]+})\s*```',
-            r'({[^{}]*"quality_rating"[^{}]*(?:{[^{}]*}[^{}]*)*})'
-        ]
-        
-        for pattern in json_patterns:
-            matches = re.findall(pattern, validation_text, re.DOTALL)
-            for match in matches:
-                try:
-                    data = json.loads(match)
-                    if "quality_rating" in data:
-                        return normalize_metrics(data)
-                except json.JSONDecodeError:
-                    continue
-        
-        # Strategy 2: Extract individual metrics if JSON parsing fails
-        metrics = {}
-        metric_patterns = {
-            "quality_rating": r"quality_rating[\"']?\s*:\s*(\d+(?:\.\d+)?)",
-            "accuracy": r"accuracy[\"']?\s*:\s*(\d+(?:\.\d+)?)",
-            "completeness": r"completeness[\"']?\s*:\s*(\d+(?:\.\d+)?)",
-            "best_practices_alignment": r"best_practices_alignment[\"']?\s*:\s*(\d+(?:\.\d+)?)",
-            "syntax_validity": r"syntax_validity[\"']?\s*:\s*(\d+(?:\.\d+)?)",
-            "security_score": r"security_score[\"']?\s*:\s*(\d+(?:\.\d+)?)",
-            "performance_score": r"performance_score[\"']?\s*:\s*(\d+(?:\.\d+)?)"
-        }
-        
-        for metric, pattern in metric_patterns.items():
-            match = re.search(pattern, validation_text, re.IGNORECASE)
-            if match:
-                metrics[metric] = float(match.group(1))
-        
-        if metrics:
-            return normalize_metrics(metrics)
-        
-        return None
-        
-    except Exception as e:
-        logger.error(f"Error extracting metrics: {e}")
-        return None
-
-def normalize_metrics(data: Dict) -> Dict[str, float]:
-    """Ensure metrics are in the correct format and range."""
-    normalized = {
-        "quality_rating": min(10, max(0, float(data.get("quality_rating", 0)))),
-        "accuracy": min(1.0, max(0.0, float(data.get("accuracy", 0.0)))),
-        "completeness": min(1.0, max(0.0, float(data.get("completeness", 0.0)))),
-        "best_practices_alignment": min(1.0, max(0.0, float(data.get("best_practices_alignment", 0.0)))),
-        "syntax_validity": min(1.0, max(0.0, float(data.get("syntax_validity", 0.0)))),
-        "security_score": min(1.0, max(0.0, float(data.get("security_score", 0.0)))),
-        "performance_score": min(1.0, max(0.0, float(data.get("performance_score", 0.0))))
-    }
-    return normalized
-
-def create_enhanced_radar_chart(metrics: Optional[Dict[str, float]]) -> Optional[object]:
-    """Create an enhanced radar chart with more metrics."""
-    if not metrics:
-        return None
-    
-    # Create data for the radar chart
-    categories = [
-        "Quality",
-        "Accuracy",
-        "Completeness",
-        "Best Practices",
-        "Syntax Valid",
-        "Security",
-        "Performance"
-    ]
-    
-    values = [
-        metrics.get("quality_rating", 0) / 10,  # Normalize to 0-1 scale
-        metrics.get("accuracy", 0),
-        metrics.get("completeness", 0),
-        metrics.get("best_practices_alignment", 0),
-        metrics.get("syntax_validity", 0),
-        metrics.get("security_score", 0),
-        metrics.get("performance_score", 0)
-    ]
-    
-    # Create a DataFrame for plotting
-    df = pd.DataFrame({
-        'Category': categories,
-        'Value': values
-    })
-    
-    # Create the radar chart
-    fig = px.line_polar(
-        df, r='Value', theta='Category', line_close=True,
-        range_r=[0, 1], title="Comprehensive Validation Assessment"
-    )
-    fig.update_traces(fill='toself', fillcolor='rgba(0, 100, 255, 0.2)')
-    fig.update_layout(
-        polar=dict(
-            radialaxis=dict(
-                visible=True,
-                range=[0, 1]
-            )
-        ),
-        showlegend=False,
-        height=400
-    )
-    
-    return fig
-
 def validate_apex_trigger(validation_model: str, original_code: str, corrected_code: str) -> str:
     """Enhanced validation with skeptical evaluation and structured output."""
     if not validation_model or not original_code.strip() or not corrected_code.strip():
@@ -937,6 +314,57 @@ BE HARSH. Maximum 3 items per category. Focus on REAL issues.
     
     return call_llm(validation_model, prompt, temperature=0.1)
 
+def create_enhanced_radar_chart(metrics: Optional[Dict[str, float]]) -> Optional[object]:
+    """Create an enhanced radar chart with more metrics."""
+    if not metrics:
+        return None
+    
+    # Create data for the radar chart
+    categories = [
+        "Quality",
+        "Accuracy",
+        "Completeness",
+        "Best Practices",
+        "Syntax Valid",
+        "Security",
+        "Performance"
+    ]
+    
+    values = [
+        metrics.get("quality_rating", 0) / 10,  # Normalize to 0-1 scale
+        metrics.get("accuracy", 0),
+        metrics.get("completeness", 0),
+        metrics.get("best_practices_alignment", 0),
+        metrics.get("syntax_validity", 0),
+        metrics.get("security_score", 0),
+        metrics.get("performance_score", 0)
+    ]
+    
+    # Create a DataFrame for plotting
+    df = pd.DataFrame({
+        'Category': categories,
+        'Value': values
+    })
+    
+    # Create the radar chart
+    fig = px.line_polar(
+        df, r='Value', theta='Category', line_close=True,
+        range_r=[0, 1], title="Comprehensive Validation Assessment"
+    )
+    fig.update_traces(fill='toself', fillcolor='rgba(0, 100, 255, 0.2)')
+    fig.update_layout(
+        polar=dict(
+            radialaxis=dict(
+                visible=True,
+                range=[0, 1]
+            )
+        ),
+        showlegend=False,
+        height=400
+    )
+    
+    return fig
+
 def get_theme_styles(theme_choice: str) -> Tuple[str, str, str, str]:
     """Get theme styles for different UI elements."""
     themes = {
@@ -1225,13 +653,6 @@ def main():
             - **Primary Model**: Performs initial conversion with skeptical analysis
             - **Validation Model**: Double-checks work with harsh but fair evaluation
             
-            **⚡ Key Improvements:**
-            - Syntax validation before and after correction
-            - Security vulnerability detection (FLS, CRUD, injection)
-            - Performance analysis (O(n²) algorithms, governor limits)
-            - B2B Commerce specific migration validation
-            - Automatic test case suggestions
-            
             **⚠️ Important**: Always review and test AI-generated code in a sandbox before production deployment.
             """
         )