Update app.py

app.py

@@ -161,10 +161,9 @@ def call_together_api(model: str, prompt: str, temperature: float = 0.7, max_tok
     """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 have a skeptical and thorough approach to code review, always checking for "
-        "syntax errors, security vulnerabilities, and performance issues."
+        "You are a Salesforce B2B Commerce expert. Be CONCISE and PRECISE. "
+        "Focus on CODE QUALITY over explanations. Use structured formats when requested. "
+        "Always check for syntax errors, security issues, and performance problems."
     )
     
     def make_request():
@@ -199,10 +198,9 @@ def call_anthropic_api(model: str, prompt: str, temperature: float = 0.7, max_to
     """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 have a skeptical and thorough approach to code review, always checking for "
-        "syntax errors, security vulnerabilities, and performance issues."
+        "You are a Salesforce B2B Commerce expert. Be CONCISE and PRECISE. "
+        "Focus on CODE QUALITY over explanations. Use structured formats when requested. "
+        "Always check for syntax errors, security issues, and performance problems."
     )
     
     def make_request():
@@ -353,25 +351,51 @@ def extract_code_blocks(text: str) -> str:
     
     return '\n\n'.join(filter(None, code_blocks))
 
-def extract_explanations(text: str, code_blocks: str) -> str:
-    """Extract explanations by removing code blocks from the response."""
-    explanation = text
+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"
     
-    # 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)
+    if sections["key_changes"]:
+        formatted += "**Key Changes:**\n" + sections["key_changes"] + "\n\n"
     
-    # Remove code block markers
-    explanation = re.sub(r"```(?:apex|java|Apex|Java|APEX|JAVA)?.*?```", "*[Code moved to Code Output section]*", explanation, flags=re.DOTALL)
+    if sections["critical_issues"]:
+        formatted += "**Critical Issues Fixed:**\n" + sections["critical_issues"] + "\n\n"
     
-    # Clean up extra whitespace
-    explanation = re.sub(r'\n{3,}', '\n\n', explanation)
+    if sections["warnings"]:
+        formatted += "**⚠️ Remaining Warnings:**\n" + sections["warnings"]
     
-    return explanation.strip()
+    # If structured extraction failed, provide a brief summary
+    if not any(sections.values()):
+        # Fall back to a simple extraction
+        formatted = "### Code Correction Summary\n\n"
+        formatted += "The code has been corrected and optimized. "
+        formatted += "Check the code output for inline comments explaining specific changes.\n\n"
+        formatted += "For detailed analysis, see the Full Model Response."
+    
+    return formatted.strip()
 
 def perform_skeptical_evaluation(code: str, context: str = "trigger") -> Dict[str, any]:
     """Perform skeptical evaluation of code looking for common issues."""
@@ -527,45 +551,48 @@ def correct_apex_trigger(model: str, trigger_code: str, progress=None) -> Tuple[
     # Perform skeptical evaluation
     evaluation = perform_skeptical_evaluation(trigger_code, "trigger")
     
-    # Build comprehensive prompt
+    # Build comprehensive prompt with structured output format
     prompt = f"""
-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'])}
+Correct this Apex Trigger for B2B Lightning Experience migration. Be BRIEF and DIRECT.
+
+ORIGINAL CODE:
+```apex
+{trigger_code}
+```
+
+DETECTED ISSUES:
+- Syntax Errors: {len(syntax_issues)}
+- Security Issues: {len(evaluation['security_concerns'])}
 - Performance Issues: {len(evaluation['performance_issues'])}
 - B2B Commerce Issues: {len(evaluation['b2b_commerce_issues'])}
 
-ORIGINAL TRIGGER CODE:
+PROVIDE EXACTLY THIS FORMAT:
+
+## CORRECTED CODE
 ```apex
-{trigger_code}
+[Put the complete corrected trigger here with inline comments for changes]
 ```
 
-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
+## KEY CHANGES (bullet points only)
+- [Change 1: Brief description]
+- [Change 2: Brief description]
+- [Maximum 7 bullet points]
+
+## CRITICAL ISSUES FIXED
+1. [Most important issue]: [One-line explanation]
+2. [Second issue]: [One-line explanation]
+3. [Third issue]: [One-line explanation]
+
+## REMAINING WARNINGS
+- [Any issues that need manual review]
 
-Return the corrected code in ```apex blocks with detailed explanations of ALL changes made.
+BE CONCISE. NO VERBOSE EXPLANATIONS. FOCUS ON CODE QUALITY.
 """
 
     if progress:
         progress(0.5, desc="Calling AI model...")
     
-    response = call_llm(model, prompt, temperature=0.3)  # Lower temperature for more consistent corrections
+    response = call_llm(model, prompt, temperature=0.2)  # Even lower temperature for consistency
     
     if progress:
         progress(0.8, desc="Processing response...")
@@ -574,17 +601,23 @@ Return the corrected code in ```apex blocks with detailed explanations of ALL ch
     code_output = extract_code_blocks(response)
     
     # Validate the corrected code
+    validation_warnings = []
     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."
+            error_count = len([i for i in corrected_issues if i["type"] == "error"])
+            warning_count = len([i for i in corrected_issues if i["type"] == "warning"])
+            validation_warnings.append(f"⚠️ Validation: {error_count} errors, {warning_count} warnings remain")
     
-    explanation = extract_explanations(response, code_output)
+    # Extract structured explanation
+    explanation = format_structured_explanation(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```"
+    # Add validation warnings if any
+    if validation_warnings:
+        explanation = "\n".join(validation_warnings) + "\n\n" + explanation
+    
+    # Add test case reference (brief)
+    explanation += "\n\n**Test Template:** Available in Full Response section"
     
     if progress:
         progress(1.0, desc="Complete!")
@@ -615,52 +648,63 @@ def convert_cc_object(model: str, cc_object_code: str, progress=None) -> Tuple[s
     evaluation = perform_skeptical_evaluation(cc_object_code, "object")
     
     prompt = f"""
-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)
+Convert this CloudCraze Object to B2B Lightning Experience. Be BRIEF and PRECISE.
 
-CLOUDCRAZE OBJECT CODE:
+CLOUDCRAZE OBJECT:
 ```
 {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. Complete B2B LEX object implementation in ```apex blocks
-2. Field mapping table
-3. Data migration considerations
-4. Manual migration steps if any
+PROVIDE EXACTLY THIS FORMAT:
+
+## B2B LEX OBJECT MAPPING
+- Source: [CloudCraze object name]
+- Target: [B2B LEX object name]
+- Migration Complexity: [Low/Medium/High]
+
+## CONVERTED CODE
+```apex
+[Complete B2B LEX implementation with inline comments]
+```
+
+## FIELD MAPPINGS (table format)
+| CC Field | B2B Field | Type | Notes |
+|----------|-----------|------|-------|
+| field1   | newField1 | Text | Required |
+| field2   | newField2 | Number | Optional |
+
+## MIGRATION STEPS
+1. [Step 1 - one line]
+2. [Step 2 - one line]
+3. [Maximum 5 steps]
+
+## DATA MIGRATION SCRIPT
+```apex
+[Brief data migration code if needed, otherwise state "Not Required"]
+```
+
+## WARNINGS
+- [Any manual steps or considerations]
+
+BE CONCISE. FOCUS ON ACTIONABLE INFORMATION.
 """
 
     if progress:
         progress(0.5, desc="Calling AI model...")
     
-    response = call_llm(model, prompt, temperature=0.3)
+    response = call_llm(model, prompt, temperature=0.2)
     
     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```"
+    # Extract structured explanation
+    explanation = format_object_conversion_explanation(response, code_output)
+    
+    # Add brief test reference
+    explanation += "\n\n**Test Utilities:** See Full Response for test data creation utilities"
     
     if progress:
         progress(1.0, desc="Complete!")
@@ -778,7 +822,7 @@ def create_enhanced_radar_chart(metrics: Optional[Dict[str, float]]) -> Optional
     return fig
 
 def validate_apex_trigger(validation_model: str, original_code: str, corrected_code: str) -> str:
-    """Enhanced validation with skeptical evaluation."""
+    """Enhanced validation with skeptical evaluation and structured output."""
     if not validation_model or not original_code.strip() or not corrected_code.strip():
         return "Please provide all required inputs for validation."
     
@@ -787,80 +831,111 @@ def validate_apex_trigger(validation_model: str, original_code: str, corrected_c
     corr_valid, corr_issues = validate_apex_syntax(corrected_code)
     
     prompt = f"""
-You are performing a SKEPTICAL validation of an Apex code migration. Your job is to find problems, not to praise.
+Validate this Apex trigger correction. Be CRITICAL but CONCISE.
 
-ORIGINAL CODE (had {len(orig_issues)} issues):
+ORIGINAL ({len(orig_issues)} issues detected):
 ```apex
 {original_code}
 ```
 
-CORRECTED CODE (has {len(corr_issues)} issues):
+CORRECTED ({len(corr_issues)} issues detected):
 ```apex
 {corrected_code}
 ```
 
-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
-
-IMPORTANT: Be harsh but fair. If the correction is genuinely good, acknowledge it, but still look for improvements.
+PROVIDE THIS EXACT JSON FORMAT:
+```json
+{{
+    "quality_rating": [1-10],
+    "accuracy": [0.0-1.0],
+    "completeness": [0.0-1.0],
+    "best_practices_alignment": [0.0-1.0],
+    "syntax_validity": [0.0-1.0],
+    "security_score": [0.0-1.0],
+    "performance_score": [0.0-1.0],
+    "errors": [
+        "Error 1: [specific line/issue]",
+        "Error 2: [specific line/issue]"
+    ],
+    "warnings": [
+        "Warning 1: [potential issue]",
+        "Warning 2: [potential issue]"
+    ],
+    "suggestions": [
+        "Improvement 1: [actionable suggestion]",
+        "Improvement 2: [actionable suggestion]"
+    ]
+}}
+```
 
-Provide your assessment in this JSON format:
-{json.dumps(VALIDATION_SCHEMA, indent=2)}
+SCORING CRITERIA:
+- quality_rating: Overall code quality (1=terrible, 10=excellent)
+- accuracy: Correctness of fixes (0=wrong, 1=perfect)
+- completeness: All issues addressed (0=none, 1=all)
+- best_practices_alignment: Follows Salesforce standards (0=poor, 1=excellent)
+- syntax_validity: No syntax errors (0=many errors, 1=error-free)
+- security_score: Security best practices (0=vulnerable, 1=secure)
+- performance_score: Efficiency and scalability (0=poor, 1=optimal)
 
-Be specific about line numbers and provide actionable feedback.
+BE HARSH. FIND PROBLEMS. Maximum 3 items per category.
 """
     
-    return call_llm(validation_model, prompt, temperature=0.2)  # Very low temperature for consistent validation
+    return call_llm(validation_model, prompt, temperature=0.1)  # Very low temperature for consistent JSON
 
 def validate_cc_object_conversion(validation_model: str, original_object: str, converted_object: str) -> str:
-    """Enhanced validation for CloudCraze object conversion."""
+    """Enhanced validation for CloudCraze object conversion with structured output."""
     if not validation_model or not original_object.strip() or not converted_object.strip():
         return "Please provide all required inputs for validation."
     
     prompt = f"""
-You are performing a SKEPTICAL validation of a CloudCraze to B2B Lightning Experience object conversion.
+Validate this CloudCraze to B2B LEX conversion. Be CRITICAL and BRIEF.
 
-ORIGINAL CLOUDCRAZE OBJECT:
+ORIGINAL CLOUDCRAZE:
 ```
 {original_object}
 ```
 
-CONVERTED B2B LEX OBJECT:
+CONVERTED B2B LEX:
 ```
 {converted_object}
 ```
 
-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?
-
-Provide your assessment in this JSON format:
-{json.dumps(VALIDATION_SCHEMA, indent=2)}
-
-Include specific examples of issues found.
+PROVIDE THIS EXACT JSON FORMAT:
+```json
+{{
+    "quality_rating": [1-10],
+    "accuracy": [0.0-1.0],
+    "completeness": [0.0-1.0],
+    "best_practices_alignment": [0.0-1.0],
+    "syntax_validity": [0.0-1.0],
+    "security_score": [0.0-1.0],
+    "performance_score": [0.0-1.0],
+    "errors": [
+        "Missing field: [field_name]",
+        "Wrong mapping: [issue]"
+    ],
+    "warnings": [
+        "Data type mismatch: [field]",
+        "Custom logic not migrated: [what]"
+    ],
+    "suggestions": [
+        "Add validation for: [field]",
+        "Consider indexing: [field]"
+    ]
+}}
+```
+
+FOCUS ON:
+1. Missing field mappings
+2. Data type conversions
+3. Relationship integrity
+4. Custom field handling
+5. Performance at scale
+
+BE HARSH. Maximum 3 items per category. Focus on REAL issues.
 """
     
-    return call_llm(validation_model, prompt, temperature=0.2)
+    return call_llm(validation_model, prompt, temperature=0.1)
 
 def get_theme_styles(theme_choice: str) -> Tuple[str, str, str, str]:
     """Get theme styles for different UI elements."""