Upload app.py

app.py

@@ -1067,10 +1067,16 @@ async def run_stage2_analysis_v2(
                         semantic_analysis=semantic_analysis,
                         log_callback=state.log,
                     )
+                    # Log what the LLM contributed
+                    if brand_result:
+                        state.log(f"   ├─ Brand Primary: {brand_result.primary_color or 'N/A'} ({brand_result.confidence or 'N/A'} confidence)")
+                        state.log(f"   ├─ Brand Secondary: {brand_result.secondary_color or 'N/A'}")
+                        state.log(f"   ├─ Palette Strategy: {brand_result.palette_strategy or 'N/A'}")
+                        state.log(f"   └─ Cohesion Score: {brand_result.cohesion_score or 'N/A'}/10")
                 except Exception as e:
-                    state.log(f"   ⚠️ Brand Identifier failed: {str(e)[:50]}")
+                    state.log(f"   ⚠️ Brand Identifier failed: {str(e)[:120]}")
                     brand_result = BrandIdentification()
-                
+
                 # Benchmark Advisor
                 if benchmark_comparisons:
                     try:
@@ -1081,20 +1087,38 @@ async def run_stage2_analysis_v2(
                             benchmark_comparisons=benchmark_comparisons,
                             log_callback=state.log,
                         )
+                        # Log what the LLM contributed
+                        if benchmark_advice:
+                            state.log(f"   ├─ Recommended: {benchmark_advice.recommended_system or 'N/A'}")
+                            changes = getattr(benchmark_advice, 'changes_needed', []) or []
+                            state.log(f"   ├─ Changes Needed: {len(changes)}")
+                            if changes:
+                                state.log(f"   └─ Key Change: {changes[0].get('what', 'N/A') if isinstance(changes[0], dict) else changes[0]}")
                     except Exception as e:
-                        state.log(f"   ⚠️ Benchmark Advisor failed: {str(e)[:50]}")
+                        state.log(f"   ⚠️ Benchmark Advisor failed: {str(e)[:120]}")
                         benchmark_advice = BenchmarkAdvice()
                 else:
                     benchmark_advice = BenchmarkAdvice()
-                
+
                 # Best Practices Validator
                 try:
                     best_practices = await best_practices_agent.analyze(
                         rule_engine_results=rule_results,
                         log_callback=state.log,
                     )
+                    # Log what the LLM contributed
+                    if best_practices:
+                        checks = getattr(best_practices, 'checks', []) or []
+                        passing = sum(1 for c in checks if c.get('pass', False)) if checks else 0
+                        failing = len(checks) - passing if checks else 0
+                        state.log(f"   ├─ Overall Score: {best_practices.overall_score or 'N/A'}/100")
+                        state.log(f"   ├─ Passing: {passing} | Failing: {failing}")
+                        if checks:
+                            top_fail = next((c for c in checks if not c.get('pass', True)), None)
+                            if top_fail:
+                                state.log(f"   └─ Top Fix: {top_fail.get('fix', top_fail.get('name', 'N/A'))[:60]}")
                 except Exception as e:
-                    state.log(f"   ⚠️ Best Practices Validator failed: {str(e)[:50]}")
+                    state.log(f"   ⚠️ Best Practices Validator failed: {str(e)[:120]}")
                     best_practices = BestPracticesResult(overall_score=rule_results.consistency_score)
             else:
                 # No HF client - use defaults
@@ -1129,8 +1153,21 @@ async def run_stage2_analysis_v2(
                         best_practices=best_practices,
                         log_callback=state.log,
                     )
+                    if final_synthesis:
+                        state.log("")
+                        state.log(f"   ✅ HEAD Synthesizer: COMPLETE")
+                        state.log(f"   ├─ Scores: {final_synthesis.scores}")
+                        if final_synthesis.executive_summary:
+                            state.log(f"   ├─ Summary: {final_synthesis.executive_summary[:100]}...")
+                        color_recs = getattr(final_synthesis, 'color_recommendations', {})
+                        if color_recs:
+                            state.log(f"   ├─ Color Recommendations: {len(color_recs)} suggested changes")
+                        if final_synthesis.top_3_actions:
+                            state.log(f"   └─ Top Actions: {len(final_synthesis.top_3_actions)} priorities")
                 except Exception as e:
-                    state.log(f"   ⚠️ HEAD Synthesizer failed: {str(e)[:50]}")
+                    state.log(f"   ⚠️ HEAD Synthesizer failed: {str(e)[:120]}")
+                    import traceback
+                    state.log(f"   └─ {traceback.format_exc()[:200]}")
                     final_synthesis = None
             
             # Create fallback synthesis if needed
@@ -1203,9 +1240,16 @@ async def run_stage2_analysis_v2(
             
             # Generate visual previews
             typography_preview_html = ""
+            color_ramps_preview_html = ""
+            llm_recs_html = ""
+
             try:
-                from core.preview_generator import generate_typography_preview_html
-                
+                from core.preview_generator import (
+                    generate_typography_preview_html,
+                    generate_semantic_color_ramps_html,
+                    generate_color_ramps_preview_html,
+                )
+
                 primary_font = fonts.get("primary", "Open Sans")
                 desktop_typo_dict = {
                     name: {
@@ -1216,23 +1260,89 @@ async def run_stage2_analysis_v2(
                     for name, t in state.desktop_normalized.typography.items()
                 }
                 typography_preview_html = generate_typography_preview_html(desktop_typo_dict, primary_font)
+
+                # Generate color ramps preview (semantic groups)
+                semantic_analysis = getattr(state, 'semantic_analysis', {})
+                desktop_dict_for_colors = normalized_to_dict(state.desktop_normalized)
+
+                if semantic_analysis:
+                    color_ramps_preview_html = generate_semantic_color_ramps_html(
+                        semantic_analysis=semantic_analysis,
+                        color_tokens=desktop_dict_for_colors.get("colors", {}),
+                    )
+                else:
+                    color_ramps_preview_html = generate_color_ramps_preview_html(
+                        color_tokens=desktop_dict_for_colors.get("colors", {}),
+                    )
+
+                state.log("   ✅ Color ramps preview generated")
+
             except Exception as preview_err:
-                state.log(f"   ⚠️ Preview generation failed: {str(preview_err)[:50]}")
-                typography_preview_html = "<div class='placeholder-msg'>Preview unavailable</div>"
-            
+                state.log(f"   ⚠️ Preview generation failed: {str(preview_err)[:80]}")
+                typography_preview_html = typography_preview_html or "<div class='placeholder-msg'>Preview unavailable</div>"
+                color_ramps_preview_html = "<div class='placeholder-msg'>Color ramps preview unavailable</div>"
+
+            # Generate LLM recommendations HTML
+            try:
+                # Build recs dict in the format expected by the HTML formatter
+                synth_recs = {}
+                if final_synthesis:
+                    # Convert list of color recs to dict keyed by role
+                    color_recs_dict = {}
+                    for rec in (final_synthesis.color_recommendations or []):
+                        if isinstance(rec, dict) and rec.get("role"):
+                            color_recs_dict[rec["role"]] = rec
+                    synth_recs["color_recommendations"] = color_recs_dict
+
+                    # Add AA fixes from rule engine
+                    aa_fixes = []
+                    if rule_results and rule_results.accessibility:
+                        for a in rule_results.accessibility:
+                            if not a.passes_aa_normal:
+                                aa_fixes.append(a.to_dict() if hasattr(a, 'to_dict') else {"color": str(a)})
+                    synth_recs["accessibility_fixes"] = aa_fixes
+
+                llm_recs_html = format_llm_color_recommendations_html(
+                    final_recs=synth_recs,
+                    semantic_analysis=getattr(state, 'semantic_analysis', {}),
+                )
+            except Exception as recs_err:
+                state.log(f"   ⚠️ LLM recs HTML failed: {str(recs_err)[:120]}")
+                import traceback
+                state.log(f"   └─ {traceback.format_exc()[:200]}")
+                llm_recs_html = "<div class='placeholder-msg'>LLM recommendations unavailable</div>"
+
+            # Store upgrade_recommendations for Apply Upgrades button
+            aa_failures_list = []
+            if rule_results and rule_results.accessibility:
+                aa_failures_list = [
+                    a.to_dict() for a in rule_results.accessibility
+                    if not a.passes_aa_normal
+                ]
+            state.upgrade_recommendations = {
+                "color_recommendations": (final_synthesis.color_recommendations if final_synthesis else []),
+                "accessibility_fixes": aa_failures_list,
+                "scores": (final_synthesis.scores if final_synthesis else {}),
+                "top_3_actions": (final_synthesis.top_3_actions if final_synthesis else []),
+            }
+
         except Exception as format_err:
             state.log(f"   ⚠️ Formatting failed: {str(format_err)[:100]}")
-            # Return minimal results
+            import traceback
+            state.log(traceback.format_exc()[:500])
+            # Return minimal results (must match 11 outputs)
             return (
                 f"⚠️ Analysis completed with formatting errors: {str(format_err)[:50]}",
                 state.get_logs(),
                 "*Benchmark comparison unavailable*",
-                "<div>Scores unavailable</div>",
-                "<div>Actions unavailable</div>",
+                "<div class='placeholder-msg'>Scores unavailable</div>",
+                "<div class='placeholder-msg'>Actions unavailable</div>",
                 [],
                 None,
                 None,
-                "",
+                "<div class='placeholder-msg'>Typography preview unavailable</div>",
+                "<div class='placeholder-msg'>Color ramps preview unavailable</div>",
+                "<div class='placeholder-msg'>LLM recommendations unavailable</div>",
             )
         
         progress(0.95, desc="✅ Complete!")
@@ -1277,8 +1387,10 @@ async def run_stage2_analysis_v2(
             typography_desktop_data,
             typography_mobile_data,
             typography_preview_html,
+            color_ramps_preview_html,
+            llm_recs_html,
         )
-        
+
     except Exception as e:
         import traceback
         state.log(f"❌ Critical Error: {str(e)}")
@@ -1345,17 +1457,19 @@ def create_fallback_synthesis(rule_results, benchmark_comparisons, brand_result,
 
 
 def create_stage2_error_response(error_msg: str):
-    """Create error response tuple for Stage 2."""
+    """Create error response tuple for Stage 2 (must match 11 outputs)."""
     return (
         error_msg,
         state.get_logs(),
         "",  # benchmark_md
-        "",  # scores_html
+        f"<div class='placeholder-msg'>{error_msg}</div>",  # scores_html
         "",  # actions_html
         [],  # color_recs_table
         None,  # typography_desktop
         None,  # typography_mobile
         "",  # typography_preview
+        "",  # color_ramps_preview
+        "",  # llm_recs_html
     )
 
 
@@ -3870,15 +3984,17 @@ def create_ui():
             fn=run_stage2_analysis_v2,
             inputs=[benchmark_checkboxes],
             outputs=[
-                stage2_status, 
-                stage2_log, 
+                stage2_status,
+                stage2_log,
                 benchmark_comparison_md,
                 scores_dashboard,
                 priority_actions_html,
                 color_recommendations_table,
-                typography_desktop, 
-                typography_mobile, 
+                typography_desktop,
+                typography_mobile,
                 stage2_typography_preview,
+                stage2_color_ramps_preview,
+                llm_color_recommendations,
             ],
         )