Update utils.py

utils.py

@@ -1,484 +1,305 @@
-"""Utility functions for Salesforce B2B Commerce Migration Assistant"""
+"""
+Utility functions for Salesforce B2B Commerce migration assistant.
+"""
 
 import re
 import json
 import logging
-from typing import Dict, Tuple, List, Optional
+from typing import Dict, List, Tuple, Optional, Any
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# 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"
-    }
+# Validation schema for Apex code
+VALIDATION_SCHEMA = {
+    "syntax_errors": ["missing_semicolon", "unclosed_bracket", "invalid_syntax"],
+    "security_issues": ["soql_injection", "hardcoded_credentials", "unsafe_dml"],
+    "performance_issues": ["governor_limits", "bulk_operations", "inefficient_queries"],
+    "b2b_commerce_issues": ["deprecated_apis", "missing_null_checks", "incorrect_field_references"]
 }
 
-# B2B Commerce specific patterns
+# B2B Commerce patterns for detection
 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__)"
+    "cloudcraze_reference": r"(ccrz__|E_[A-Z]|CloudCraze)",
+    "trigger_pattern": r"trigger\s+\w+\s+on\s+\w+",
+    "apex_class_pattern": r"(public|private|global)\s+class\s+\w+",
+    "soql_pattern": r"SELECT\s+.+\s+FROM\s+\w+",
+    "dml_pattern": r"(insert|update|delete|upsert)\s+\w+"
 }
 
-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"]
-}
-
-def validate_apex_syntax(code: str) -> Tuple[bool, List[Dict[str, str]]]:
-    """Validate Apex syntax and return errors/warnings."""
+def validate_apex_syntax(code: str) -> Tuple[bool, List[Dict[str, Any]]]:
+    """
+    Validate Apex code syntax and return issues found.
+    
+    Args:
+        code: Apex code to validate
+        
+    Returns:
+        Tuple of (is_valid, list_of_issues)
+    """
     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
+    # Basic syntax checks
+    if not code.strip():
+        issues.append({"type": "error", "message": "Empty code provided", "line": 0})
+        return False, issues
+    
+    # Check for balanced brackets
+    brackets = {"(": ")", "{": "}", "[": "]"}
+    stack = []
+    
+    for i, char in enumerate(code):
+        if char in brackets:
+            stack.append((char, i))
+        elif char in brackets.values():
+            if not stack:
+                issues.append({"type": "error", "message": f"Unmatched closing bracket '{char}'", "line": code[:i].count('\n') + 1})
+            else:
+                open_char, _ = stack.pop()
+                if brackets[open_char] != char:
+                    issues.append({"type": "error", "message": f"Mismatched bracket pair", "line": code[:i].count('\n') + 1})
+    
+    # Check for unclosed brackets
+    if stack:
+        for char, pos in stack:
+            issues.append({"type": "error", "message": f"Unclosed bracket '{char}'", "line": code[:pos].count('\n') + 1})
+    
+    # Check for missing semicolons (basic check)
+    lines = code.split('\n')
+    for line_num, line in enumerate(lines, 1):
+        stripped = line.strip()
+        if stripped and not stripped.endswith((';', '{', '}', '//', '/*', '*/', '*')):
+            if any(keyword in stripped for keyword in ['if', 'for', 'while', 'try', 'catch', 'class', 'trigger']):
+                continue
+            if re.search(r'\b(insert|update|delete|upsert|return)\b', stripped):
+                issues.append({"type": "warning", "message": "Possible missing semicolon", "line": line_num})
+    
+    is_valid = not any(issue["type"] == "error" for issue in issues)
+    return is_valid, issues
 
-def perform_skeptical_evaluation(code: str, context: str = "trigger") -> Dict[str, any]:
-    """Perform skeptical evaluation of code looking for common issues."""
+def perform_skeptical_evaluation(code: str, code_type: str = "trigger") -> Dict[str, List[str]]:
+    """
+    Perform skeptical evaluation of code to find potential issues.
+    
+    Args:
+        code: Code to evaluate
+        code_type: Type of code (trigger, class, object)
+        
+    Returns:
+        Dictionary with categorized issues
+    """
     evaluation = {
-        "syntax_issues": [],
         "security_concerns": [],
         "performance_issues": [],
-        "best_practice_violations": [],
-        "b2b_commerce_issues": []
+        "b2b_commerce_issues": [],
+        "best_practice_violations": []
     }
     
-    # 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"
-        })
+    if re.search(r"String\.format|String\.valueOf.*user", code, re.IGNORECASE):
+        evaluation["security_concerns"].append("Potential SOQL injection vulnerability")
+    
+    if re.search(r"password\s*=\s*['\"][^'\"]+['\"]", code, re.IGNORECASE):
+        evaluation["security_concerns"].append("Hardcoded credentials detected")
     
     # 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"
-            })
+    if re.search(r"for\s*\([^)]*:[^)]*\)\s*\{[^}]*\b(insert|update|delete|upsert)\b", code):
+        evaluation["performance_issues"].append("DML operation inside loop - governor limit risk")
+    
+    if re.search(r"for\s*\([^)]*:[^)]*\)\s*\{[^}]*\bSELECT\b", code, re.IGNORECASE):
+        evaluation["performance_issues"].append("SOQL query inside loop - governor limit risk")
     
     # 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))}"
-        })
+    if re.search(B2B_COMMERCE_PATTERNS["cloudcraze_reference"], code):
+        evaluation["b2b_commerce_issues"].append("CloudCraze references need migration to B2B LEX")
+    
+    if code_type == "trigger" and not re.search(r"Trigger\.(isInsert|isUpdate|isDelete)", code):
+        evaluation["best_practice_violations"].append("Missing trigger context checks")
     
     return evaluation
 
-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)
+def extract_code_blocks(response: str) -> str:
+    """
+    Extract code blocks from AI response.
     
-    return '\n\n'.join(filter(None, code_blocks))
+    Args:
+        response: AI model response
+        
+    Returns:
+        Extracted code or empty string if none found
+    """
+    # Look for code blocks with various delimiters
+    patterns = [
+        r"```(?:apex|java|salesforce)?\s*(.*?)```",
+        r"```\s*(.*?)```",
+        r"<code>(.*?)</code>",
+        r"`([^`]+)`"
+    ]
+    
+    for pattern in patterns:
+        matches = re.findall(pattern, response, re.DOTALL | re.IGNORECASE)
+        if matches:
+            # Return the longest match (most likely to be the main code block)
+            return max(matches, key=len).strip()
+    
+    return ""
 
 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"]
+    """
+    Format the AI response into a structured explanation.
     
-    # 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()
+    Args:
+        response: Raw AI response
+        code_output: Extracted code
+        
+    Returns:
+        Formatted explanation
+    """
+    explanation = ""
+    
+    # Extract key changes section
+    key_changes_match = re.search(r"## KEY CHANGES.*?(?=##|$)", response, re.DOTALL | re.IGNORECASE)
+    if key_changes_match:
+        explanation += "**Key Changes:**\n" + key_changes_match.group(0).replace("## KEY CHANGES", "").strip() + "\n\n"
+    
+    # Extract critical issues section
+    critical_issues_match = re.search(r"## CRITICAL ISSUES.*?(?=##|$)", response, re.DOTALL | re.IGNORECASE)
+    if critical_issues_match:
+        explanation += "**Critical Issues Fixed:**\n" + critical_issues_match.group(0).replace("## CRITICAL ISSUES", "").strip() + "\n\n"
+    
+    # Extract warnings section
+    warnings_match = re.search(r"## (?:REMAINING )?WARNINGS.*?(?=##|$)", response, re.DOTALL | re.IGNORECASE)
+    if warnings_match:
+        explanation += "**Remaining Warnings:**\n" + warnings_match.group(0).replace("## REMAINING WARNINGS", "").replace("## WARNINGS", "").strip()
+    
+    return explanation if explanation else "Analysis completed. See full response for details."
 
 def format_object_conversion_explanation(response: str, code_output: str) -> str:
-    """Format the object conversion explanation in a structured manner."""
-    sections = {
-        "mapping": "",
-        "field_table": "",
-        "steps": "",
-        "warnings": ""
-    }
+    """
+    Format object conversion explanation.
+    
+    Args:
+        response: Raw AI response
+        code_output: Extracted code
+        
+    Returns:
+        Formatted explanation
+    """
+    explanation = ""
     
-    # Extract object mapping section
-    mapping_match = re.search(r"##\s*B2B LEX OBJECT MAPPING.*?\n((?:[-•]\s*.*?\n)+)", response, re.IGNORECASE | re.DOTALL)
+    # Extract mapping section
+    mapping_match = re.search(r"## B2B LEX OBJECT MAPPING.*?(?=##|$)", response, re.DOTALL | re.IGNORECASE)
     if mapping_match:
-        sections["mapping"] = mapping_match.group(1).strip()
+        explanation += "**Object Mapping:**\n" + mapping_match.group(0).replace("## B2B LEX OBJECT MAPPING", "").strip() + "\n\n"
     
-    # Extract field mappings table
-    table_match = re.search(r"##\s*FIELD MAPPINGS.*?\n((?:\|.*?\|.*?\n)+)", response, re.IGNORECASE | re.DOTALL)
-    if table_match:
-        sections["field_table"] = table_match.group(1).strip()
+    # Extract field mappings
+    field_mappings_match = re.search(r"## FIELD MAPPINGS.*?(?=##|$)", response, re.DOTALL | re.IGNORECASE)
+    if field_mappings_match:
+        explanation += "**Field Mappings:**\n" + field_mappings_match.group(0).replace("## FIELD MAPPINGS", "").strip() + "\n\n"
     
     # Extract migration steps
-    steps_match = re.search(r"##\s*MIGRATION STEPS.*?\n((?:\d+\..*?\n)+)", response, re.IGNORECASE | re.DOTALL)
+    steps_match = re.search(r"## MIGRATION STEPS.*?(?=##|$)", response, re.DOTALL | re.IGNORECASE)
     if steps_match:
-        sections["steps"] = steps_match.group(1).strip()
-    
-    # Extract warnings
-    warning_match = re.search(r"##\s*WARNINGS.*?\n((?:[-•]\s*.*?\n)*)", response, re.IGNORECASE | re.DOTALL)
-    if warning_match:
-        sections["warnings"] = warning_match.group(1).strip()
-    
-    # Build formatted explanation
-    formatted = "### Conversion Summary\n\n"
-    
-    if sections["mapping"]:
-        formatted += "**Object Mapping:**\n" + sections["mapping"] + "\n\n"
-    
-    if sections["field_table"]:
-        formatted += "**Field Mappings:**\n" + sections["field_table"] + "\n\n"
+        explanation += "**Migration Steps:**\n" + steps_match.group(0).replace("## MIGRATION STEPS", "").strip()
     
-    if sections["steps"]:
-        formatted += "**Migration Steps:**\n" + sections["steps"] + "\n\n"
-    
-    if sections["warnings"]:
-        formatted += "**⚠️ Important Notes:**\n" + sections["warnings"]
-    
-    # Fallback if structured extraction failed
-    if not any(sections.values()):
-        formatted = "### Conversion Summary\n\n"
-        formatted += "The CloudCraze object has been converted to B2B Lightning Experience format. "
-        formatted += "Check the code output for the complete implementation.\n\n"
-        formatted += "For detailed field mappings and migration steps, see the Full Model Response."
-    
-    return formatted.strip()
+    return explanation if explanation else "Conversion completed. See full response for details."
 
 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
+    """
+    Extract validation metrics from AI response.
+    
+    Args:
+        validation_text: AI validation response
         
-    except Exception as e:
-        logger.error(f"Error extracting metrics: {e}")
-        return None
+    Returns:
+        Dictionary of metrics or None if parsing fails
+    """
+    try:
+        # Look for JSON block in the response
+        json_match = re.search(r"```json\s*(.*?)```", validation_text, re.DOTALL)
+        if json_match:
+            metrics_data = json.loads(json_match.group(1))
+            return {
+                "quality_rating": float(metrics_data.get("quality_rating", 0)),
+                "accuracy": float(metrics_data.get("accuracy", 0)),
+                "completeness": float(metrics_data.get("completeness", 0)),
+                "best_practices_alignment": float(metrics_data.get("best_practices_alignment", 0)),
+                "syntax_validity": float(metrics_data.get("syntax_validity", 0)),
+                "security_score": float(metrics_data.get("security_score", 0)),
+                "performance_score": float(metrics_data.get("performance_score", 0))
+            }
+    except (json.JSONDecodeError, ValueError, KeyError) as e:
+        logger.warning(f"Failed to parse validation 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))))
-    }
+def normalize_metrics(metrics: Dict[str, float]) -> Dict[str, float]:
+    """
+    Normalize metrics to 0-1 scale.
+    
+    Args:
+        metrics: Raw metrics dictionary
+        
+    Returns:
+        Normalized metrics
+    """
+    normalized = {}
+    for key, value in metrics.items():
+        if key == "quality_rating":
+            normalized[key] = value / 10.0  # Convert 1-10 scale to 0-1
+        else:
+            normalized[key] = max(0.0, min(1.0, value))  # Clamp to 0-1
+    
     return normalized
 
-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
-    }}
+def generate_test_cases(code: str, code_type: str = "trigger") -> str:
+    """
+    Generate basic test case templates for the given code.
     
+    Args:
+        code: Code to generate tests for
+        code_type: Type of code (trigger, class, object)
+        
+    Returns:
+        Test case template as string
+    """
+    if code_type == "trigger":
+        # Extract trigger name and object
+        trigger_match = re.search(r"trigger\s+(\w+)\s+on\s+(\w+)", code, re.IGNORECASE)
+        if trigger_match:
+            trigger_name = trigger_match.group(1)
+            sobject_name = trigger_match.group(2)
+            
+            return f"""@isTest
+public class {trigger_name}Test {{
     @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
-        }}
+    static void testInsert() {{
+        // Test insert scenario
+        {sobject_name} testRecord = new {sobject_name}();
+        // Set required fields
         
         Test.startTest();
-        insert testRecords;
+        insert testRecord;
         Test.stopTest();
         
-        // TODO: Add assertions
-        System.assert(true, 'Bulk insert test needs implementation');
+        // Assert expected behavior
     }}
     
     @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) {{
-            // TODO: Create test records
-        }}
-        return records;
+    static void testUpdate() {{
+        // Test update scenario
+        {sobject_name} testRecord = new {sobject_name}();
+        // Set required fields
+        insert testRecord;
+        
+        Test.startTest();
+        // Modify fields
+        update testRecord;
+        Test.stopTest();
+        
+        // Assert expected behavior
     }}
+}}"""
     
-    public static void validateMigrationMapping() {{
-        // Validate that all fields are properly mapped
-        // TODO: Add field mapping validation
-    }}
-}}
-"""
-
-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}"
+    return "// Test case template not available for this code type"