Update src/app.py

src/app.py

@@ -4,6 +4,9 @@ import numpy as np
 import re
 import io
 import base64
+import os
+import requests
+import json
 from collections import Counter
 import matplotlib.pyplot as plt
 import seaborn as sns
@@ -58,6 +61,58 @@ from reportlab.lib.units import inch
 from reportlab.graphics.charts.barcharts import VerticalBarChart
 from reportlab.graphics.shapes import Drawing
 
+# Claude Chatbot Class
+class ClaudeChatbot:
+    def __init__(self):
+        self.api_key = os.getenv('OPENROUTER_API_KEY')
+        self.base_url = "https://openrouter.ai/api/v1/chat/completions"
+        self.model = "anthropic/claude-sonnet-4"
+        
+        if not self.api_key:
+            st.error("❌ OPENROUTER_API_KEY not found in environment variables!")
+            st.info("Please set your OpenRouter API key in the environment variables.")
+    
+    def generate_response(self, prompt, context="", max_tokens=1500):
+        """Generate response using Claude via OpenRouter"""
+        if not self.api_key:
+            return "Error: API key not configured"
+        
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://your-app-url.com",  # Replace with your actual URL
+            "X-Title": "AI Resume Analyzer"
+        }
+        
+        system_prompt = """You are an expert resume and career consultant with deep knowledge of hiring practices, ATS systems, and industry requirements. You provide actionable, specific advice to help job seekers improve their resumes and career prospects. Always be encouraging but honest in your feedback."""
+        
+        if context:
+            system_prompt += f"\n\nContext about the user's resume:\n{context}"
+        
+        data = {
+            "model": self.model,
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": prompt}
+            ],
+            "max_tokens": max_tokens,
+            "temperature": 0.7
+        }
+        
+        try:
+            response = requests.post(self.base_url, headers=headers, json=data, timeout=30)
+            response.raise_for_status()
+            
+            result = response.json()
+            return result['choices'][0]['message']['content']
+        
+        except requests.exceptions.RequestException as e:
+            return f"Error connecting to API: {str(e)}"
+        except KeyError as e:
+            return f"Error parsing response: {str(e)}"
+        except Exception as e:
+            return f"Unexpected error: {str(e)}"
+
 # Download NLTK data if not already present
 @st.cache_resource
 def download_nltk_data():
@@ -146,6 +201,7 @@ def basic_grammar_check(text):
 class ResumeAnalyzer:
     def __init__(self):
         self.nlp, self.grammar_tool = init_tools()
+        self.chatbot = ClaudeChatbot()
         
         try:
             self.stop_words = set(stopwords.words('english'))
@@ -155,32 +211,55 @@ class ResumeAnalyzer:
         
         self.lemmatizer = WordNetLemmatizer()
         
-        # Job role keywords dictionary
+        # Expanded job role keywords dictionary (15 total roles)
         self.job_keywords = {
             "Data Scientist": ["python", "machine learning", "statistics", "pandas", "numpy", "scikit-learn", 
-                              "tensorflow", "pytorch", "sql", "data analysis", "visualization", "jupyter"],
+                              "tensorflow", "pytorch", "sql", "data analysis", "visualization", "jupyter", "r", "statistics", "deep learning"],
             "Software Engineer": ["programming", "java", "python", "javascript", "react", "node.js", "database",
-                                 "git", "agile", "testing", "debugging", "api", "frontend", "backend"],
+                                 "git", "agile", "testing", "debugging", "api", "frontend", "backend", "algorithms", "data structures"],
             "Product Manager": ["product", "strategy", "roadmap", "stakeholder", "analytics", "user experience",
-                               "market research", "agile", "scrum", "requirements", "metrics"],
+                               "market research", "agile", "scrum", "requirements", "metrics", "wireframes", "user stories"],
             "Marketing Manager": ["marketing", "digital marketing", "seo", "social media", "analytics", "campaigns",
-                                 "brand", "content", "advertising", "growth"],
+                                 "brand", "content", "advertising", "growth", "conversion", "roi", "crm"],
             "Data Analyst": ["sql", "excel", "python", "tableau", "power bi", "statistics", "reporting",
-                            "data visualization", "business intelligence", "analytics"]
+                            "data visualization", "business intelligence", "analytics", "dashboards", "kpi"],
+            "DevOps Engineer": ["docker", "kubernetes", "aws", "azure", "gcp", "jenkins", "ci/cd", "terraform",
+                               "ansible", "monitoring", "linux", "bash", "infrastructure", "deployment"],
+            "UI/UX Designer": ["figma", "sketch", "adobe xd", "prototyping", "wireframes", "user research",
+                              "usability testing", "design systems", "responsive design", "accessibility", "typography"],
+            "Cybersecurity Analyst": ["security", "penetration testing", "vulnerability assessment", "siem", "firewall",
+                                     "incident response", "compliance", "risk assessment", "cryptography", "network security"],
+            "Business Analyst": ["requirements gathering", "process improvement", "stakeholder management", "documentation",
+                                "business process", "gap analysis", "user stories", "workflow", "project management"],
+            "Full Stack Developer": ["html", "css", "javascript", "react", "angular", "vue", "node.js", "express",
+                                   "mongodb", "postgresql", "rest api", "graphql", "version control", "responsive design"],
+            "Machine Learning Engineer": ["tensorflow", "pytorch", "keras", "scikit-learn", "mlops", "model deployment",
+                                        "feature engineering", "model optimization", "docker", "kubernetes", "python", "deep learning"],
+            "Cloud Architect": ["aws", "azure", "gcp", "cloud migration", "serverless", "microservices", "containerization",
+                              "infrastructure as code", "cost optimization", "scalability", "security"],
+            "Sales Manager": ["sales", "crm", "lead generation", "client relationship", "negotiation", "revenue growth",
+                             "pipeline management", "forecasting", "team leadership", "quota attainment"],
+            "Project Manager": ["project management", "pmp", "agile", "scrum", "kanban", "risk management",
+                               "stakeholder communication", "budget management", "timeline", "resource allocation"],
+            "Quality Assurance Engineer": ["testing", "automation", "selenium", "junit", "test cases", "bug tracking",
+                                         "regression testing", "performance testing", "api testing", "quality standards"]
         }
         
         # Common skills database
         self.technical_skills = [
-            "python", "java", "javascript", "c++", "sql", "html", "css", "react", "angular", "vue",
+            "python", "java", "javascript", "c++", "c#", "php", "ruby", "go", "rust", "swift",
+            "sql", "html", "css", "react", "angular", "vue", "node.js", "express", "django", "flask",
             "machine learning", "deep learning", "tensorflow", "pytorch", "pandas", "numpy",
-            "docker", "kubernetes", "aws", "azure", "git", "jenkins", "ci/cd", "mongodb", "postgresql",
-            "redis", "elasticsearch", "spark", "hadoop", "tableau", "power bi", "excel"
+            "docker", "kubernetes", "aws", "azure", "gcp", "git", "jenkins", "ci/cd", "mongodb", "postgresql",
+            "redis", "elasticsearch", "spark", "hadoop", "tableau", "power bi", "excel", "figma", "sketch",
+            "linux", "bash", "terraform", "ansible", "selenium", "junit", "jira", "confluence"
         ]
         
         self.soft_skills = [
             "leadership", "communication", "teamwork", "problem solving", "critical thinking",
             "project management", "time management", "adaptability", "creativity", "analytical",
-            "collaboration", "innovation", "strategic thinking", "customer service", "negotiation"
+            "collaboration", "innovation", "strategic thinking", "customer service", "negotiation",
+            "presentation", "mentoring", "conflict resolution", "decision making", "emotional intelligence"
         ]
 
     def extract_text_from_pdf(self, file):
@@ -406,6 +485,32 @@ class ResumeAnalyzer:
         
         return summary
 
+    def get_claude_analysis(self, text, sections, job_role, ats_score, match_percentage):
+        """Get detailed analysis from Claude"""
+        context = f"""
+        Resume Analysis Data:
+        - Target Role: {job_role}
+        - ATS Score: {ats_score}/100
+        - Role Match: {match_percentage:.1f}%
+        - Word Count: {len(text.split())}
+        - Sections Found: {list(sections.keys())}
+        - Resume Text (first 2000 chars): {text[:2000]}
+        """
+        
+        prompt = f"""
+        Please provide a comprehensive analysis of this resume for a {job_role} position. Include:
+        
+        1. **Strengths**: What are the standout elements?
+        2. **Improvement Areas**: Specific areas that need work
+        3. **Missing Elements**: Key components that should be added
+        4. **Industry-Specific Advice**: Tailored recommendations for {job_role}
+        5. **Action Items**: 3-5 concrete steps to improve the resume
+        
+        Keep the analysis professional, constructive, and actionable.
+        """
+        
+        return self.chatbot.generate_response(prompt, context)
+
     def create_pdf_report(self, text, sections, ats_score, match_percentage, selected_role, tech_skills, soft_skills, found_keywords):
         """Create a PDF report using ReportLab"""
         buffer = io.BytesIO()
@@ -462,17 +567,17 @@ class ResumeAnalyzer:
 
 def main():
     st.set_page_config(
-        page_title="AI Resume Analyzer",
+        page_title="AI Resume Analyzer with Claude",
         page_icon="📄",
         layout="wide"
     )
     
-    st.title("🚀 AI-Powered Resume Analyzer")
-    st.markdown("Upload your resume and get comprehensive analysis with actionable insights!")
+    st.title("🚀 AI-Powered Resume Analyzer with Claude Assistant")
+    st.markdown("Upload your resume and get comprehensive analysis with AI-powered insights!")
     
-    # Show dependency status
-    with st.expander("📋 Dependency Status", expanded=False):
-        col1, col2, col3 = st.columns(3)
+    # Show dependency and API status
+    with st.expander("📋 System Status", expanded=False):
+        col1, col2, col3, col4 = st.columns(4)
         with col1:
             if SPACY_AVAILABLE:
                 st.success("✅ spaCy Available")
@@ -490,6 +595,12 @@ def main():
                 st.success("✅ Grammar Tool Available")
             else:
                 st.warning("⚠️ Grammar Tool Not Available")
+        
+        with col4:
+            if os.getenv('OPENROUTER_API_KEY'):
+                st.success("✅ Claude API Available")
+            else:
+                st.error("❌ Claude API Not Available")
     
     # Initialize analyzer
     analyzer = ResumeAnalyzer()
@@ -499,6 +610,12 @@ def main():
     job_roles = list(analyzer.job_keywords.keys())
     selected_role = st.sidebar.selectbox("Select Target Job Role:", job_roles)
     
+    # Initialize session state for chat
+    if "chat_history" not in st.session_state:
+        st.session_state.chat_history = []
+    if "resume_context" not in st.session_state:
+        st.session_state.resume_context = ""
+    
     # File upload section
     st.header("📁 Upload Your Resume")
     uploaded_file = st.file_uploader(
@@ -523,6 +640,9 @@ def main():
             # Process the resume
             st.success("✅ Resume uploaded and processed successfully!")
             
+            # Store resume context for chatbot
+            st.session_state.resume_context = text
+            
             # Extract data for analysis
             sections = analyzer.extract_sections(text)
             tech_skills, soft_skills = analyzer.extract_skills(text)
@@ -530,9 +650,9 @@ def main():
             ats_score = analyzer.calculate_ats_score(text, sections)
             
             # Create tabs for different analyses
-            tab1, tab2, tab3, tab4, tab5 = st.tabs([
+            tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs([
                 "📊 Overview", "🎯 Skills Analysis", "📝 Section Breakdown", 
-                "🔍 ATS Analysis", "📋 Report & Suggestions"
+                "🔍 ATS Analysis", "📋 Report & Suggestions", "🤖 AI Assistant"
             ])
             
             with tab1:
@@ -588,8 +708,29 @@ def main():
                         skills_text = " • ".join(tech_skills)
                         st.success(f"Found {len(tech_skills)} technical skills:")
                         st.write(skills_text)
+                        
+                        # Skills distribution chart
+                        if len(tech_skills) > 5:
+                            skills_df = pd.DataFrame({
+                                'Skill': tech_skills[:10],
+                                'Count': [1] * len(tech_skills[:10])
+                            })
+                            fig = px.pie(skills_df, values='Count', names='Skill', 
+                                       title='Technical Skills Distribution')
+                            st.plotly_chart(fig, use_container_width=True)
+                        else:
+                            # Simple bar chart for fewer skills
+                            skills_df = pd.DataFrame({
+                                'Skill': tech_skills,
+                                'Count': [1] * len(tech_skills)
+                            })
+                            fig = px.bar(skills_df, x='Skill', y='Count', 
+                                       title='Technical Skills Found')
+                            fig.update_xaxis(tickangle=45)
+                            st.plotly_chart(fig, use_container_width=True)
                     else:
-                        st.info("No technical skills detected")
+                        st.warning("No technical skills detected")
+                        st.info("💡 Consider adding technical skills relevant to your field")
                 
                 with col2:
                     st.subheader("🤝 Soft Skills")
@@ -597,63 +738,99 @@ def main():
                         skills_text = " • ".join(soft_skills)
                         st.success(f"Found {len(soft_skills)} soft skills:")
                         st.write(skills_text)
+                        
+                        # Soft skills chart
+                        if len(soft_skills) > 3:
+                            soft_df = pd.DataFrame({
+                                'Skill': soft_skills[:8],
+                                'Count': [1] * len(soft_skills[:8])
+                            })
+                            fig = px.bar(soft_df, x='Skill', y='Count', 
+                                       title='Soft Skills Found',
+                                       color='Skill')
+                            fig.update_xaxis(tickangle=45)
+                            st.plotly_chart(fig, use_container_width=True)
+                        else:
+                            # Display as simple list for fewer skills
+                            for skill in soft_skills:
+                                st.write(f"✅ {skill}")
                     else:
-                        st.info("No soft skills detected")
+                        st.warning("No soft skills detected")
+                        st.info("💡 Consider highlighting leadership, communication, and teamwork skills")
                 
-                # Job role matching
-                st.subheader(f"🎯 Match Analysis for {selected_role}")
+                # Skills comparison section
+                st.subheader("📊 Skills Overview")
                 
-                # Progress bar for match percentage
-                st.metric("Match Percentage", f"{match_percentage:.1f}%")
-                st.progress(match_percentage / 100)
+                # Create metrics row
+                col1, col2, col3, col4 = st.columns(4)
                 
-                if found_keywords:
-                    st.write("**Found Keywords:**")
-                    keywords_text = " • ".join(found_keywords)
-                    st.success(keywords_text)
+                with col1:
+                    st.metric("Technical Skills", len(tech_skills))
                 
-                # Skills gap analysis
-                missing_keywords = [kw for kw in analyzer.job_keywords[selected_role] if kw not in found_keywords]
-                if missing_keywords:
-                    st.write("**Missing Keywords (Consider Adding):**")
-                    missing_text = " • ".join(missing_keywords[:10])  # Show top 10
-                    st.warning(missing_text)
-            
-            with tab3:
-                st.header("Section Breakdown")
+                with col2:
+                    st.metric("Soft Skills", len(soft_skills))
                 
-                for section_name, content in sections.items():
-                    if content:
-                        with st.expander(f"📋 {section_name.title()} Section"):
-                            st.text_area(f"{section_name} content", content, height=150, disabled=True)
+                with col3:
+                    total_skills = len(tech_skills) + len(soft_skills)
+                    st.metric("Total Skills", total_skills)
+                
+                with col4:
+                    # Calculate skills balance
+                    if total_skills > 0:
+                        tech_ratio = len(tech_skills) / total_skills * 100
+                        st.metric("Tech/Soft Ratio", f"{tech_ratio:.0f}%/{100-tech_ratio:.0f}%")
                     else:
-                        st.warning(f"❌ {section_name.title()} section not found or empty")
-            
-            with tab4:
-                st.header("ATS Analysis")
+                        st.metric("Tech/Soft Ratio", "0%/0%")
+                
+                # Skills recommendations
+                st.subheader("💡 Skills Recommendations")
+                
+                recommendations = []
+                
+                # Technical skills recommendations
+                if len(tech_skills) < 5:
+                    recommendations.append("📈 Add more technical skills relevant to your field")
+                
+                # Soft skills recommendations
+                if len(soft_skills) < 3:
+                    recommendations.append("🤝 Highlight more soft skills like leadership and communication")
+                
+                # Balance recommendations
+                if len(tech_skills) > 0 and len(soft_skills) == 0:
+                    recommendations.append("⚖️ Balance technical skills with soft skills")
+                elif len(soft_skills) > 0 and len(tech_skills) == 0:
+                    recommendations.append("⚖️ Add technical skills to complement your soft skills")
+                
+                if recommendations:
+                    for rec in recommendations:
+                        st.info(rec)
+                else:
+                    st.success("✅ Good balance of technical and soft skills!")
+                
+                # Role-specific keyword analysis
+                st.subheader(f"🎯 {selected_role} Keywords Analysis")
                 
                 col1, col2 = st.columns(2)
                 
                 with col1:
-                    # ATS Score gauge
+                    # Match percentage visualization
                     fig = go.Figure(go.Indicator(
-                        mode="gauge+number+delta",
-                        value=ats_score,
-                        domain={'x': [0, 1], 'y': [0, 1]},
-                        title={'text': "ATS Friendliness Score"},
-                        delta={'reference': 80},
-                        gauge={
+                        mode = "gauge+number",
+                        value = match_percentage,
+                        domain = {'x': [0, 1], 'y': [0, 1]},
+                        title = {'text': f"{selected_role} Match"},
+                        gauge = {
                             'axis': {'range': [None, 100]},
-                            'bar': {'color': "darkblue"},
+                            'bar': {'color': "darkgreen"},
                             'steps': [
-                                {'range': [0, 50], 'color': "lightgray"},
-                                {'range': [50, 80], 'color': "yellow"},
-                                {'range': [80, 100], 'color': "green"}
+                                {'range': [0, 40], 'color': "lightcoral"},
+                                {'range': [40, 70], 'color': "yellow"},
+                                {'range': [70, 100], 'color': "lightgreen"}
                             ],
                             'threshold': {
                                 'line': {'color': "red", 'width': 4},
                                 'thickness': 0.75,
-                                'value': 90
+                                'value': 80
                             }
                         }
                     ))
@@ -661,153 +838,110 @@ def main():
                     st.plotly_chart(fig, use_container_width=True)
                 
                 with col2:
-                    # Grammar check
-                    st.subheader("📝 Grammar Check")
-                    grammar_errors = analyzer.grammar_check(text)
+                    st.metric("Keywords Found", len(found_keywords))
+                    st.metric("Match Percentage", f"{match_percentage:.1f}%")
                     
-                    if grammar_errors:
-                        st.warning(f"Found {len(grammar_errors)} potential issues")
-                        for i, error in enumerate(grammar_errors[:5]):  # Show first 5
-                            st.text(f"{i+1}. {error.message}")
+                    # Match level indicator
+                    if match_percentage >= 80:
+                        st.success("🎉 Excellent match!")
+                    elif match_percentage >= 60:
+                        st.warning("👍 Good match")
+                    elif match_percentage >= 40:
+                        st.warning("⚠️ Fair match")
                     else:
-                        st.success("✅ No major grammar issues detected")
-                
-                # ATS recommendations
-                st.subheader("💡 ATS Improvement Suggestions")
-                recommendations = []
-                
-                if ats_score < 70:
-                    recommendations.extend([
-                        "Add more bullet points to improve readability",
-                        "Include contact information (email, phone)",
-                        "Ensure all major sections are present",
-                        "Use standard section headings"
-                    ])
-                
-                if match_percentage < 60:
-                    recommendations.append(f"Include more {selected_role}-specific keywords")
+                        st.error("❌ Poor match")
                 
-                if len(text.split()) < 300:
-                    recommendations.append("Consider adding more detailed descriptions")
-                
-                for rec in recommendations:
-                    st.write(f"• {rec}")
-            
-            with tab5:
-                st.header("Comprehensive Report & Suggestions")
-                
-                # Overall scores
-                col1, col2, col3 = st.columns(3)
-                
-                with col1:
-                    st.metric("ATS Score", f"{ats_score}/100", 
-                             delta=f"{ats_score-70} vs Average" if ats_score >= 70 else f"{ats_score-70} vs Average")
-                
-                with col2:
-                    st.metric("Role Match", f"{match_percentage:.1f}%",
-                             delta=f"{match_percentage-60:.1f}% vs Good Match" if match_percentage >= 60 else f"{match_percentage-60:.1f}% vs Good Match")
+                # Keywords found section
+                if found_keywords:
+                    st.subheader("✅ Keywords Found")
+                    
+                    # Display found keywords in a nice format
+                    keyword_cols = st.columns(3)
+                    for i, keyword in enumerate(found_keywords):
+                        with keyword_cols[i % 3]:
+                            st.success(f"✓ {keyword}")
+                else:
+                    st.warning("��� No role-specific keywords found")
+                
+                # Missing keywords section
+                all_keywords = analyzer.job_keywords[selected_role]
+                missing_keywords = [kw for kw in all_keywords if kw not in found_keywords]
                 
-                with col3:
-                    overall_score = (ats_score + match_percentage) / 2
-                    st.metric("Overall Score", f"{overall_score:.1f}/100")
-                
-                # Detailed feedback
-                st.subheader("📋 Detailed Feedback")
-                
-                # Strengths
-                strengths = []
-                if ats_score >= 80:
-                    strengths.append("Resume is ATS-friendly")
-                if match_percentage >= 70:
-                    strengths.append(f"Strong match for {selected_role} position")
-                if len(tech_skills) >= 5:
-                    strengths.append("Rich technical skill set")
-                if len(sections) >= 4:
-                    strengths.append("Well-structured with multiple sections")
-                
-                if strengths:
-                    st.success("**Strengths:**")
-                    for strength in strengths:
-                        st.write(f"✅ {strength}")
-                
-                # Areas for improvement
-                improvements = []
-                if ats_score < 70:
-                    improvements.append("Improve ATS compatibility")
-                if match_percentage < 60:
-                    improvements.append("Add more role-specific keywords")
-                if not sections.get('projects'):
-                    improvements.append("Consider adding a projects section")
-                if len(soft_skills) < 3:
-                    improvements.append("Highlight more soft skills")
+                if missing_keywords:
+                    st.subheader("🔍 Suggested Keywords to Add")
+                    st.info(f"Consider adding these {selected_role}-specific keywords to improve your match score:")
+                    
+                    # Show missing keywords in expandable sections
+                    with st.expander(f"View all {len(missing_keywords)} missing keywords", expanded=len(missing_keywords) <= 10):
+                        missing_cols = st.columns(3)
+                        for i, keyword in enumerate(missing_keywords):
+                            with missing_cols[i % 3]:
+                                st.write(f"📝 {keyword}")
                 
-                if improvements:
-                    st.warning("**Areas for Improvement:**")
-                    for improvement in improvements:
-                        st.write(f"⚠️ {improvement}")
+                # Skills gap analysis
+                st.subheader("📋 Skills Gap Analysis")
                 
-                # Generate downloadable report
-                st.subheader("📄 Download Report")
+                # Calculate skills coverage for the role
+                role_technical_skills = [skill for skill in analyzer.technical_skills 
+                                       if skill in analyzer.job_keywords[selected_role]]
                 
-                col1, col2 = st.columns(2)
+                found_role_skills = [skill for skill in tech_skills if skill in role_technical_skills]
+                missing_role_skills = [skill for skill in role_technical_skills if skill not in tech_skills]
                 
-                with col1:
-                    # Text report
-                    report_content = f"""
-RESUME ANALYSIS REPORT
-Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-
-OVERVIEW:
-- ATS Score: {ats_score}/100
-- Role Match: {match_percentage:.1f}%
-- Overall Score: {overall_score:.1f}/100
-
-PERSONA SUMMARY:
-{analyzer.generate_persona_summary(text, sections)}
-
-TECHNICAL SKILLS FOUND:
-{', '.join(tech_skills) if tech_skills else 'None detected'}
-
-SOFT SKILLS FOUND:
-{', '.join(soft_skills) if soft_skills else 'None detected'}
-
-ROLE-SPECIFIC KEYWORDS FOUND:
-{', '.join(found_keywords) if found_keywords else 'None found'}
-
-STRENGTHS:
-{chr(10).join(f'- {s}' for s in strengths)}
-
-AREAS FOR IMPROVEMENT:
-{chr(10).join(f'- {i}' for i in improvements)}
-                    """
+                if role_technical_skills:
+                    coverage_percentage = (len(found_role_skills) / len(role_technical_skills)) * 100
                     
-                    st.download_button(
-                        label="📥 Download Text Report",
-                        data=report_content,
-                        file_name=f"resume_analysis_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt",
-                        mime="text/plain"
-                    )
-                
-                with col2:
-                    # PDF report
-                    if st.button("Generate PDF Report"):
-                        try:
-                            pdf_buffer = analyzer.create_pdf_report(
-                                text, sections, ats_score, match_percentage, 
-                                selected_role, tech_skills, soft_skills, found_keywords
-                            )
-                            
-                            st.download_button(
-                                label="📄 Download PDF Report",
-                                data=pdf_buffer.getvalue(),
-                                file_name=f"resume_analysis_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf",
-                                mime="application/pdf"
-                            )
-                        except Exception as e:
-                            st.error(f"Error generating PDF: {str(e)}")
-                            st.info("PDF generation requires all ReportLab dependencies. Using text report as fallback.")
-        else:
-            st.error("❌ Error processing the uploaded file. Please try a different file.")
-
-if __name__ == "__main__":
-    main()
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        st.metric("Role Skills Coverage", f"{coverage_percentage:.1f}%")
+                        
+                        if coverage_percentage >= 80:
+                            st.success("🎯 Excellent coverage of role-specific skills!")
+                        elif coverage_percentage >= 60:
+                            st.warning("👍 Good coverage, consider adding a few more")
+                        else:
+                            st.error("⚠️ Low coverage, focus on adding role-specific skills")
+                    
+                    with col2:
+                        if missing_role_skills:
+                            st.write("**Priority skills to add:**")
+                            for skill in missing_role_skills[:5]:
+                                st.write(f"🎯 {skill}")
+                        else:
+                            st.success("✅ All key role skills covered!")
+                
+                # Skills trend analysis (if we had historical data)
+                st.subheader("📈 Skills Insights")
+                
+                insights = []
+                
+                # Programming languages analysis
+                programming_langs = ['python', 'java', 'javascript', 'c++', 'c#', 'php', 'ruby', 'go']
+                found_langs = [lang for lang in programming_langs if lang in [s.lower() for s in tech_skills]]
+                
+                if len(found_langs) >= 3:
+                    insights.append(f"💻 Strong programming portfolio with {len(found_langs)} languages")
+                elif len(found_langs) >= 1:
+                    insights.append(f"💻 Programming experience in {', '.join(found_langs)}")
+                
+                # Cloud skills analysis
+                cloud_skills = ['aws', 'azure', 'gcp', 'docker', 'kubernetes']
+                found_cloud = [skill for skill in cloud_skills if skill in [s.lower() for s in tech_skills]]
+                
+                if found_cloud:
+                    insights.append(f"☁️ Cloud-ready with {', '.join(found_cloud)} experience")
+                
+                # Data skills analysis
+                data_skills = ['sql', 'python', 'tableau', 'power bi', 'excel', 'pandas', 'numpy']
+                found_data = [skill for skill in data_skills if skill in [s.lower() for s in tech_skills]]
+                
+                if len(found_data) >= 3:
+                    insights.append(f"📊 Strong data analysis capabilities")
+                
+                if insights:
+                    for insight in insights:
+                        st.info(insight)
+                else:
+                    st.info("💡 Add more technical skills to unlock insights about your profile")
+