Major visual improvements: stunning outputs, downloadable exports, enhanced UI

agents.py

@@ -103,24 +103,35 @@ class AnalysisAgent(BaseAgent):
         # Calculate dynamic tokens
         max_tokens = self._calculate_dynamic_tokens(prompt, len(text))
         
-        system = """You are AnalysisAgent: produce crisp, visually appealing, and highly readable insights. 
+        system = """You are AnalysisAgent: produce stunning, visually rich, and highly engaging insights. 
 
-CRITICAL FORMATTING REQUIREMENTS:
-- Use clear section headers with emojis (## 📋 Key Points, ## 🔍 Analysis, etc.)
-- Create concise bullet points (max 1 line each)
-- Use tables for data comparison when appropriate
-- Include visual separators (---) between major sections
-- Use **bold** for key concepts and numbers
-- Keep sections short and scannable
-- Prioritize actionable insights over lengthy explanations
+CRITICAL VISUAL FORMATTING REQUIREMENTS:
+- Use beautiful section headers with emojis and clear hierarchy
+- Create visually appealing bullet points with icons (• ✅ ❌ ⚠️ 💡 🎯 📊)
+- Use tables extensively for data comparison and organization
+- Include progress bars, metrics cards, and visual separators
+- Use **bold** for key concepts, numbers, and important data
+- Create infographic-style summaries with visual elements
+- Use color coding and visual hierarchy throughout
+- Include actionable insights with clear visual indicators
 
 CONTENT REQUIREMENTS:
-- Be concise and to the point
-- Use simple language even for technical topics
-- Include specific numbers, percentages, and metrics
-- Provide clear next steps or recommendations
-- Structure information for quick scanning
-- Focus on what matters most to the user"""
+- Be concise but comprehensive - every word counts
+- Use simple language with technical depth when needed
+- Include specific numbers, percentages, and metrics prominently
+- Provide clear next steps with visual callouts
+- Structure information for instant scanning and understanding
+- Focus on what matters most with visual emphasis
+- Create engaging, professional presentations
+
+VISUAL ELEMENTS TO USE:
+- 📊 Data visualizations and metrics
+- 🎯 Key insights with visual emphasis
+- ✅ Success indicators and achievements
+- ⚠️ Important warnings and considerations
+- 💡 Actionable recommendations
+- 📈 Trends and comparisons
+- 🔍 Detailed analysis sections"""
         
         try:
             response = await call_openai_chat(

app.py

@@ -2,9 +2,11 @@
 import os
 import asyncio
 import uuid
+import re
 from pathlib import Path
 from typing import Optional, List, Tuple
 import time
+from datetime import datetime
 
 import gradio as gr
 from agents import (
@@ -159,7 +161,7 @@ def handle_batch_analysis(files, prompt, username="anonymous"):
         return f"Error during batch analysis: {str(e)}", None, None
 
 def handle_export(result_text, export_format, username="anonymous"):
-    """Handle export of analysis results"""
+    """Handle export of analysis results with downloadable files"""
     if not result_text or result_text.strip() == "":
         return "No content to export.", None
     
@@ -167,19 +169,47 @@ def handle_export(result_text, export_format, username="anonymous"):
         return "Export functionality not available.", None
     
     try:
+        # Create a unique filename
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"analysis_{username}_{timestamp}.{export_format}"
+        
         if export_format == "txt":
-            filepath = EXPORT_MANAGER.export_text(result_text, username=username)
+            # Create a clean text version without HTML
+            clean_text = re.sub(r'<[^>]+>', '', result_text)  # Remove HTML tags
+            clean_text = re.sub(r'\n\s*\n', '\n\n', clean_text)  # Clean up spacing
+            filepath = EXPORT_MANAGER.export_text(clean_text, filename=filename)
         elif export_format == "json":
-            data = {"analysis": result_text, "exported_by": username, "timestamp": time.time()}
-            filepath = EXPORT_MANAGER.export_json(data, username=username)
+            data = {
+                "analysis": result_text,
+                "exported_by": username,
+                "timestamp": time.time(),
+                "export_date": datetime.now().isoformat(),
+                "format": export_format
+            }
+            filepath = EXPORT_MANAGER.export_json(data, filename=filename)
         elif export_format == "pdf":
-            filepath = EXPORT_MANAGER.export_pdf(result_text, username=username)
+            filepath = EXPORT_MANAGER.export_pdf(result_text, filename=filename)
         else:
             return f"Unsupported export format: {export_format}", None
         
-        return f"✅ Export successful! File saved to: {filepath}", filepath
+        # Return success message with download info
+        success_msg = f"""
+        <div style="background: #d4edda; border: 1px solid #c3e6cb; border-radius: 8px; padding: 15px; margin: 10px 0;">
+        <h4 style="color: #155724; margin: 0 0 10px 0;">✅ Export Successful!</h4>
+        <p style="color: #155724; margin: 0 0 10px 0;">Your analysis has been exported as <strong>{export_format.upper()}</strong> format.</p>
+        <p style="color: #155724; margin: 0; font-size: 14px;">Filename: <code>{filename}</code></p>
+        </div>
+        """
+        
+        return success_msg, filepath
     except Exception as e:
-        return f"❌ Export failed: {str(e)}", None
+        error_msg = f"""
+        <div style="background: #f8d7da; border: 1px solid #f5c6cb; border-radius: 8px; padding: 15px; margin: 10px 0;">
+        <h4 style="color: #721c24; margin: 0 0 10px 0;">❌ Export Failed</h4>
+        <p style="color: #721c24; margin: 0;">Error: {str(e)}</p>
+        </div>
+        """
+        return error_msg, None
 
 def get_custom_prompts():
     """Get available custom prompts"""
@@ -261,14 +291,25 @@ with gr.Blocks(title="PDF Analysis & Orchestrator", theme=gr.themes.Soft()) as d
                 
                 with gr.Column(scale=1):
                     # Export Section
-                    with gr.Accordion("💾 Export Results", open=False):
+                    with gr.Accordion("💾 Export & Download", open=True):
+                        gr.Markdown("**Download your analysis in multiple formats:**")
                         export_format = gr.Dropdown(
                             choices=["txt", "json", "pdf"],
-                            label="Export Format",
-                            value="txt"
+                            label="📄 Export Format",
+                            value="txt",
+                            info="Choose your preferred format"
                         )
-                        export_btn = gr.Button("📥 Export", variant="secondary")
-                        export_status = gr.Textbox(label="Export Status", interactive=False)
+                        export_btn = gr.Button("📥 Generate Download", variant="secondary", size="lg")
+                        export_status = gr.Markdown(
+                            value="**Ready to export** - Click the button above to generate downloadable files",
+                            label="Export Status"
+                        )
+                        
+                        # Download section
+                        gr.Markdown("**📁 Download Options:**")
+                        gr.Markdown("• **TXT**: Clean text format for easy reading")
+                        gr.Markdown("• **JSON**: Structured data with metadata")
+                        gr.Markdown("• **PDF**: Professional formatted document")
 
         # Batch Processing Tab
         with gr.Tab("📚 Batch Processing"):

utils/visual_output.py

@@ -123,22 +123,30 @@ class VisualOutputGenerator:
         return chart
     
     def create_key_points(self, points: List[str], title: str = "Key Points") -> str:
-        """Create a visually appealing key points section"""
+        """Create a stunning key points section with visual elements"""
         if not points:
             return ""
         
+        # Icons for different types of points
+        icons = ["🎯", "💡", "✅", "📊", "⚡", "🔍", "🚀", "💎", "⭐", "🔥"]
+        
         visual = f"""
 ## 💡 {title}
 
-<div style="display: grid; gap: 15px; margin: 20px 0;">
+<div style="display: grid; gap: 20px; margin: 25px 0;">
 """
         
         for i, point in enumerate(points, 1):
+            icon = icons[i % len(icons)]
+            color = ["#007bff", "#28a745", "#ffc107", "#dc3545", "#6f42c1"][i % 5]
+            
             visual += f"""
-<div style="background: #f8f9fa; border-left: 4px solid #007bff; padding: 15px; border-radius: 0 8px 8px 0; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
-<div style="display: flex; align-items: flex-start;">
-<span style="background: #007bff; color: white; border-radius: 50%; width: 24px; height: 24px; display: flex; align-items: center; justify-content: center; font-weight: bold; margin-right: 12px; flex-shrink: 0;">{i}</span>
-<p style="margin: 0; line-height: 1.5;">{point}</p>
+<div style="background: linear-gradient(135deg, {color}15, {color}05); border: 2px solid {color}30; padding: 20px; border-radius: 12px; box-shadow: 0 4px 12px rgba(0,0,0,0.1); transition: transform 0.2s ease;">
+<div style="display: flex; align-items: flex-start; gap: 15px;">
+<div style="background: {color}; color: white; border-radius: 50%; width: 32px; height: 32px; display: flex; align-items: center; justify-content: center; font-size: 16px; font-weight: bold; flex-shrink: 0; box-shadow: 0 2px 8px {color}50;">{icon}</div>
+<div style="flex: 1;">
+<p style="margin: 0; line-height: 1.6; font-size: 16px; color: #333; font-weight: 500;">{point}</p>
+</div>
 </div>
 </div>
 """
@@ -195,36 +203,94 @@ class VisualOutputGenerator:
         return cards
     
     def format_analysis_with_visuals(self, analysis_text: str, document_metadata: Dict[str, Any] = None) -> str:
-        """Format analysis text with visual elements"""
-        # Extract key information for visual representation
+        """Format analysis text with stunning visual elements"""
         visual_elements = []
         
         # Add document info if available
         if document_metadata:
             visual_elements.append(self.create_metric_cards({
-                "Pages": document_metadata.get('page_count', 'Unknown'),
-                "File Size": f"{document_metadata.get('file_size', 0) / 1024:.1f} KB",
-                "Processing Time": f"{document_metadata.get('processing_time', 0):.1f}s"
-            }, "Document Information"))
+                "📄 Pages": document_metadata.get('page_count', 'Unknown'),
+                "💾 File Size": f"{document_metadata.get('file_size', 0) / 1024:.1f} KB",
+                "⚡ Processing": f"{document_metadata.get('processing_time', 0):.1f}s",
+                "🎯 Tokens": document_metadata.get('tokens_used', 'N/A')
+            }, "📊 Document Overview"))
+        
+        # Create a beautiful header
+        visual_elements.append(self.create_analysis_header())
         
         # Try to extract key points from analysis
         key_points = self._extract_key_points(analysis_text)
         if key_points:
-            visual_elements.append(self.create_key_points(key_points))
+            visual_elements.append(self.create_key_points(key_points, "🎯 Key Insights"))
         
         # Try to extract metrics
         metrics = self._extract_metrics(analysis_text)
         if metrics:
-            visual_elements.append(self.create_metric_cards(metrics, "Key Metrics"))
+            visual_elements.append(self.create_metric_cards(metrics, "📈 Key Metrics"))
         
-        # Combine visual elements with analysis
-        result = analysis_text
+        # Try to extract data for tables
+        table_data = self._extract_table_data(analysis_text)
+        if table_data:
+            visual_elements.append(self.create_data_table(table_data, "📋 Data Summary"))
         
-        if visual_elements:
-            result = "\n\n".join(visual_elements) + "\n\n---\n\n" + analysis_text
+        # Format the main analysis with better structure
+        formatted_analysis = self._format_analysis_text(analysis_text)
+        
+        # Combine all elements
+        result = "\n\n".join(visual_elements)
+        if formatted_analysis:
+            result += f"\n\n---\n\n{formatted_analysis}"
         
         return result
     
+    def create_analysis_header(self) -> str:
+        """Create a beautiful analysis header"""
+        return """
+<div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 25px; border-radius: 15px; color: white; margin: 20px 0; text-align: center; box-shadow: 0 8px 32px rgba(0,0,0,0.1);">
+<h1 style="margin: 0 0 10px 0; font-size: 28px; font-weight: 700;">📄 AI Document Analysis</h1>
+<p style="margin: 0; font-size: 16px; opacity: 0.9;">Powered by Advanced AI • Instant Insights • Professional Results</p>
+</div>
+"""
+    
+    def _format_analysis_text(self, text: str) -> str:
+        """Format analysis text with better visual structure"""
+        # Split into sections
+        sections = text.split('\n\n')
+        formatted_sections = []
+        
+        for section in sections:
+            if section.strip():
+                # Check if it's a header
+                if section.startswith('##'):
+                    formatted_sections.append(f"\n{section}\n")
+                else:
+                    # Format as a content block
+                    formatted_sections.append(f"""
+<div style="background: #f8f9fa; border-left: 4px solid #007bff; padding: 20px; margin: 15px 0; border-radius: 0 8px 8px 0; box-shadow: 0 2px 8px rgba(0,0,0,0.05);">
+{section}
+</div>
+""")
+        
+        return '\n'.join(formatted_sections)
+    
+    def _extract_table_data(self, text: str) -> List[Dict[str, Any]]:
+        """Extract data that can be formatted as tables"""
+        table_data = []
+        
+        # Look for comparison patterns
+        comparison_pattern = r'(\w+):\s*(\d+(?:\.\d+)?%?)\s*vs\s*(\w+):\s*(\d+(?:\.\d+)?%?)'
+        matches = re.findall(comparison_pattern, text, re.IGNORECASE)
+        
+        for match in matches:
+            table_data.append({
+                "Metric": match[0],
+                "Value": match[1],
+                "Comparison": match[2],
+                "Value 2": match[3]
+            })
+        
+        return table_data
+    
     def _extract_key_points(self, text: str) -> List[str]:
         """Extract key points from analysis text"""
         # Look for bullet points, numbered lists, or key findings