Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,687 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import json
+from langchain_core.prompts import ChatPromptTemplate
+from pydantic import BaseModel, Field
+from langchain_openai import ChatOpenAI
+from langchain_community.document_loaders import WebBaseLoader
+import pdfplumber
+import PyPDF2
+import fitz  # PyMuPDF
+from PIL import Image
+import easyocr
+import os
+import tempfile
+import re
+import io
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# Fix for Windows OpenMP conflict
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+
+# Set USER_AGENT to avoid warnings
+os.environ["USER_AGENT"] = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+
+# Set page configuration
+st.set_page_config(
+    page_title="ATS_Assassin",
+    page_icon="📄",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better styling
+st.markdown("""
+<style>
+    .main {
+        padding: 0rem 1rem;
+    }
+    .stAlert {
+        margin-top: 1rem;
+    }
+    
+    /* Enhanced score card styling */
+    .score-card {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 2rem;
+        border-radius: 20px;
+        text-align: center;
+        margin: 0.5rem;
+        box-shadow: 0 10px 20px rgba(0,0,0,0.1);
+        transition: transform 0.3s ease, box-shadow 0.3s ease;
+        position: relative;
+        overflow: hidden;
+    }
+    
+    .score-card:hover {
+        transform: translateY(-5px);
+        box-shadow: 0 15px 30px rgba(0,0,0,0.2);
+    }
+    
+    .score-card::before {
+        content: "";
+        position: absolute;
+        top: -50%;
+        left: -50%;
+        width: 200%;
+        height: 200%;
+        background: radial-gradient(circle, rgba(255,255,255,0.1) 0%, transparent 70%);
+        animation: shimmer 3s infinite;
+    }
+    
+    @keyframes shimmer {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
+    }
+    
+    .score-card-initial {
+        background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+    }
+    
+    .score-card-improved {
+        background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+    }
+    
+    .score-card-improvement {
+        background: linear-gradient(135deg, #fa709a 0%, #fee140 100%);
+    }
+    
+    .score-label {
+        color: white;
+        font-size: 0.9rem;
+        font-weight: 500;
+        margin-bottom: 0.5rem;
+        opacity: 0.9;
+    }
+    
+    .score-value {
+        color: white;
+        font-size: 2.5rem;
+        font-weight: bold;
+        margin-bottom: 0.5rem;
+        text-shadow: 2px 2px 4px rgba(0,0,0,0.2);
+    }
+    
+    .score-delta {
+        color: white;
+        font-size: 1.2rem;
+        font-weight: 600;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        gap: 0.3rem;
+    }
+    
+    .arrow-up {
+        width: 0;
+        height: 0;
+        border-left: 8px solid transparent;
+        border-right: 8px solid transparent;
+        border-bottom: 12px solid #4ade80;
+        display: inline-block;
+        animation: bounce 2s infinite;
+    }
+    
+    @keyframes bounce {
+        0%, 100% { transform: translateY(0); }
+        50% { transform: translateY(-5px); }
+    }
+    
+    /* Progress ring for scores */
+    .progress-ring {
+        position: relative;
+        width: 120px;
+        height: 120px;
+        margin: 0 auto 1rem auto;
+    }
+    
+    .progress-ring-circle {
+        stroke: rgba(255,255,255,0.3);
+        fill: transparent;
+        stroke-width: 8;
+    }
+    
+    .progress-ring-circle-progress {
+        stroke: white;
+        fill: transparent;
+        stroke-width: 8;
+        stroke-linecap: round;
+        transform: rotate(-90deg);
+        transform-origin: 50% 50%;
+        transition: stroke-dashoffset 1s ease-in-out;
+    }
+    
+    .section-header {
+        background-color: #e9ecef;
+        padding: 0.5rem 1rem;
+        border-radius: 5px;
+        margin: 0.5rem 0;
+        cursor: pointer;
+    }
+    
+    .section-content {
+        padding: 1rem;
+        background-color: #ffffff;
+        border: 1px solid #dee2e6;
+        border-radius: 5px;
+        margin-bottom: 1rem;
+    }
+    
+    /* Animated gradient background for results header */
+    .results-header {
+        background: linear-gradient(-45deg, #ee7752, #e73c7e, #23a6d5, #23d5ab);
+        background-size: 400% 400%;
+        animation: gradient 15s ease infinite;
+        color: white;
+        padding: 2rem;
+        border-radius: 15px;
+        text-align: center;
+        margin-bottom: 2rem;
+        box-shadow: 0 5px 15px rgba(0,0,0,0.2);
+    }
+    
+    @keyframes gradient {
+        0% { background-position: 0% 50%; }
+        50% { background-position: 100% 50%; }
+        100% { background-position: 0% 50%; }
+    }
+    
+    .results-header h1 {
+        margin: 0;
+        font-size: 2.5rem;
+        text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+    }
+    
+    /* Metric styles for native Streamlit metrics */
+    [data-testid="metric-container"] {
+        background: transparent;
+        padding: 0;
+    }
+    
+    [data-testid="metric-container"] > div {
+        background: transparent;
+    }
+    
+    [data-testid="metric-container"] label {
+        color: white !important;
+        font-weight: 500;
+        opacity: 0.9;
+    }
+    
+    [data-testid="metric-container"] [data-testid="metric-value"] {
+        color: white !important;
+        font-size: 2.2rem;
+        font-weight: bold;
+    }
+    
+    [data-testid="metric-container"] [data-testid="metric-delta"] {
+        color: white !important;
+        font-size: 1.1rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Define Pydantic models
+class ResumeSection(BaseModel):
+    """Information about a section in a resume."""
+    section_name: str = Field(description="The name of the resume section (e.g., 'Experience', 'Education', 'Skills').")
+    content: str = Field(description="The full text content of this section.")
+
+class ResumeAnalysis(BaseModel):
+    """Analysis of a resume based on a job description."""
+    resume_sections: list[ResumeSection] = Field(description="A list of identified sections and their content from the resume.")
+    initial_match_score: int = Field(description="An initial match score out of 100, indicating how well the resume matches the job description.")
+    score_issues: str = Field(description="A detailed summary of the main reasons why the initial score is not 100, specifically identifying key requirements from the job description that are missing or not clearly highlighted in the resume.")
+    suggested_resume_updates: str = Field(description="Specific, actionable suggestions for how to modify the resume content to better match the job description. Focus on adding relevant keywords and rephrasing existing content to align with job requirements.")
+    updated_resume_content_suggestion: list[ResumeSection] = Field(description="A suggested revised version of the resume content, presented as a list of sections with potentially modified content based on the job description. These modifications should be realistic and significantly improve the match score.")
+
+# Initialize session state
+if 'analysis_complete' not in st.session_state:
+    st.session_state.analysis_complete = False
+if 'analysis_result' not in st.session_state:
+    st.session_state.analysis_result = None
+if 'ocr_reader' not in st.session_state:
+    st.session_state.ocr_reader = None
+
+# Helper functions
+@st.cache_resource
+def get_ocr_reader():
+    """Initialize OCR reader once and cache it"""
+    try:
+        return easyocr.Reader(['en'], gpu=False)  # Disable GPU for Windows compatibility
+    except Exception as e:
+        st.warning(f"OCR initialization warning: {e}")
+        return None
+
+def extract_text_from_pdf(pdf_path):
+    """Extracts text from a PDF using multiple methods without requiring poppler."""
+    
+    # Method 1: Try pdfplumber first
+    try:
+        with pdfplumber.open(pdf_path) as pdf:
+            if pdf.pages:
+                all_text = ""
+                for page in pdf.pages:
+                    page_text = page.extract_text()
+                    if page_text:
+                        all_text += page_text + "\n"
+
+                if all_text.strip():
+                    return all_text.strip()
+                else:
+                    st.info("pdfplumber did not extract text. Trying PyPDF2...")
+    except Exception as e:
+        st.warning(f"pdfplumber failed: {e}. Trying PyPDF2...")
+    
+    # Method 2: Try PyPDF2
+    try:
+        with open(pdf_path, 'rb') as file:
+            pdf_reader = PyPDF2.PdfReader(file)
+            all_text = ""
+            
+            for page_num in range(len(pdf_reader.pages)):
+                page = pdf_reader.pages[page_num]
+                text = page.extract_text()
+                if text:
+                    all_text += text + "\n"
+            
+            if all_text.strip():
+                return all_text.strip()
+            else:
+                st.info("PyPDF2 did not extract text. Trying PyMuPDF with OCR...")
+    except Exception as e:
+        st.warning(f"PyPDF2 failed: {e}. Trying PyMuPDF with OCR...")
+    
+    # Method 3: Use PyMuPDF (fitz) to convert PDF to images for OCR
+    try:
+        # Open the PDF with PyMuPDF
+        pdf_document = fitz.open(pdf_path)
+        
+        if len(pdf_document) == 0:
+            return "The PDF file is empty or has no pages."
+        
+        # Get the first page
+        page = pdf_document[0]
+        
+        # Convert page to image
+        mat = fitz.Matrix(2, 2)  # Increase resolution
+        pix = page.get_pixmap(matrix=mat)
+        img_data = pix.tobytes("png")
+        
+        # Convert to PIL Image
+        image = Image.open(io.BytesIO(img_data))
+        
+        # Save the image temporarily for OCR
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.png') as tmp_img:
+            image_path = tmp_img.name
+            image.save(image_path, 'PNG')
+        
+        # Get or initialize OCR reader
+        reader = get_ocr_reader()
+        if reader is None:
+            return "OCR reader could not be initialized."
+        
+        # Read text from the image
+        result = reader.readtext(image_path)
+        
+        # Extract text
+        extracted_text = ""
+        for (bbox, text, prob) in result:
+            extracted_text += text + " "
+        
+        # Clean up
+        pdf_document.close()
+        try:
+            os.unlink(image_path)
+        except:
+            pass
+        
+        if extracted_text.strip():
+            return extracted_text.strip()
+        else:
+            return "Could not extract text from the PDF using any method."
+            
+    except Exception as e:
+        return f"All text extraction methods failed: {e}"
+
+def analyze_and_update_resume(resume_text: str, job_description_text: str):
+    """Analyze resume against job description and provide suggestions."""
+    try:
+        # Initialize LLM
+        llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
+        
+        # Create prompt template
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", """You are an expert ATS scorer and resume optimization assistant.
+            Your primary goal is to provide actionable and realistic suggestions to *significantly improve* a resume's match score against a given job description.
+            Your task is to analyze a resume against a job description with high accuracy, simulating an advanced ATS system.
+            First, meticulously identify ALL key sections and their content from the provided resume text.
+            Then, perform a detailed assessment of how well the resume's content, skills, and experience align with the requirements and preferences outlined in the job description. Provide an initial match score out of 100, explaining your reasoning based on specific keywords, skills, and experiences mentioned in both the resume and job description.
+            Clearly articulate the specific gaps or areas where the resume significantly deviates from or fails to address key aspects of the job description. These should be concrete points directly tied to the job requirements.
+            Based on this analysis, provide specific and impactful suggestions for modifying the resume content. **These suggestions must be designed to strategically increase the resume's ATS score against the job description by directly addressing the identified gaps and highlighting relevant experience.** Focus on:
+            1. Incorporating relevant keywords and phrases from the job description where applicable and where supported by the candidate's experience.
+            2. Rephrasing existing bullet points or descriptions to *strongly* highlight experiences that are directly relevant to the job requirements and use action verbs that match the job description's tone.
+            3. Adding missing information if it's implied by the existing content but not explicitly stated (e.g., mentioning specific tools, methodologies, or quantifiable results used) that are mentioned in the job description.
+            4. **Ensure the suggested modifications realistically improve the alignment and are not fabricated.**
+            Finally, present the suggested revised version of the resume content. This should be a realistic and optimized version of the original resume, incorporating the suggested changes within the original section structure. Do NOT invent experience or skills that are not at least partially supported by the original resume content; focus on strategically highlighting and re-framing existing information to better match the job description and improve the score.
+            Ensure the output is strictly in the specified JSON format. The 'updated_resume_content_suggestion' field should contain the full text of the suggested updated resume sections."""),
+            ("human", """Resume Text:
+            {resume_text}
+
+            Job Description Text:
+            {job_description_text}"""),
+        ])
+
+        structured_llm = llm.with_structured_output(ResumeAnalysis)
+        analysis_chain = prompt | structured_llm
+
+        # Perform initial analysis
+        with st.spinner("Analyzing resume..."):
+            initial_analysis = analysis_chain.invoke({
+                "resume_text": resume_text,
+                "job_description_text": job_description_text
+            })
+
+        # Prepare updated resume text
+        suggested_updated_resume_text_sections = ""
+        for section in initial_analysis.updated_resume_content_suggestion:
+            suggested_updated_resume_text_sections += f"{section.section_name}:\n{section.content}\n\n"
+
+        # Score the updated resume
+        with st.spinner("Calculating improved score..."):
+            scoring_prompt = ChatPromptTemplate.from_messages([
+                ("system", """You are an expert resume and job description matcher.
+                Your task is to assess how well the provided resume text matches the job description and provide a single integer score out of 100 based on ATS scoring principles. Focus on the alignment of skills, experience, and keywords. Provide only the integer score."""),
+                ("human", """Assess the match score between the following resume text and job description.
+                Provide only a single integer score out of 100.
+
+                Resume Text:
+                {resume_text}
+
+                Job Description Text:
+                {job_description_text}"""),
+            ])
+
+            scoring_llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
+            scoring_chain = scoring_prompt | scoring_llm
+
+            updated_score_response = scoring_chain.invoke({
+                "resume_text": suggested_updated_resume_text_sections.strip(),
+                "job_description_text": job_description_text
+            })
+
+            # Parse score
+            try:
+                updated_score_text = updated_score_response.content.strip()
+                match = re.search(r'\d+', updated_score_text)
+                if match:
+                    updated_score = int(match.group(0))
+                    updated_score = max(0, min(100, updated_score))
+                else:
+                    updated_score = -1
+            except:
+                updated_score = -1
+
+        # Prepare result - using model_dump() instead of dict() for Pydantic v2
+        result = {
+            "initial_analysis": initial_analysis.model_dump(),
+            "initial_score": initial_analysis.initial_match_score,
+            "suggested_resume_updates_description": initial_analysis.suggested_resume_updates,
+            "suggested_updated_resume_content_json": [sec.model_dump() for sec in initial_analysis.updated_resume_content_suggestion],
+            "updated_score": updated_score,
+            "score_comparison": f"Initial score: {initial_analysis.initial_match_score}, Updated score: {updated_score}"
+        }
+
+        return result
+
+    except Exception as e:
+        st.error(f"An error occurred during analysis: {e}")
+        return {"error": str(e)}
+
+# Main app
+st.title("🎯 ATS Assassin - Stealth Mode")
+st.markdown("Upload your resume and job description to get AI-powered suggestions for improvement to enhance the ATS score.")
+
+# Installation instructions
+with st.expander("📦 Required Dependencies", expanded=False):
+    st.markdown("""
+    **Install the following packages:**
+    ```bash
+    pip install streamlit langchain-core langchain-openai langchain-community
+    pip install pydantic pdfplumber PyPDF2 pymupdf pillow easyocr
+    ```
+    
+    **Note:** This version doesn't require poppler! We use PyMuPDF (fitz) instead of pdf2image.
+    """)
+
+# Sidebar for configuration
+with st.sidebar:
+    st.header("⚙️ Configuration")
+    
+    # OpenAI API Key
+    api_key = st.text_input("OpenAI API Key", type="password", help="Enter your OpenAI API key")
+    if api_key:
+        os.environ["OPENAI_API_KEY"] = api_key
+    
+    st.divider()
+    
+    # Job Description Input Method
+    st.subheader("📋 Job Description Input")
+    input_method = st.radio(
+        "Choose input method:",
+        ["Upload PDF", "Enter URL"],
+        help="Select how you want to provide the job description"
+    )
+
+# Main content area
+col1, col2 = st.columns([1, 1])
+
+with col1:
+    st.subheader("📄 Upload Resume")
+    resume_file = st.file_uploader("Choose your resume PDF", type=['pdf'])
+    
+    if resume_file:
+        st.success(f"✅ Resume uploaded: {resume_file.name}")
+
+with col2:
+    st.subheader("💼 Job Description")
+    
+    job_description_text = None
+    
+    if input_method == "Upload PDF":
+        job_file = st.file_uploader("Choose job description PDF", type=['pdf'])
+        if job_file:
+            st.success(f"✅ Job description uploaded: {job_file.name}")
+    else:
+        job_url = st.text_input("Enter job description URL", placeholder="https://example.com/job-posting")
+        if job_url:
+            st.success(f"✅ URL provided")
+
+# Analyze button
+if st.button("🚀 Analyze Resume", type="primary", use_container_width=True):
+    # Validation
+    if not api_key:
+        st.error("Please enter your OpenAI API key in the sidebar.")
+    elif not resume_file:
+        st.error("Please upload your resume.")
+    elif input_method == "Upload PDF" and not job_file:
+        st.error("Please upload the job description PDF.")
+    elif input_method == "Enter URL" and not job_url:
+        st.error("Please enter the job description URL.")
+    else:
+        try:
+            # Extract resume text
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_resume:
+                tmp_resume.write(resume_file.read())
+                tmp_resume.flush()
+                resume_text = extract_text_from_pdf(tmp_resume.name)
+                try:
+                    os.unlink(tmp_resume.name)
+                except:
+                    pass
+            
+            # Extract job description
+            if input_method == "Upload PDF":
+                with tempfile.NamedTemporaryFile(delete=False, suffix='.pdf') as tmp_job:
+                    tmp_job.write(job_file.read())
+                    tmp_job.flush()
+                    job_description_text = extract_text_from_pdf(tmp_job.name)
+                    try:
+                        os.unlink(tmp_job.name)
+                    except:
+                        pass
+            else:
+                with st.spinner("Fetching job description from URL..."):
+                    loader = WebBaseLoader(job_url)
+                    docs = loader.load()
+                    # Try to get description from metadata, fallback to page content
+                    if docs and len(docs) > 0:
+                        job_description_text = docs[0].metadata.get("description", docs[0].page_content)
+                    else:
+                        st.error("Could not fetch content from the URL")
+                        job_description_text = None
+            
+            if job_description_text:
+                # Perform analysis
+                result = analyze_and_update_resume(resume_text, job_description_text)
+                
+                if "error" not in result:
+                    st.session_state.analysis_complete = True
+                    st.session_state.analysis_result = result
+                else:
+                    st.error(f"Analysis failed: {result['error']}")
+            else:
+                st.error("Could not extract job description text")
+                
+        except Exception as e:
+            st.error(f"An error occurred: {str(e)}")
+            st.exception(e)
+
+# Display results
+if st.session_state.analysis_complete and st.session_state.analysis_result:
+    result = st.session_state.analysis_result
+    
+    # Animated header
+    st.markdown('<div class="results-header"><h1>📊 Analysis Results</h1></div>', unsafe_allow_html=True)
+    
+    # Score comparison with enhanced styling
+    col1, col2, col3 = st.columns([1, 1, 1])
+    
+    initial_score = result['initial_score']
+    updated_score = result['updated_score']
+    score_diff = updated_score - initial_score if updated_score != -1 else 0
+    
+    with col1:
+        st.markdown('<div class="score-card score-card-initial">', unsafe_allow_html=True)
+        # Progress ring SVG
+        progress_initial = initial_score / 100 * 377  # 377 is the circumference of the circle
+        st.markdown(f'''
+        <div class="progress-ring">
+            <svg width="120" height="120">
+                <circle class="progress-ring-circle" cx="60" cy="60" r="50"></circle>
+                <circle class="progress-ring-circle-progress" cx="60" cy="60" r="50" 
+                    style="stroke-dasharray: 377; stroke-dashoffset: {377 - progress_initial};">
+                </circle>
+                <text x="60" y="70" text-anchor="middle" fill="white" style="font-size: 28px; font-weight: bold;">
+                    {initial_score}
+                </text>
+            </svg>
+        </div>
+        <div class="score-label">Initial Score</div>
+        ''', unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    with col2:
+        st.markdown('<div class="score-card score-card-improved">', unsafe_allow_html=True)
+        if updated_score != -1:
+            progress_updated = updated_score / 100 * 377
+            st.markdown(f'''
+            <div class="progress-ring">
+                <svg width="120" height="120">
+                    <circle class="progress-ring-circle" cx="60" cy="60" r="50"></circle>
+                    <circle class="progress-ring-circle-progress" cx="60" cy="60" r="50" 
+                        style="stroke-dasharray: 377; stroke-dashoffset: {377 - progress_updated};">
+                    </circle>
+                    <text x="60" y="70" text-anchor="middle" fill="white" style="font-size: 28px; font-weight: bold;">
+                        {updated_score}
+                    </text>
+                </svg>
+            </div>
+            <div class="score-label">Improved Score</div>
+            <div class="score-delta">
+                <span class="arrow-up"></span>
+                <span>+{score_diff} points</span>
+            </div>
+            ''', unsafe_allow_html=True)
+        else:
+            st.markdown('<div class="score-value">N/A</div><div class="score-label">Improved Score</div>', unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    with col3:
+        st.markdown('<div class="score-card score-card-improvement">', unsafe_allow_html=True)
+        if updated_score != -1 and initial_score > 0:
+            improvement_percentage = (score_diff / initial_score * 100)
+            st.markdown(f'''
+            <div style="margin-top: 20px;">
+                <div class="score-value">{improvement_percentage:.1f}%</div>
+                <div class="score-label">Total Improvement</div>
+                <div class="score-delta">
+                    <span class="arrow-up"></span>
+                    <span>{score_diff} points gained</span>
+                </div>
+            </div>
+            ''', unsafe_allow_html=True)
+        else:
+            st.markdown('<div class="score-value">N/A</div><div class="score-label">Improvement</div>', unsafe_allow_html=True)
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Add some spacing
+    st.markdown("<br>", unsafe_allow_html=True)
+    
+    # Issues identified with better styling
+    with st.expander("🔍 **Issues Identified**", expanded=True):
+        st.markdown(f"""
+        <div style="background-color: #fff3cd; padding: 1.5rem; border-radius: 10px; border-left: 4px solid #ffc107; color: #856404;">
+            <p style="margin: 0; line-height: 1.6; font-size: 1rem;">
+                {result['initial_analysis']['score_issues']}
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Suggestions with better styling
+    with st.expander("💡 **Improvement Suggestions**", expanded=True):
+        st.markdown(f"""
+        <div style="background-color: #d4edda; padding: 1.5rem; border-radius: 10px; border-left: 4px solid #28a745; color: #155724;">
+            <p style="margin: 0; line-height: 1.6; font-size: 1rem;">
+                {result['suggested_resume_updates_description']}
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Original sections
+    st.divider()
+    st.subheader("📑 Original Resume Sections")
+    
+    for section in result['initial_analysis']['resume_sections']:
+        with st.expander(f"**{section['section_name']}**"):
+            st.text(section['content'])
+    
+    # Suggested updated sections
+    st.divider()
+    st.subheader("✨ Suggested Updated Resume Sections")
+    
+    for section in result['suggested_updated_resume_content_json']:
+        with st.expander(f"**{section['section_name']}** (Optimized)"):
+            st.text(section['content'])
+    
+    # Download button for updated resume
+    st.divider()
+    updated_resume_text = ""
+    for section in result['suggested_updated_resume_content_json']:
+        updated_resume_text += f"{section['section_name']}:\n{section['content']}\n\n"
+    
+    st.download_button(
+        label="📥 Download Optimized Resume (Text)",
+        data=updated_resume_text,
+        file_name="optimized_resume.txt",
+        mime="text/plain",
+        use_container_width=True
+    )