Update app.py

app.py

@@ -6,6 +6,14 @@ 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
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 # Model options for dropdown with both Together AI and Anthropic models
 together_models = [
@@ -29,29 +37,89 @@ VALIDATION_SCHEMA = {
     "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"
+        "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"
     }
 }
 
-def get_api_key(provider):
-    if provider == "together":
-        api_key = os.getenv("TOGETHER_API_KEY")
-        if not api_key:
-            raise ValueError("TOGETHER_API_KEY not set. Please add it in Space secrets.")
-        return api_key
-    elif provider == "anthropic":
-        api_key = os.getenv("ANTHROPIC_API_KEY")
-        if not api_key:
-            raise ValueError("ANTHROPIC_API_KEY not set. Please add it in Space secrets.")
-        return api_key
-    else:
-        raise ValueError(f"Unknown provider: {provider}")
+# 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_provider(model):
+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:
@@ -59,13 +127,47 @@ def get_provider(model):
     else:
         raise ValueError(f"Unknown model: {model}")
 
-def call_together_api(model, prompt, temperature=0.7, max_tokens=1500):
+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 development expert specializing in B2B Commerce migrations,"
-        " CloudCraze to B2B Lightning Experience conversions, and Apex code optimization."
+        "You are a Salesforce development expert specializing in B2B Commerce migrations, "
+        "CloudCraze to B2B Lightning Experience conversions, and Apex code optimization. "
+        "You have a skeptical and thorough approach to code review, always checking for "
+        "syntax errors, security vulnerabilities, and performance issues."
     )
-    try:
+    
+    def make_request():
         headers = {
             "Authorization": f"Bearer {api_key}",
             "Content-Type": "application/json"
@@ -83,23 +185,27 @@ def call_together_api(model, prompt, temperature=0.7, max_tokens=1500):
         resp = requests.post(
             "https://api.together.xyz/v1/chat/completions",
             headers=headers,
-            json=payload
+            json=payload,
+            timeout=30
         )
         if resp.status_code != 200:
-            return f"Error: Status {resp.status_code}: {resp.text}"
+            return handle_api_error(resp.status_code, resp.text)
         data = resp.json()
-        text = data["choices"][0]["message"]["content"]
-        return text
-    except Exception as e:
-        return f"Error calling Together AI API: {e}"
+        return data["choices"][0]["message"]["content"]
+    
+    return call_api_with_retry(make_request)
 
-def call_anthropic_api(model, prompt, temperature=0.7, max_tokens=1500):
+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 development expert specializing in B2B Commerce migrations,"
-        " CloudCraze to B2B Lightning Experience conversions, and Apex code optimization."
+        "You are a Salesforce development expert specializing in B2B Commerce migrations, "
+        "CloudCraze to B2B Lightning Experience conversions, and Apex code optimization. "
+        "You have a skeptical and thorough approach to code review, always checking for "
+        "syntax errors, security vulnerabilities, and performance issues."
     )
-    try:
+    
+    def make_request():
         headers = {
             "x-api-key": api_key,
             "anthropic-version": "2023-06-01",
@@ -117,17 +223,19 @@ def call_anthropic_api(model, prompt, temperature=0.7, max_tokens=1500):
         resp = requests.post(
             "https://api.anthropic.com/v1/messages",
             headers=headers,
-            json=payload
+            json=payload,
+            timeout=30
         )
         if resp.status_code != 200:
-            return f"Error: Status {resp.status_code}: {resp.text}"
+            return handle_api_error(resp.status_code, resp.text)
         data = resp.json()
-        text = data["content"][0]["text"]
-        return text
-    except Exception as e:
-        return f"Error calling Anthropic API: {e}"
+        return data["content"][0]["text"]
+    
+    return call_api_with_retry(make_request)
 
-def call_llm(model, prompt, temperature=0.7, max_tokens=1500):
+@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)
@@ -136,140 +244,588 @@ def call_llm(model, prompt, temperature=0.7, max_tokens=1500):
     else:
         return f"Error: Unknown provider for model {model}"
 
-def extract_code_blocks(text):
-    """Extract code blocks from the model's response"""
-    # Pattern to match code blocks with ```apex or ```java or just ```
-    pattern = r"```(?:apex|java)?(.*?)```"
-    matches = re.findall(pattern, text, re.DOTALL)
+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)
     
-    # Clean up extracted code blocks
     code_blocks = []
     for block in matches:
-        # Remove leading/trailing whitespace
         cleaned_block = block.strip()
         if cleaned_block:
             code_blocks.append(cleaned_block)
     
-    # If no code blocks found but text contains code-like content
-    if not code_blocks and ("public" in text or "private" in text or "trigger" in text):
-        # Try to extract the most code-like part
-        lines = text.split('\n')
-        potential_code = []
-        in_code_section = False
+    # 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 line in lines:
-            if any(keyword in line for keyword in ["public", "private", "class", "trigger", "@"]):
-                in_code_section = True
-            
-            if in_code_section:
-                potential_code.append(line)
+        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))"
+        ]
         
-        if potential_code:
-            code_blocks.append('\n'.join(potential_code))
+        for pattern in marker_patterns:
+            found = re.findall(pattern, text, re.DOTALL | re.IGNORECASE)
+            code_blocks.extend(found)
     
-    return '\n\n'.join(code_blocks) if code_blocks else ""
+    return '\n\n'.join(filter(None, code_blocks))
 
-def extract_explanations(text, code_blocks):
-    """Extract explanations from the model's response by removing code blocks"""
-    # Replace all code blocks with placeholders
+def extract_explanations(text: str, code_blocks: str) -> str:
+    """Extract explanations by removing code blocks from the response."""
     explanation = text
-    for block in code_blocks.split('\n\n'):
-        # Escape special regex characters in the block
-        escaped_block = re.escape(block)
-        explanation = re.sub(escaped_block, "[CODE BLOCK REMOVED]", explanation, flags=re.DOTALL)
+    
+    # Remove code blocks
+    if code_blocks:
+        for block in code_blocks.split('\n\n'):
+            if block.strip():
+                # Escape special regex characters
+                escaped_block = re.escape(block)
+                explanation = re.sub(escaped_block, "", explanation, flags=re.DOTALL)
     
     # Remove code block markers
-    explanation = re.sub(r"```(?:apex|java)?.*?```", "", explanation, flags=re.DOTALL)
+    explanation = re.sub(r"```(?:apex|java|Apex|Java|APEX|JAVA)?.*?```", "*[Code moved to Code Output section]*", explanation, flags=re.DOTALL)
     
-    # Clean up the explanation
-    explanation = explanation.replace("[CODE BLOCK REMOVED]", "*Code has been moved to the Code Output section*")
+    # Clean up extra whitespace
+    explanation = re.sub(r'\n{3,}', '\n\n', explanation)
     
     return explanation.strip()
 
-def correct_apex_trigger(model, trigger_code):
+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
+    }}
+}}
+"""
+
+def correct_apex_trigger(model: str, trigger_code: str, progress=None) -> Tuple[str, str, str]:
+    """Correct Apex Trigger with skeptical evaluation."""
+    if progress:
+        progress(0.1, desc="Validating input...")
+    
+    # Input validation
     if not trigger_code.strip():
         return "Please provide Apex Trigger code to correct.", "", ""
+    
+    if len(trigger_code.strip()) < 50:
+        return "Code too short to be a valid Apex trigger. Please provide complete code.", "", ""
+    
+    # Perform initial syntax check
+    is_valid, syntax_issues = validate_apex_syntax(trigger_code)
+    
+    if progress:
+        progress(0.3, desc="Analyzing code structure...")
+    
+    # Perform skeptical evaluation
+    evaluation = perform_skeptical_evaluation(trigger_code, "trigger")
+    
+    # Build comprehensive prompt
     prompt = f"""
-Please analyze and correct the following Apex Trigger code for migration from CloudCraze to B2B Lightning Experience.
-Identify any issues, optimize it according to best practices, and provide the corrected code.
+You are tasked with correcting and optimizing the following Apex Trigger for migration from CloudCraze to B2B Lightning Experience.
+
+IMPORTANT: Apply a SKEPTICAL lens to this code. Assume there are hidden issues and actively look for:
+1. Syntax errors (missing semicolons, brackets, incorrect method signatures)
+2. Logic errors (null pointer exceptions, incorrect loop conditions)
+3. Security vulnerabilities (FLS violations, SOQL injection risks)
+4. Performance issues (queries in loops, inefficient algorithms)
+5. Governor limit risks (excessive DML, SOQL operations)
+6. B2B Commerce specific issues (deprecated CloudCraze methods, incorrect object mappings)
 
+Initial Analysis Found:
+- Syntax Issues: {len(syntax_issues)}
+- Security Concerns: {len(evaluation['security_concerns'])}
+- Performance Issues: {len(evaluation['performance_issues'])}
+- B2B Commerce Issues: {len(evaluation['b2b_commerce_issues'])}
+
+ORIGINAL TRIGGER CODE:
 ```apex
 {trigger_code}
 ```
 
-Please return the corrected code with explanations of changes. Put the corrected code in ```apex code blocks.
+REQUIREMENTS:
+1. Fix ALL syntax errors
+2. Implement proper bulkification
+3. Add comprehensive error handling
+4. Ensure FLS/CRUD security
+5. Optimize for performance
+6. Migrate CloudCraze references to B2B Lightning Experience
+7. Add detailed comments explaining each fix
+
+Return the corrected code in ```apex blocks with detailed explanations of ALL changes made.
 """
-    response = call_llm(model, prompt)
+
+    if progress:
+        progress(0.5, desc="Calling AI model...")
+    
+    response = call_llm(model, prompt, temperature=0.3)  # Lower temperature for more consistent corrections
+    
+    if progress:
+        progress(0.8, desc="Processing response...")
     
-    # Extract code blocks and explanations
+    # Extract code and explanations
     code_output = extract_code_blocks(response)
+    
+    # Validate the corrected code
+    if code_output:
+        corrected_valid, corrected_issues = validate_apex_syntax(code_output)
+        if not corrected_valid:
+            # Add warning to explanation
+            response += f"\n\n⚠️ WARNING: The corrected code still has {len(corrected_issues)} syntax issues that need manual review."
+    
     explanation = extract_explanations(response, code_output)
     
+    # Add test case template
+    test_template = generate_test_cases("trigger", code_output)
+    explanation += f"\n\n### Suggested Test Class Template:\n```apex\n{test_template}\n```"
+    
+    if progress:
+        progress(1.0, desc="Complete!")
+    
     return response, code_output, explanation
 
-def convert_cc_object(model, cc_object_code):
+def convert_cc_object(model: str, cc_object_code: str, progress=None) -> Tuple[str, str, str]:
+    """Convert CloudCraze Object with skeptical evaluation."""
+    if progress:
+        progress(0.1, desc="Validating input...")
+    
+    # Input validation
     if not cc_object_code.strip():
         return "Please provide CloudCraze Object code to convert.", "", ""
+    
+    if len(cc_object_code.strip()) < 30:
+        return "Code too short to be a valid CloudCraze object. Please provide complete code.", "", ""
+    
+    if progress:
+        progress(0.3, desc="Analyzing CloudCraze structure...")
+    
+    # Check for CloudCraze patterns
+    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")
+    
+    # Perform evaluation
+    evaluation = perform_skeptical_evaluation(cc_object_code, "object")
+    
     prompt = f"""
-Please convert the following CloudCraze Object code to B2B Lightning Experience format.
-Identify the corresponding B2B LEx system object, map fields, and provide the full definition.
+You are tasked with converting CloudCraze Object code to B2B Lightning Experience format.
+
+IMPORTANT: Apply a SKEPTICAL lens to this conversion. Actively look for:
+1. Missing or incorrectly mapped fields
+2. Data type mismatches between CloudCraze and B2B LEX
+3. Relationship mapping issues
+4. Custom fields that have no B2B LEX equivalent
+5. Business logic embedded in CloudCraze that needs migration
+6. Data migration challenges (data format changes, validation rules)
 
+CLOUDCRAZE OBJECT CODE:
 ```
 {cc_object_code}
 ```
 
+REQUIREMENTS:
+1. Identify the exact B2B LEX object mapping
+2. Map ALL fields with data type conversions
+3. Handle custom fields appropriately
+4. Document any data migration considerations
+5. Provide complete implementation code
+6. Include data migration script if needed
+7. List any manual steps required
+
 Return:
-1. Equivalent B2B LEx object name
-2. Field mappings
-3. Full implementation code in ```apex code blocks
-4. Additional steps if needed
+1. Complete B2B LEX object implementation in ```apex blocks
+2. Field mapping table
+3. Data migration considerations
+4. Manual migration steps if any
 """
-    response = call_llm(model, prompt)
+
+    if progress:
+        progress(0.5, desc="Calling AI model...")
+    
+    response = call_llm(model, prompt, temperature=0.3)
     
-    # Extract code blocks and explanations
+    if progress:
+        progress(0.8, desc="Processing response...")
+    
+    # Extract code and explanations
     code_output = extract_code_blocks(response)
     explanation = extract_explanations(response, code_output)
     
+    # Add test case template
+    test_template = generate_test_cases("object", code_output)
+    explanation += f"\n\n### Suggested Test Data Creation:\n```apex\n{test_template}\n```"
+    
+    if progress:
+        progress(1.0, desc="Complete!")
+    
     return response, code_output, explanation
 
-def validate_apex_trigger(validation_model, original_code, corrected_code):
+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."""
     if not validation_model or not original_code.strip() or not corrected_code.strip():
         return "Please provide all required inputs for validation."
     
+    # Perform syntax validation on both
+    orig_valid, orig_issues = validate_apex_syntax(original_code)
+    corr_valid, corr_issues = validate_apex_syntax(corrected_code)
+    
     prompt = f"""
-I need you to validate and review the following Apex code migration. This involves both CloudCraze to B2B Lightning Experience conversions AND general Apex code optimization.
+You are performing a SKEPTICAL validation of an Apex code migration. Your job is to find problems, not to praise.
 
-ORIGINAL CODE:
+ORIGINAL CODE (had {len(orig_issues)} issues):
 ```apex
 {original_code}
 ```
 
-CORRECTED CODE:
+CORRECTED CODE (has {len(corr_issues)} issues):
 ```apex
 {corrected_code}
 ```
 
-Please review the corrected code and provide:
-1. Is the correction accurate and complete? Highlight any missed issues.
-2. Are there any potential runtime errors or performance concerns?
-3. Does it follow Salesforce best practices for B2B Lightning Experience?
-4. Are there optimization opportunities that were missed?
-5. Evaluate both the B2B Commerce conversion aspects AND the general Apex optimization.
-6. Rate the quality of the correction on a scale of 1-10 with explanation.
+CRITICAL EVALUATION REQUIRED:
+1. List ALL remaining syntax errors in the corrected code
+2. Identify any NEW issues introduced by the correction
+3. Find security vulnerabilities (FLS, CRUD, injection risks)
+4. Identify performance problems (O(n²) algorithms, unbounded queries)
+5. Check governor limit risks (queries/DML in loops)
+6. Verify B2B Commerce migration completeness
+7. Look for edge cases not handled
+8. Check error handling completeness
 
-Additionally, provide a structured assessment in JSON format following this schema:
+IMPORTANT: Be harsh but fair. If the correction is genuinely good, acknowledge it, but still look for improvements.
+
+Provide your assessment in this JSON format:
 {json.dumps(VALIDATION_SCHEMA, indent=2)}
 
-Be thorough and detailed in your assessment, addressing both the conversion and optimization aspects.
+Be specific about line numbers and provide actionable feedback.
 """
-    return call_llm(validation_model, prompt)
+    
+    return call_llm(validation_model, prompt, temperature=0.2)  # Very low temperature for consistent validation
 
-def validate_cc_object_conversion(validation_model, original_object, converted_object):
+def validate_cc_object_conversion(validation_model: str, original_object: str, converted_object: str) -> str:
+    """Enhanced validation for CloudCraze object conversion."""
     if not validation_model or not original_object.strip() or not converted_object.strip():
         return "Please provide all required inputs for validation."
     
     prompt = f"""
-I need you to validate and review the following CloudCraze Object conversion to B2B Lightning Experience format. This involves both CloudCraze to B2B Lightning Experience conversions AND optimization of the resulting code.
+You are performing a SKEPTICAL validation of a CloudCraze to B2B Lightning Experience object conversion.
 
 ORIGINAL CLOUDCRAZE OBJECT:
 ```
@@ -281,126 +837,116 @@ CONVERTED B2B LEX OBJECT:
 {converted_object}
 ```
 
-Please review the conversion and provide:
-1. Is the object mapping correct and complete? Identify any missed fields or relationships.
-2. Are there any potential data migration issues or concerns?
-3. Does the converted object follow B2B Lightning Experience best practices?
-4. Are there optimization opportunities that were missed in the conversion?
-5. Evaluate both the B2B Commerce conversion aspects AND the optimization of the resulting code.
-6. Rate the quality of the conversion on a scale of 1-10 with explanation.
+CRITICAL EVALUATION REQUIRED:
+1. Verify EVERY field is mapped correctly (check data types!)
+2. Identify missing fields or relationships
+3. Check for custom field handling
+4. Validate business logic migration
+5. Identify data migration challenges
+6. Check for hardcoded values that should be configurable
+7. Verify object security settings
+8. Look for performance implications
+
+SPECIFIC CHECKS:
+- Are all CloudCraze custom fields accounted for?
+- Are relationship fields properly mapped?
+- Are there data type mismatches?
+- Are validation rules considered?
+- Is the object scalable for large data volumes?
 
-Additionally, provide a structured assessment in JSON format following this schema:
+Provide your assessment in this JSON format:
 {json.dumps(VALIDATION_SCHEMA, indent=2)}
 
-Be thorough and detailed in your assessment, addressing both the conversion and optimization aspects.
+Include specific examples of issues found.
 """
-    return call_llm(validation_model, prompt)
-
-def extract_validation_metrics(validation_text):
-    try:
-        # Try to find JSON in the response
-        start_idx = validation_text.find('{')
-        end_idx = validation_text.rfind('}') + 1
-        
-        if start_idx != -1 and end_idx != -1 and start_idx < end_idx:
-            json_str = validation_text[start_idx:end_idx]
-            # Print for debugging
-            print("Extracted JSON:", json_str)
-            
-            try:
-                data = json.loads(json_str)
-                
-                # Extract the required metrics with default values
-                metrics = {
-                    "quality_rating": float(data.get("quality_rating", 0)),
-                    "accuracy": float(data.get("accuracy", 0.0)),
-                    "completeness": float(data.get("completeness", 0.0)),
-                    "best_practices_alignment": float(data.get("best_practices_alignment", 0.0))
-                }
-                
-                return metrics
-            except json.JSONDecodeError as je:
-                print(f"JSON decode error: {je}")
-                return None
-        else:
-            print("No JSON found in validation text")
-            return None
-    except Exception as e:
-        print(f"Error extracting metrics: {e}")
-        return None
-
-def create_radar_chart(metrics):
-    if not metrics:
-        return None
-    
-    # Create data for the radar chart
-    categories = ["Quality", "Accuracy", "Completeness", "Best Practices"]
-    values = [
-        metrics["quality_rating"] / 10,  # Normalize to 0-1 scale
-        metrics["accuracy"],
-        metrics["completeness"],
-        metrics["best_practices_alignment"]
-    ]
-    
-    # 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="Validation Assessment"
-    )
-    fig.update_traces(fill='toself')
-    
-    return fig
+    return call_llm(validation_model, prompt, temperature=0.2)
 
-# Theme functionality has been moved to inline function in main()
+def get_theme_styles(theme_choice: str) -> Tuple[str, str, str, str]:
+    """Get theme styles for different UI elements."""
+    themes = {
+        "Dark": {
+            "explanation": "background-color: #1e1e1e; color: #e0e0e0; padding: 15px; border-radius: 8px; font-family: 'Inter', sans-serif; line-height: 1.6;",
+            "code": "background-color: #0d1117; color: #c9d1d9; font-family: 'Fira Code', 'Consolas', monospace; padding: 15px; border-radius: 8px; border: 1px solid #30363d; font-size: 14px; line-height: 1.5;",
+            "validation": "background-color: #161b22; color: #c9d1d9; padding: 15px; border-radius: 8px; border: 1px solid #30363d;",
+            "error": "background-color: #3d1418; color: #f85149; padding: 10px; border-radius: 5px; border: 1px solid #f85149;"
+        },
+        "Light": {
+            "explanation": "background-color: #ffffff; color: #24292e; padding: 15px; border-radius: 8px; border: 1px solid #e1e4e8; font-family: 'Inter', sans-serif; line-height: 1.6;",
+            "code": "background-color: #f6f8fa; color: #24292e; font-family: 'Fira Code', 'Consolas', monospace; padding: 15px; border-radius: 8px; border: 1px solid #e1e4e8; font-size: 14px; line-height: 1.5;",
+            "validation": "background-color: #f6f8fa; color: #24292e; padding: 15px; border-radius: 8px; border: 1px solid #e1e4e8;",
+            "error": "background-color: #ffe4e6; color: #d73a49; padding: 10px; border-radius: 5px; border: 1px solid #d73a49;"
+        }
+    }
+    
+    theme = themes.get(theme_choice, themes["Light"])
+    return (theme["explanation"], theme["code"], theme["explanation"], theme["code"])
 
 def main():
-    with gr.Blocks(title="Salesforce B2B Commerce Migration Assistant", theme=gr.themes.Soft(primary_hue="blue")) as app:
+    """Main application entry point."""
+    with gr.Blocks(
+        title="Salesforce B2B Commerce Migration Assistant",
+        theme=gr.themes.Soft(primary_hue="blue"),
+        css="""
+        .gradio-container {
+            font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+        }
+        .gr-button-primary {
+            background-color: #0969da !important;
+        }
+        .gr-button-primary:hover {
+            background-color: #0860ca !important;
+        }
+        code {
+            font-family: 'Fira Code', 'Consolas', 'Monaco', monospace;
+        }
+        """
+    ) as app:
         
-        gr.Markdown("# Salesforce B2B Commerce Migration Assistant")
-        gr.Markdown("This tool helps migrate CloudCraze code to B2B Lightning Experience.")
+        gr.Markdown("# 🚀 Salesforce B2B Commerce Migration Assistant")
+        gr.Markdown("Advanced tool for migrating CloudCraze code to B2B Lightning Experience with skeptical AI validation.")
 
-        # Create model dropdowns
+        # Model selection
         with gr.Row():
             with gr.Column():
-                gr.Markdown("### Primary Model")
+                gr.Markdown("### 🤖 Primary Model")
                 primary_model_dropdown = gr.Dropdown(
                     choices=all_models,
-                    value=anthropic_models[0],  # Default to Claude 3.7 Sonnet
-                    label="Select Primary AI Model for Conversion"
+                    value=anthropic_models[0],
+                    label="Select Primary AI Model for Conversion",
+                    info="This model performs the initial code conversion"
                 )
             
             with gr.Column():
-                gr.Markdown("### Validation Model")
+                gr.Markdown("### 🔍 Validation Model")
                 validation_model_dropdown = gr.Dropdown(
                     choices=all_models,
-                    value=anthropic_models[1],  # Default to Claude 3 Haiku
+                    value=anthropic_models[1],
                     label="Select Validation AI Model for Review",
-                    info="This model will validate and review the output from the primary model"
+                    info="This model skeptically reviews and validates the output"
                 )
 
-        with gr.Tab("Apex Trigger Correction"):
-            gr.Markdown("### Apex Trigger Correction")
-            gr.Markdown("Paste your Apex Trigger code below:")
+        with gr.Tab("⚡ Apex Trigger Correction"):
+            gr.Markdown("### Apex Trigger Correction & Optimization")
+            gr.Markdown("Paste your Apex Trigger code for analysis, correction, and optimization.")
 
             trigger_input = gr.Textbox(
-                lines=12,
-                placeholder="Paste Apex Trigger code here...",
-                label="Apex Trigger Code"
+                lines=15,
+                placeholder="Paste your Apex Trigger code here...\n\nExample:\ntrigger AccountTrigger on Account (before insert, before update) {\n    // Your trigger logic\n}",
+                label="Apex Trigger Code",
+                elem_classes="code-input"
             )
             
             with gr.Row():
-                trigger_button = gr.Button("Correct Apex Trigger", variant="primary")
-                copy_code_button = gr.Button("Copy Code", variant="secondary")
+                trigger_button = gr.Button("🔧 Correct & Optimize", variant="primary", size="lg")
+                copy_code_button = gr.Button("📋 Copy Code", variant="secondary")
                 
-            with gr.Accordion("Full Model Response (Hidden by Default)", open=False):
+            # Progress indicator
+            trigger_progress = gr.Textbox(label="Progress", visible=False)
+            
+            with gr.Accordion("📄 Full Model Response", open=False):
                 trigger_full_response = gr.Textbox(
-                    lines=15,
+                    lines=20,
                     label="Full Model Response",
                     interactive=False
                 )
@@ -408,44 +954,45 @@ def main():
             with gr.Row():
                 with gr.Column():
                     trigger_explanation = gr.Textbox(
-                        lines=10,
-                        label="Explanation",
-                        placeholder="Explanation will appear here after correction",
+                        lines=15,
+                        label="📝 Explanation & Analysis",
+                        placeholder="Detailed explanation will appear here...",
                         interactive=False,
                         elem_id="trigger_explanation"
                     )
                 
                 with gr.Column():
                     trigger_code_output = gr.Code(
-                        language="python",  # Using Python syntax highlighting as it's supported
-                        label="Corrected Code (Apex)",
-                        value="# Corrected Apex code will appear here",
+                        language="java",
+                        label="✅ Corrected Code (Apex)",
+                        value="// Corrected Apex code will appear here",
                         elem_id="trigger_code_output"
                     )
             
-            gr.Markdown("### Validation Results")
+            gr.Markdown("### 🎯 Validation Results")
             with gr.Row():
                 with gr.Column(scale=2):
                     trigger_validation_output = gr.Textbox(
-                        lines=15,
-                        label="Validation Assessment",
-                        placeholder="Validation results will appear here after clicking 'Validate Correction'",
-                        interactive=True
+                        lines=20,
+                        label="🔍 Skeptical Validation Assessment",
+                        placeholder="Validation results will appear here...",
+                        interactive=True,
+                        elem_id="trigger_validation"
                     )
                 with gr.Column(scale=1):
-                    trigger_chart = gr.Plot(label="Validation Metrics")
+                    trigger_chart = gr.Plot(label="📊 Validation Metrics")
             
-            validate_trigger_button = gr.Button("Validate Correction")
+            validate_trigger_button = gr.Button("🔍 Validate Correction", variant="secondary", size="lg")
             
+            # Wire up functionality
             def validate_and_chart_trigger(model, original, corrected):
                 validation_text = validate_apex_trigger(model, original, corrected)
                 metrics = extract_validation_metrics(validation_text)
-                chart = create_radar_chart(metrics) if metrics else None
+                chart = create_enhanced_radar_chart(metrics) if metrics else None
                 return validation_text, chart
             
-            # Handle button clicks
             trigger_button.click(
-                fn=correct_apex_trigger,
+                fn=lambda m, c: correct_apex_trigger(m, c, gr.Progress()),
                 inputs=[primary_model_dropdown, trigger_input],
                 outputs=[trigger_full_response, trigger_code_output, trigger_explanation],
                 show_progress=True
@@ -458,44 +1005,44 @@ def main():
                 show_progress=True
             )
             
-            # Copy code button functionality
-            def copy_code_message():
-                return "Code copied to clipboard! (Use Ctrl+C/Cmd+C for manual copy if automatic copy fails)"
-                
             copy_code_button.click(
-                fn=copy_code_message,
+                fn=lambda: gr.Info("Code copied! Use Ctrl+C/Cmd+C if automatic copy fails."),
                 inputs=[],
-                outputs=gr.Textbox(visible=False)
+                outputs=[]
             )
             
             with gr.Row():
-                trigger_clear = gr.Button("Clear Input")
+                trigger_clear = gr.Button("🗑️ Clear Input")
                 trigger_clear.click(lambda: "", [], trigger_input)
                 
-                results_clear = gr.Button("Clear Results")
+                results_clear = gr.Button("🧹 Clear Results")
                 results_clear.click(
                     lambda: ["", "", "", "", None],
                     [],
                     [trigger_full_response, trigger_code_output, trigger_explanation, trigger_validation_output, trigger_chart]
                 )
 
-        with gr.Tab("CloudCraze Object Conversion"):
-            gr.Markdown("### CloudCraze Object Conversion")
-            gr.Markdown("Paste your CloudCraze Object code below:")
+        with gr.Tab("🔄 CloudCraze Object Conversion"):
+            gr.Markdown("### CloudCraze to B2B Lightning Experience Object Conversion")
+            gr.Markdown("Convert CloudCraze custom objects to B2B Lightning Experience format.")
 
             object_input = gr.Textbox(
-                lines=12,
-                placeholder="Paste CC object code here...",
-                label="CloudCraze Object Code"
+                lines=15,
+                placeholder="Paste your CloudCraze Object definition here...\n\nExample:\nE_Product__c fields, relationships, and custom logic",
+                label="CloudCraze Object Code",
+                elem_classes="code-input"
             )
             
             with gr.Row():
-                object_button = gr.Button("Convert Object", variant="primary")
-                object_copy_code_button = gr.Button("Copy Code", variant="secondary")
+                object_button = gr.Button("🔄 Convert Object", variant="primary", size="lg")
+                object_copy_code_button = gr.Button("📋 Copy Code", variant="secondary")
+            
+            # Progress indicator
+            object_progress = gr.Textbox(label="Progress", visible=False)
                 
-            with gr.Accordion("Full Model Response (Hidden by Default)", open=False):
+            with gr.Accordion("📄 Full Model Response", open=False):
                 object_full_response = gr.Textbox(
-                    lines=15,
+                    lines=20,
                     label="Full Model Response",
                     interactive=False
                 )
@@ -503,44 +1050,44 @@ def main():
             with gr.Row():
                 with gr.Column():
                     object_explanation = gr.Textbox(
-                        lines=10,
-                        label="Explanation",
-                        placeholder="Explanation will appear here after conversion",
+                        lines=15,
+                        label="📝 Conversion Explanation",
+                        placeholder="Detailed explanation will appear here...",
                         interactive=False,
                         elem_id="object_explanation"
                     )
                 
                 with gr.Column():
                     object_code_output = gr.Code(
-                        language="python",  # Using Python syntax highlighting as it's supported
-                        label="Converted Code (Apex)",
-                        value="# Converted Apex code will appear here",
+                        language="java",
+                        label="✅ Converted Code (B2B LEX)",
+                        value="// Converted B2B Lightning Experience code will appear here",
                         elem_id="object_code_output"
                     )
             
-            gr.Markdown("### Validation Results")
+            gr.Markdown("### 🎯 Validation Results")
             with gr.Row():
                 with gr.Column(scale=2):
                     object_validation_output = gr.Textbox(
-                        lines=15,
-                        label="Validation Assessment",
-                        placeholder="Validation results will appear here after clicking 'Validate Conversion'",
-                        interactive=True
+                        lines=20,
+                        label="🔍 Skeptical Validation Assessment",
+                        placeholder="Validation results will appear here...",
+                        interactive=True,
+                        elem_id="object_validation"
                     )
                 with gr.Column(scale=1):
-                    object_chart = gr.Plot(label="Validation Metrics")
+                    object_chart = gr.Plot(label="📊 Validation Metrics")
             
-            validate_object_button = gr.Button("Validate Conversion")
+            validate_object_button = gr.Button("🔍 Validate Conversion", variant="secondary", size="lg")
             
             def validate_and_chart_object(model, original, converted):
                 validation_text = validate_cc_object_conversion(model, original, converted)
                 metrics = extract_validation_metrics(validation_text)
-                chart = create_radar_chart(metrics) if metrics else None
+                chart = create_enhanced_radar_chart(metrics) if metrics else None
                 return validation_text, chart
             
-            # Handle button clicks
             object_button.click(
-                fn=convert_cc_object,
+                fn=lambda m, c: convert_cc_object(m, c, gr.Progress()),
                 inputs=[primary_model_dropdown, object_input],
                 outputs=[object_full_response, object_code_output, object_explanation],
                 show_progress=True
@@ -553,21 +1100,17 @@ def main():
                 show_progress=True
             )
             
-            # Copy code button functionality
-            def copy_code_message():
-                return "Code copied to clipboard! (Use Ctrl+C/Cmd+C for manual copy if automatic copy fails)"
-                
             object_copy_code_button.click(
-                fn=copy_code_message,
+                fn=lambda: gr.Info("Code copied! Use Ctrl+C/Cmd+C if automatic copy fails."),
                 inputs=[],
-                outputs=gr.Textbox(visible=False)
+                outputs=[]
             )
             
             with gr.Row():
-                object_clear = gr.Button("Clear Input")
+                object_clear = gr.Button("🗑️ Clear Input")
                 object_clear.click(lambda: "", [], object_input)
                 
-                object_results_clear = gr.Button("Clear Results")
+                object_results_clear = gr.Button("🧹 Clear Results")
                 object_results_clear.click(
                     lambda: ["", "", "", "", None],
                     [],
@@ -575,32 +1118,15 @@ def main():
                 )
 
         # UI Preferences
-        with gr.Accordion("UI Preferences", open=False):
+        with gr.Accordion("⚙️ UI Preferences", open=False):
             theme_radio = gr.Radio(
-                label="Theme", 
+                label="🎨 Theme", 
                 choices=["Light", "Dark"], 
                 value="Light"
             )
             
-            # Simple theme change function that applies CSS to individual components
-            def change_theme(theme_choice):
-                if theme_choice == "Dark":
-                    explanation_style = "background-color: #2e2e2e; color: #ffffff;"
-                    code_style = "background-color: #1e1e1e; color: #e0e0e0; font-family: 'Courier New', monospace;"
-                else:  # Light
-                    explanation_style = "background-color: #ffffff; color: #333333;"
-                    code_style = "background-color: #f5f5f5; color: #333333; font-family: 'Courier New', monospace;"
-                
-                return (
-                    explanation_style,  # trigger_explanation
-                    code_style,         # trigger_code_output
-                    explanation_style,  # object_explanation
-                    code_style          # object_code_output
-                )
-            
-            # Connect the theme radio to the change_theme function
             theme_radio.change(
-                fn=change_theme,
+                fn=get_theme_styles,
                 inputs=[theme_radio],
                 outputs=[
                     trigger_explanation, 
@@ -610,25 +1136,29 @@ def main():
                 ]
             )
 
-        gr.Markdown("### About This Tool")
+        gr.Markdown("### 📚 About This Tool")
         gr.Markdown(
             """
-                 **Primary Model**: Performs the initial code conversion or correction.
-                **Validation Model**: Reviews and validates the output from the primary model, identifying potential issues or improvements.
-                **Trigger Correction**: Fixes Apex Triggers for B2B LEx compatibility.
-                **Object Conversion**: Maps and converts CloudCraze object definitions to B2B LEx.
-                **Model Selection**: Choose from Together AI models or Anthropic's Claude models.
-                
-                **New Interface Features**:
-                - Separated code output in dedicated code editor interface with syntax highlighting
-                - Clear separation between explanations and code
-                - "Copy Code" button for easy copying
-                - Dark mode option for comfortable viewing
-                - Hidden full model response to reduce clutter
-                
-                **Validation** outputs four key metrics (quality, accuracy, completeness, best practices) as both JSON and a radar chart.
-                Always review AI-generated code before production use.
-                """
+            **🚀 Enhanced Features:**
+            - **Skeptical AI Evaluation**: Models actively search for syntax errors, security issues, and performance problems
+            - **Comprehensive Validation**: 7-metric assessment including syntax, security, and performance
+            - **Edge Case Detection**: Identifies governor limits, bulkification issues, and B2B Commerce pitfalls
+            - **Test Case Generation**: Automatic test class templates for migrated code
+            - **Enhanced Error Detection**: Pattern-based syntax validation before AI processing
+            
+            **🤖 Model Roles:**
+            - **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.
+            """
         )
 
     app.launch()