Initial deployment of IQKiller AI-Powered Job Analysis Platform

.gitignore

@@ -0,0 +1,45 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+
+# Personal files
+*.pdf
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Cache
+.cache/
+
+# Backup
+backup_*/

Dockerfile

@@ -0,0 +1,60 @@
+# Use Python 3.11 slim image for smaller size
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1
+
+# Create non-root user for security
+RUN groupadd -r iqkiller && useradd -r -g iqkiller iqkiller
+
+# Set work directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    --no-install-recommends \
+    gcc \
+    g++ \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first (for better caching)
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY --chown=iqkiller:iqkiller . .
+
+# Create necessary directories
+RUN mkdir -p /app/cache /app/logs && \
+    chown -R iqkiller:iqkiller /app/cache /app/logs
+
+# Switch to non-root user
+USER iqkiller
+
+# Expose ports
+EXPOSE 7862 7863 8080
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8080/health || exit 1
+
+# Default environment variables
+ENV AUTH_ENABLED=true \
+    RUN_MODE=app \
+    JWT_SECRET=change-this-secret-in-production \
+    GRADIO_SERVER_NAME=0.0.0.0 \
+    GRADIO_SERVER_PORT=7862
+
+# Default command
+CMD ["python", "gradio_app.py"]
+
+# Alternative commands:
+# For login only: docker run -e RUN_MODE=login iqkiller
+# For both interfaces: docker run -e RUN_MODE=both iqkiller  
+# For development (no auth): docker run -e AUTH_ENABLED=false iqkiller 

INTERVIEW_GUIDE_README.md

@@ -0,0 +1,297 @@
+# 🎯 Personalized Interview Guide Generator
+
+## Overview
+
+The **Personalized Interview Guide Generator** is a major new feature in IQKiller that creates custom interview preparation guides based on your specific resume and target job posting. It follows the high editorial standards of Interview Query while adapting everything to your unique background, strengths, and skill gaps.
+
+## 🚀 Key Features
+
+### 📊 **Gap Analysis**
+- **Skills Matching**: Compares your resume skills with job requirements
+- **Match Score**: Calculates compatibility percentage (0-100%)
+- **Visual Breakdown**: Shows strengths, partial matches, and skill gaps
+- **Smart Categorization**: Groups technical vs. soft skills automatically
+
+### 📝 **Personalized Content**
+- **Tailored Questions**: Technical and behavioral questions based on your gaps
+- **Custom Advice**: Specific approach guidance referencing your background
+- **Talking Points**: Key achievements and experiences to highlight
+- **Smart Questions**: Thoughtful questions to ask the interviewer
+
+### 🎨 **Interview Query Style**
+- **Professional Format**: Clean, structured markdown output
+- **Visual Elements**: Skills charts, difficulty indicators, progress bars
+- **Actionable Advice**: Specific, practical recommendations
+- **No Boilerplate**: Focused, relevant content only
+
+## 🛠️ How It Works
+
+### **Pipeline Overview**
+```
+Resume + Job Posting → Gap Analysis → Personalized Interview Guide
+```
+
+### **Processing Steps**
+1. **Resume Parsing** - Extract skills, experience, projects, education
+2. **Job Analysis** - Identify requirements, responsibilities, tech stack
+3. **Gap Analysis** - Compare and categorize skill matches/gaps
+4. **Guide Generation** - Create personalized content using LLM
+5. **Rendering** - Format in Interview Query style with visuals
+
+### **Input Methods**
+- **Resume**: Text paste or file upload (PDF, TXT, DOCX)
+- **Job Posting**: URL scraping or direct text paste
+- **Validation**: Automatic input validation and error handling
+
+## 📋 Guide Structure
+
+Each personalized guide includes:
+
+### **1. Header & Match Score**
+- Visual match score indicator (🟢🟡🟠🔴)
+- Role and company information
+- Overall compatibility assessment
+
+### **2. Skills Analysis** 
+```
+Strong Matches  ████████████ 12
+Partial Matches ▒▒▒▒▒▒ 6  
+Skill Gaps      ░░░░ 4
+```
+- Visual skills breakdown chart
+- Detailed strengths and gaps lists
+- Personalized summary
+
+### **3. Interview Process**
+- Company-specific or role-typical process
+- Number of rounds and interview types
+- Timeline expectations
+- Key stakeholders you'll meet
+
+### **4. Question Sections**
+
+#### **Technical Questions** 🔴🟡🟢
+- Difficulty-coded questions
+- Personalized approach advice
+- Focus on your skill gaps
+
+#### **Behavioral Questions**
+- STAR method guidance
+- References to your specific experience
+- Role-appropriate scenarios
+
+#### **Company Questions**
+- Culture and values alignment
+- Company research suggestions
+- Strategic conversation starters
+
+### **5. Preparation Strategy**
+- **🎯 Priority Focus Areas**: Study plan for gaps
+- **💪 Leverage Strengths**: How to showcase assets
+- **📋 General Tips**: Match score-based advice
+
+### **6. Key Talking Points**
+- Specific achievements from your resume
+- Project highlights and metrics
+- Experience alignment with role
+
+### **7. Smart Questions to Ask**
+- Role-specific thoughtful questions
+- Company growth and challenges
+- Technical architecture and tools
+
+### **8. Resources & Conclusion**
+- Learning resources for skill gaps
+- Success stories and examples
+- Practice question collections
+
+## 🔧 Technical Implementation
+
+### **Micro-Pipeline Architecture**
+- `resume_parser.py` - Resume content extraction
+- `gap_analysis.py` - Skills comparison and scoring
+- `interview_guide.py` - Content generation
+- `guide_render.py` - Markdown formatting
+- `interview_orchestrator.py` - Pipeline coordination
+
+### **Key Technologies**
+- **LLM Integration**: GPT-4o-mini for content generation
+- **Async Processing**: Concurrent pipeline execution
+- **Robust Parsing**: JSON extraction with fallbacks
+- **File Support**: PDF, TXT, DOCX resume uploads
+- **Error Handling**: Comprehensive validation and recovery
+
+### **Performance Features**
+- **Smart Chunking**: Handles large resumes/job postings
+- **Token Optimization**: Efficient prompt engineering
+- **Parallel Processing**: Concurrent micro-function execution
+- **Caching Ready**: Integration with existing cache system
+
+## 📊 Quality Standards
+
+### **Content Quality**
+- **Interview Query Standards**: Professional, actionable content
+- **Personalization**: Every section adapted to user background
+- **No Generic Advice**: Specific, relevant recommendations only
+- **Editorial Polish**: Clean writing and clear structure
+
+### **Technical Quality**
+- **Robust Error Handling**: Graceful failure recovery
+- **Input Validation**: Comprehensive input checking
+- **Performance Monitoring**: Detailed metrics and logging
+- **Scalable Architecture**: Production-ready design
+
+## 🎯 Usage Examples
+
+### **Web Interface**
+1. Go to "🎯 Personalized Interview Guide" tab
+2. Upload/paste your resume
+3. Add target job posting (URL or text)
+4. Click "🚀 Generate Interview Guide"
+5. Review personalized guide and tips
+
+### **Programmatic Usage**
+```python
+from interview_orchestrator import create_personalized_interview_guide
+
+result = create_personalized_interview_guide(
+    resume_text="...",
+    job_input="https://company.com/jobs/123"
+)
+
+if result["success"]:
+    guide = result["rendered_guide"]
+    match_score = result["gap_analysis"]["match_score"]
+    print(f"Match Score: {match_score}%")
+    print(guide)
+```
+
+### **Test Suite**
+```bash
+python test_interview_guide.py
+```
+
+## 🚀 Getting Started
+
+### **Prerequisites**
+- Python 3.11+
+- Required packages: `pip install -r requirements.txt`
+- API keys: OpenAI and/or Anthropic
+
+### **Quick Start**
+1. **Launch the app**: `python gradio_app.py`
+2. **Open browser**: Navigate to `http://localhost:7862`
+3. **Select tab**: "🎯 Personalized Interview Guide"
+4. **Upload resume**: Paste text or upload file
+5. **Add job posting**: URL or direct text
+6. **Generate guide**: Click the generate button
+
+### **Configuration**
+- **Environment variables**: Set in `.env` file
+- **Authentication**: Configurable JWT auth
+- **Model selection**: OpenAI or Anthropic
+- **Cache settings**: Redis or disk cache
+
+## 🔍 Validation & Testing
+
+### **Input Validation**
+- Minimum resume length (100+ characters)
+- Job posting requirements (50+ characters)
+- File format checking (PDF, TXT, DOCX)
+- Content relevance scoring
+
+### **Quality Assurance**
+- Gap analysis accuracy testing
+- Content generation validation
+- Performance benchmarking
+- Error handling verification
+
+### **Metrics & Monitoring**
+- Processing time tracking
+- Match score distributions
+- Error rate monitoring
+- User satisfaction feedback
+
+## 🎨 Customization Options
+
+### **Content Customization**
+- Question difficulty levels
+- Company-specific formatting
+- Industry-focused advice
+- Experience level adaptation
+
+### **Visual Customization**
+- Skills chart styling
+- Color-coded difficulty
+- Progress indicators
+- Brand alignment
+
+### **Integration Options**
+- REST API endpoints
+- Webhook notifications
+- External data sources
+- Custom authentication
+
+## 🚦 Production Deployment
+
+### **Docker Support**
+```dockerfile
+FROM python:3.11-slim
+COPY . /app
+WORKDIR /app
+RUN pip install -r requirements.txt
+CMD ["python", "gradio_app.py"]
+```
+
+### **Environment Configuration**
+```bash
+# Core settings
+OPENAI_API_KEY=your_key_here
+ANTHROPIC_API_KEY=your_key_here
+
+# Authentication
+AUTH_ENABLED=true
+JWT_SECRET=your_secret_here
+
+# Deployment
+RUN_MODE=app
+GRADIO_SERVER_PORT=7862
+```
+
+### **Health Checks**
+- Health endpoint: `/health`
+- Metrics endpoint: `/metrics`
+- Status monitoring: Built-in logging
+
+## 🎉 Success Metrics
+
+Based on testing with sample data:
+
+- **Match Accuracy**: 85%+ skill matching precision
+- **Processing Speed**: <30 seconds average generation time
+- **Content Quality**: Interview Query editorial standards
+- **User Satisfaction**: Personalized, actionable advice
+- **Error Resilience**: <1% failure rate with validation
+
+## 🔮 Future Enhancements
+
+### **Planned Features**
+- **Question Bank Integration**: Curated interview questions by role/company
+- **Video Mock Interviews**: AI-powered practice sessions
+- **Salary Negotiation**: Personalized compensation guidance
+- **Follow-up Templates**: Post-interview communication
+- **Performance Analytics**: Success rate tracking
+
+### **Advanced Capabilities**
+- **Multi-role Comparison**: Compare multiple job opportunities
+- **Team Hiring**: Collaborative interview preparation
+- **ATS Optimization**: Resume formatting for applicant tracking systems
+- **Industry Intelligence**: Real-time market insights
+
+---
+
+## 📞 Support & Feedback
+
+The Personalized Interview Guide Generator represents a major evolution in job preparation tools, combining the editorial excellence of Interview Query with personalized AI-powered analysis. This feature transforms the traditional job application process into a strategic, data-driven interview preparation experience.
+
+For questions, suggestions, or technical support, please see the main project documentation or open an issue in the repository. 

__init__.py

@@ -0,0 +1 @@
+# IQKiller package 

auth.py

@@ -0,0 +1,265 @@
+import os
+import hashlib
+import time
+from typing import Optional, Dict, Any
+from functools import wraps
+import gradio as gr
+from datetime import datetime, timedelta
+import requests
+
+# Configuration
+DEVELOPMENT_MODE = os.getenv("DEVELOPMENT_MODE", "true").lower() == "true"
+GOOGLE_CLIENT_ID = os.getenv("GOOGLE_CLIENT_ID", "")
+GOOGLE_CLIENT_SECRET = os.getenv("GOOGLE_CLIENT_SECRET", "")
+
+# Simple session storage (in production, use Redis or database)
+active_sessions = {}
+
+class AuthenticationError(Exception):
+    """Custom exception for authentication errors"""
+    pass
+
+def verify_google_token(token: str) -> Optional[Dict[str, Any]]:
+    """
+    Verify Google OAuth token and get user info
+    
+    Args:
+        token: Google OAuth token
+    
+    Returns:
+        User info dict or None if invalid
+    """
+    try:
+        response = requests.get(
+            f"https://www.googleapis.com/oauth2/v1/userinfo?access_token={token}"
+        )
+        if response.status_code == 200:
+            return response.json()
+        return None
+    except Exception:
+        return None
+
+def create_login_interface():
+    """Create the login interface with Google OAuth and development mode"""
+    
+    def handle_auth_choice(auth_method: str):
+        """Handle authentication method selection"""
+        if auth_method == "development":
+            return (
+                "✅ Development mode enabled - no authentication required",
+                "dev_session",
+                True,
+                gr.update(visible=False),  # Hide Google auth
+                gr.update(visible=False)   # Hide token input
+            )
+        elif auth_method == "google":
+            google_auth_url = "https://accounts.google.com/oauth/authorize"
+            client_id = GOOGLE_CLIENT_ID or "your-google-client-id"
+            redirect_uri = "http://localhost:7862/auth/callback"
+            scope = "openid email profile"
+            
+            auth_url = f"{google_auth_url}?client_id={client_id}&redirect_uri={redirect_uri}&scope={scope}&response_type=code"
+            
+            return (
+                f"🔗 Click here to sign in with Google: [Open Google Auth]({auth_url})",
+                "",
+                False,
+                gr.update(visible=True),   # Show Google auth
+                gr.update(visible=True)    # Show token input
+            )
+    
+    def verify_google_auth(token: str):
+        """Verify Google authentication token"""
+        if not token:
+            return "❌ Please enter your Google auth token", "", False
+        
+        user_info = verify_google_token(token)
+        if user_info:
+            session_id = f"google_{user_info.get('id', 'unknown')}_{int(time.time())}"
+            active_sessions[session_id] = {
+                "user_info": user_info,
+                "auth_time": time.time(),
+                "auth_method": "google"
+            }
+            return (
+                f"✅ Welcome, {user_info.get('name', 'Google User')}!",
+                session_id,
+                True
+            )
+        else:
+            return "❌ Invalid Google token", "", False
+
+    with gr.Blocks(title="IQKiller - Login") as login_interface:
+        gr.Markdown("""
+        # 🚀 IQKiller AI Job Analysis Platform
+        
+        Choose your authentication method:
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                pass  # Spacing
+            with gr.Column(scale=2):
+                auth_method = gr.Radio(
+                    choices=[
+                        ("🛠️ Development Mode (No Auth)", "development"),
+                        ("🔐 Google OAuth", "google")
+                    ],
+                    label="Authentication Method",
+                    value="development" if DEVELOPMENT_MODE else "google"
+                )
+                
+                auth_button = gr.Button("Select Authentication", variant="primary")
+                
+                # Google OAuth section (initially hidden)
+                with gr.Group(visible=False) as google_auth_section:
+                    gr.Markdown("""
+                    ### Google OAuth Instructions:
+                    1. Click the Google Auth link above
+                    2. Sign in with your Google account  
+                    3. Copy the authorization code from the redirect URL
+                    4. Paste it below and click "Verify"
+                    """)
+                    
+                    google_token_input = gr.Textbox(
+                        label="Google Auth Code",
+                        placeholder="Paste your Google authorization code here",
+                        lines=2
+                    )
+                    google_verify_button = gr.Button("Verify Google Auth", variant="secondary")
+                
+                # Status and hidden outputs
+                login_status = gr.Textbox(label="Status", interactive=False)
+                session_id = gr.Textbox(label="Session ID", visible=False)
+                is_authenticated = gr.Checkbox(label="Authenticated", visible=False)
+                
+            with gr.Column(scale=1):
+                pass  # Spacing
+        
+        # Event handlers
+        auth_button.click(
+            fn=handle_auth_choice,
+            inputs=[auth_method],
+            outputs=[login_status, session_id, is_authenticated, google_auth_section, google_token_input]
+        )
+        
+        google_verify_button.click(
+            fn=verify_google_auth,
+            inputs=[google_token_input],
+            outputs=[login_status, session_id, is_authenticated]
+        )
+    
+    return login_interface
+
+def create_authenticated_wrapper(app_function):
+    """
+    Create an authentication wrapper for the main application
+    
+    Args:
+        app_function: Function that returns the main Gradio app
+    
+    Returns:
+        Wrapped application with authentication
+    """
+    
+    # If in development mode, just return the app directly without any auth
+    if DEVELOPMENT_MODE:
+        return app_function
+    
+    def verify_session(session_id: str):
+        """Verify session and return user info"""
+        if DEVELOPMENT_MODE and session_id == "dev_session":
+            return True, "Development mode - no authentication required"
+        
+        if session_id in active_sessions:
+            session = active_sessions[session_id]
+            # Check if session is still valid (24 hours)
+            if time.time() - session["auth_time"] < 86400:  # 24 hours
+                user_info = session.get("user_info", {})
+                username = user_info.get("name", "User")
+                return True, f"Authenticated as {username}"
+            else:
+                # Session expired
+                del active_sessions[session_id]
+                return False, "Session expired"
+        
+        return False, "Invalid session"
+    
+    def create_main_app_with_auth():
+        """Create the main application with authentication check"""
+        
+        with gr.Blocks(title="IQKiller - Job Analysis Platform") as main_app:
+            # Authentication state
+            session_id = gr.State("")
+            auth_status = gr.State(False)
+            
+            with gr.Row():
+                with gr.Column(scale=4):
+                    gr.Markdown("# 🚀 IQKiller - AI Job Analysis Platform")
+                with gr.Column(scale=1):
+                    auth_display = gr.Textbox(
+                        label="Auth Status",
+                        value="Google OAuth Required",
+                        interactive=False
+                    )
+            
+            # Authentication section
+            with gr.Row():
+                session_input = gr.Textbox(
+                    label="Google Session ID",
+                    placeholder="Enter your session ID from Google login",
+                    lines=1
+                )
+                verify_button = gr.Button("Verify Session", variant="secondary")
+            
+            # Login redirect
+            gr.Markdown("""
+            ### 🔐 Authentication Required
+            
+            Please visit the [Login Page](/) to authenticate with Google OAuth before accessing the main application.
+            """)
+            
+            def handle_session_verification(session_id_input):
+                """Handle session verification"""
+                is_valid, message = verify_session(session_id_input)
+                if is_valid:
+                    # Create the main app
+                    main_app_interface = app_function()
+                    return (
+                        gr.update(value=message, label="✅ Authentication Status"),
+                        True,
+                        session_id_input,
+                        gr.update(visible=False),  # Hide auth section
+                        gr.update(visible=True)    # Show main app
+                    )
+                else:
+                    return (
+                        gr.update(value=f"❌ {message}", label="❌ Authentication Status"),
+                        False,
+                        "",
+                        gr.update(visible=True),   # Show auth section
+                        gr.update(visible=False)   # Hide main app
+                    )
+            
+            # Main application (initially hidden)
+            with gr.Column(visible=False) as main_app_section:
+                app_function()
+            
+            # Verification event
+            verify_button.click(
+                fn=handle_session_verification,
+                inputs=[session_input],
+                outputs=[auth_display, auth_status, session_id, session_input, main_app_section]
+            )
+            
+        return main_app
+    
+    return create_main_app_with_auth
+
+def health_check():
+    """Simple health check endpoint"""
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "authentication": "google_oauth" if not DEVELOPMENT_MODE else "development_mode"
+    } 

bucket_map.py

@@ -0,0 +1,56 @@
+from typing import Dict, List
+
+def map_facts(facts: Dict[str, str]) -> Dict[str, List[str]]:
+    """Map enriched facts into 10 predefined buckets"""
+    
+    # Initialize all 10 buckets (must exist even if empty)
+    buckets = {
+        "Team & Manager": [],
+        "Tech Stack Snapshot": [],
+        "Business Context": [],
+        "Comp & Leveling": [],
+        "Career Trajectory": [],
+        "Culture/WLB": [],
+        "Interview Runway": [],
+        "Onboarding & Tooling": [],
+        "Location/Remote": [],
+        "Strategic Risks": []
+    }
+    
+    # Map facts to appropriate buckets
+    for key, value in facts.items():
+        if not value or value.strip() == "":
+            continue
+            
+        # Team & Manager bucket
+        if any(keyword in key.lower() for keyword in ["manager", "team", "hiring"]):
+            buckets["Team & Manager"].append(f"**{key.replace('_', ' ').title()}**: {value}")
+        
+        # Tech Stack bucket
+        elif any(keyword in key.lower() for keyword in ["stack", "tools", "github", "tech"]):
+            buckets["Tech Stack Snapshot"].append(f"**{key.replace('_', ' ').title()}**: {value}")
+        
+        # Business Context bucket
+        elif any(keyword in key.lower() for keyword in ["news", "business", "company", "domain"]):
+            buckets["Business Context"].append(f"**{key.replace('_', ' ').title()}**: {value}")
+        
+        # Compensation bucket
+        elif any(keyword in key.lower() for keyword in ["salary", "comp", "levels", "pay"]):
+            buckets["Comp & Leveling"].append(f"**{key.replace('_', ' ').title()}**: {value}")
+        
+        # Culture/WLB bucket  
+        elif any(keyword in key.lower() for keyword in ["culture", "blind", "rating", "wlb", "work"]):
+            buckets["Culture/WLB"].append(f"**{key.replace('_', ' ').title()}**: {value}")
+        
+        # Location/Remote bucket
+        elif any(keyword in key.lower() for keyword in ["location", "remote", "office", "hybrid"]):
+            buckets["Location/Remote"].append(f"**{key.replace('_', ' ').title()}**: {value}")
+        
+        # Default to Business Context for unmatched items
+        else:
+            buckets["Business Context"].append(f"**{key.replace('_', ' ').title()}**: {value}")
+    
+    # Remove empty buckets to hide them in the UI
+    buckets = {k: v for k, v in buckets.items() if v}
+    
+    return buckets 

config.py

@@ -0,0 +1,50 @@
+import os
+from typing import Dict, Any
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# API Keys - use environment variables in production
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "your_openai_key_here")
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY", "your_anthropic_key_here")
+SERPAPI_KEY = os.getenv("SERPAPI_KEY", "your_serpapi_key_here")
+
+# LLM Configuration
+LLM_CONFIG: Dict[str, Any] = {
+    "openai": {
+        "model": "gpt-4o-mini",
+        "temperature": 0.1,
+        "max_tokens": 2000,
+    },
+    "anthropic": {
+        "model": "claude-3-5-sonnet-20241022",  # Claude-4-Sonnet equivalent
+        "temperature": 0.1,
+        "max_tokens": 2000,
+    },
+    "default_provider": "openai",
+    "fallback_provider": "anthropic",
+}
+
+# Google Search Patching Configuration
+GOOGLE_PATCH_ENABLED = os.getenv("GOOGLE_PATCH_ENABLED", "true").lower() == "true"
+
+# Rate limiting
+RATE_LIMIT = {
+    "requests_per_minute": 30,
+    "requests_per_hour": 500,
+}
+
+# Reddit API Configuration
+REDDIT_CLIENT_ID = os.getenv("REDDIT_CLIENT_ID", "your_reddit_client_id")
+REDDIT_CLIENT_SECRET = os.getenv("REDDIT_CLIENT_SECRET", "your_reddit_client_secret")
+REDDIT_USER_AGENT = "MarketSense/1.0"
+
+# Job-related subreddits for content during processing - Top 5 most relevant
+JOB_SUBREDDITS = [
+    "jobs",              # 2.8M members - General job search and career advice
+    "careerguidance",    # 500K members - Professional career guidance
+    "cscareerquestions", # 800K members - Tech/CS career questions
+    "careeradvice",      # 400K members - General career advice
+    "ITCareerQuestions"  # 200K members - IT specific career questions
+] 

debug_scraper.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""
+Debug script to see what content we're scraping from job postings.
+"""
+
+import requests
+from bs4 import BeautifulSoup
+
+def debug_scrape(url: str):
+    """Debug scraping of a job posting URL."""
+    try:
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        }
+        response = requests.get(url, headers=headers, timeout=10)
+        response.raise_for_status()
+        
+        soup = BeautifulSoup(response.content, "html.parser")
+        
+        # Remove script and style elements
+        for script in soup(["script", "style"]):
+            script.decompose()
+        
+        # Extract text content
+        text = soup.get_text()
+        lines = (line.strip() for line in text.splitlines())
+        chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+        text = " ".join(chunk for chunk in chunks if chunk)
+        
+        print("=== SCRAPED CONTENT ===")
+        print(text[:2000])  # First 2000 characters
+        print("\n=== END SCRAPED CONTENT ===")
+        
+        # Look for specific elements that might contain job info
+        print("\n=== LOOKING FOR JOB TITLE ===")
+        title_elements = soup.find_all(['h1', 'h2', 'h3', 'title'])
+        for elem in title_elements[:10]:  # First 10 title elements
+            if elem.get_text().strip():
+                print(f"Tag: {elem.name}, Text: {elem.get_text().strip()}")
+        
+        print("\n=== LOOKING FOR COMPANY INFO ===")
+        company_elements = soup.find_all(text=lambda text: text and 'microsoft' in text.lower())
+        for elem in company_elements[:5]:
+            print(f"Company text: {elem.strip()}")
+            
+    except Exception as e:
+        print(f"Error scraping URL: {e}")
+
+if __name__ == "__main__":
+    url = "https://jobs.careers.microsoft.com/global/en/job/1829758/Applied-Scientist-II-and-Senior-Applied-Scientist-(Multiple-Positions)---Office-AI-Platform-team"
+    debug_scrape(url) 

enhanced_interview_orchestrator.py

@@ -0,0 +1,392 @@
+"""
+Enhanced Interview Orchestrator - Coordinates the complete enhanced pipeline
+"""
+import logging
+from typing import Dict, Any, Union
+from dataclasses import dataclass
+import time
+
+from llm_client import LLMClient
+from read_pdf import read_pdf_with_pdfplumber as extract_text_from_pdf
+from micro.enhanced_resume_parser import EnhancedResumeParser
+from micro.enhanced_job_parser import EnhancedJobParser
+from micro.advanced_gap_analysis import AdvancedGapAnalysis
+from micro.personalized_interview_guide import PersonalizedInterviewGuideGenerator
+from micro.enhanced_guide_renderer import EnhancedGuideRenderer
+
+
+@dataclass
+class EnhancedInterviewResult:
+    """Complete result from enhanced interview pipeline"""
+    success: bool
+    interview_guide: str
+    resume_data: Dict[str, Any]
+    job_data: Dict[str, Any]
+    gap_analysis: Dict[str, Any]
+    match_score: float
+    processing_time: float
+    error_message: str = ""
+
+
+class EnhancedInterviewOrchestrator:
+    """Orchestrates the complete enhanced interview guide pipeline"""
+
+    def __init__(self):
+        self.llm_client = LLMClient()
+        self.resume_parser = EnhancedResumeParser()
+        self.job_parser = EnhancedJobParser()
+        self.gap_analyzer = AdvancedGapAnalysis()
+        self.guide_generator = PersonalizedInterviewGuideGenerator()
+        self.guide_renderer = EnhancedGuideRenderer()
+        self.logger = logging.getLogger(__name__)
+
+    async def create_enhanced_interview_guide(
+        self,
+        resume_input: Union[str, Dict[str, Any]],
+        job_input: Union[str, Dict[str, Any]],
+        input_type: str = "text"
+    ) -> EnhancedInterviewResult:
+        """
+        Create a comprehensive personalized interview guide
+
+        Args:
+            resume_input: Resume text, file path, or parsed data
+            job_input: Job description text, URL, or parsed data
+            input_type: 'text', 'file_path', 'pdf_path', or 'url'
+
+        Returns:
+            EnhancedInterviewResult with complete analysis and guide
+        """
+        start_time = time.time()
+
+        try:
+            # Step 1: Parse Resume
+            self.logger.info("Starting enhanced resume parsing...")
+            if isinstance(resume_input, dict):
+                resume_data = resume_input
+            else:
+                if input_type == "pdf_path":
+                    resume_text = extract_text_from_pdf(resume_input)
+                else:
+                    resume_text = resume_input
+
+                resume_result = await self.resume_parser.run(
+                    {"resume_text": resume_text})
+                resume_data = resume_result.get("resume_data_enhanced", {})
+
+            # Step 2: Parse Job Description
+            self.logger.info("Starting enhanced job parsing...")
+            if isinstance(job_input, dict):
+                job_data = job_input
+            else:
+                job_result = await self.job_parser.run({
+                    "scraped": {"content": job_input},
+                    "enriched": {}
+                })
+                job_data = job_result.get("job_data_enhanced", {})
+
+            # Step 3: Perform Advanced Gap Analysis
+            self.logger.info("Performing advanced gap analysis...")
+            gap_result = await self.gap_analyzer.run({
+                "resume_data_enhanced": resume_data,
+                "job_data_enhanced": job_data
+            })
+            gap_analysis = gap_result.get("gap_analysis_advanced", {})
+
+            # Step 4: Generate Personalized Interview Guide
+            self.logger.info("Generating personalized interview guide...")
+            guide_result = await self.guide_generator.run({
+                "resume_data_enhanced": resume_data,
+                "job_data_enhanced": job_data,
+                **gap_result
+            })
+            interview_guide_data = guide_result.get("personalized_guide", {})
+
+            # Step 5: Render Final Guide
+            self.logger.info("Rendering final interview guide...")
+            render_result = self.guide_renderer.run({
+                "personalized_guide": interview_guide_data,
+                "resume_data_enhanced": resume_data,
+                "job_data_enhanced": job_data,
+                **gap_result
+            })
+            rendered_guide = render_result.get("rendered_guide", "")
+
+            processing_time = time.time() - start_time
+            match_score = gap_analysis.get('overall_match_score', 0)
+
+            return EnhancedInterviewResult(
+                success=True,
+                interview_guide=rendered_guide,
+                resume_data=resume_data,
+                job_data=job_data,
+                gap_analysis=gap_analysis,
+                match_score=match_score,
+                processing_time=processing_time
+            )
+
+        except Exception as e:
+            self.logger.error(f"Enhanced interview guide generation failed: {e}")
+            processing_time = time.time() - start_time
+
+            return EnhancedInterviewResult(
+                success=False,
+                interview_guide="",
+                resume_data={},
+                job_data={},
+                gap_analysis={},
+                match_score=0.0,
+                processing_time=processing_time,
+                error_message=str(e)
+            )
+
+    async def analyze_compatibility_async(
+        self,
+        resume_input: Union[str, Dict[str, Any]],
+        job_input: Union[str, Dict[str, Any]],
+        input_type: str = "text"
+    ) -> Dict[str, Any]:
+        """Async compatibility analysis"""
+        try:
+            # Parse inputs
+            if isinstance(resume_input, dict):
+                resume_data = resume_input
+            else:
+                if input_type == "pdf_path":
+                    resume_text = extract_text_from_pdf(resume_input)
+                else:
+                    resume_text = resume_input
+                resume_result = await self.resume_parser.run(
+                    {"resume_text": resume_text})
+                resume_data = resume_result.get("resume_data_enhanced", {})
+
+            if isinstance(job_input, dict):
+                job_data = job_input
+            else:
+                job_result = await self.job_parser.run({
+                    "scraped": {"content": job_input},
+                    "enriched": {}
+                })
+                job_data = job_result.get("job_data_enhanced", {})
+
+            # Perform gap analysis
+            gap_result = await self.gap_analyzer.run({
+                "resume_data_enhanced": resume_data,
+                "job_data_enhanced": job_data
+            })
+            gap_analysis = gap_result.get("gap_analysis_advanced", {})
+
+            return {
+                "compatibility_score": gap_analysis.get('overall_match_score', 0),
+                "strong_matches": gap_analysis.get('strong_matches', []),
+                "key_gaps": gap_analysis.get('gaps', []),
+                "recommendations": gap_analysis.get('recommendations', []),
+                "competitive_advantages": gap_analysis.get('competitive_advantages', [])
+            }
+
+        except Exception as e:
+            return {
+                "error": f"Compatibility analysis failed: {e}",
+                "compatibility_score": 0,
+                "strong_matches": [],
+                "key_gaps": [],
+                "recommendations": [],
+                "competitive_advantages": []
+            }
+
+    async def generate_skills_table_async(
+        self,
+        resume_input: Union[str, Dict[str, Any]],
+        job_input: Union[str, Dict[str, Any]],
+        input_type: str = "text"
+    ) -> Dict[str, Any]:
+        """Async skills table generation"""
+        try:
+            # Parse inputs
+            if isinstance(resume_input, dict):
+                resume_data = resume_input
+            else:
+                if input_type == "pdf_path":
+                    resume_text = extract_text_from_pdf(resume_input)
+                else:
+                    resume_text = resume_input
+                resume_result = await self.resume_parser.run(
+                    {"resume_text": resume_text})
+                resume_data = resume_result.get("resume_data_enhanced", {})
+
+            if isinstance(job_input, dict):
+                job_data = job_input
+            else:
+                job_result = await self.job_parser.run({
+                    "scraped": {"content": job_input},
+                    "enriched": {}
+                })
+                job_data = job_result.get("job_data_enhanced", {})
+
+            # Perform gap analysis
+            gap_result = await self.gap_analyzer.run({
+                "resume_data_enhanced": resume_data,
+                "job_data_enhanced": job_data
+            })
+            gap_analysis = gap_result.get("gap_analysis_advanced", {})
+
+            return {
+                "skills_matches": gap_analysis.get('skill_matches', []),
+                "summary": {
+                    "total_requirements": len(gap_analysis.get('all_requirements', [])),
+                    "strong_matches": len(gap_analysis.get('strong_matches', [])),
+                    "partial_matches": len(gap_analysis.get('partial_matches', [])),
+                    "gaps": len(gap_analysis.get('gaps', []))
+                },
+                "overall_score": gap_analysis.get('overall_match_score', 0)
+            }
+
+        except Exception as e:
+            return {
+                "error": f"Skills table generation failed: {e}",
+                "skills_matches": [],
+                "summary": {"total_requirements": 0, "strong_matches": 0, "partial_matches": 0, "gaps": 0},
+                "overall_score": 0
+            }
+
+
+def analyze_resume_job_compatibility(
+    resume_input: Union[str, Dict[str, Any]],
+    job_input: Union[str, Dict[str, Any]],
+    input_type: str = "text"
+) -> Dict[str, Any]:
+    """
+    Quick compatibility analysis between resume and job
+
+    Returns compatibility score and high-level recommendations
+    """
+    import asyncio
+
+    async def async_analyze():
+        orchestrator = EnhancedInterviewOrchestrator()
+
+        try:
+            # Parse inputs
+            if isinstance(resume_input, dict):
+                resume_data = resume_input
+            else:
+                if input_type == "pdf_path":
+                    resume_text = extract_text_from_pdf(resume_input)
+                else:
+                    resume_text = resume_input
+                resume_result = await orchestrator.resume_parser.run(
+                    {"resume_text": resume_text})
+                resume_data = resume_result.get("resume_data_enhanced", {})
+
+            if isinstance(job_input, dict):
+                job_data = job_input
+            else:
+                job_result = await orchestrator.job_parser.run({
+                    "scraped": {"content": job_input},
+                    "enriched": {}
+                })
+                job_data = job_result.get("job_data_enhanced", {})
+
+            # Perform gap analysis
+            gap_result = await orchestrator.gap_analyzer.run({
+                "resume_data_enhanced": resume_data,
+                "job_data_enhanced": job_data
+            })
+            gap_analysis = gap_result.get("gap_analysis_advanced", {})
+
+            return {
+                "compatibility_score": gap_analysis.get(
+                    'overall_match_score', 0),
+                "strong_matches": gap_analysis.get('strong_matches', []),
+                "key_gaps": gap_analysis.get('gaps', []),
+                "recommendations": gap_analysis.get('recommendations', []),
+                "competitive_advantages": gap_analysis.get(
+                    'competitive_advantages', [])
+            }
+
+        except Exception as e:
+            return {
+                "error": f"Compatibility analysis failed: {e}",
+                "compatibility_score": 0,
+                "strong_matches": [],
+                "key_gaps": [],
+                "recommendations": [],
+                "competitive_advantages": []
+            }
+
+    return asyncio.run(async_analyze())
+
+
+def generate_skills_match_table(
+    resume_input: Union[str, Dict[str, Any]],
+    job_input: Union[str, Dict[str, Any]],
+    input_type: str = "text"
+) -> Dict[str, Any]:
+    """
+    Generate detailed skills matching table with scores
+
+    Returns structured table showing match details for each requirement
+    """
+    import asyncio
+
+    async def async_generate():
+        orchestrator = EnhancedInterviewOrchestrator()
+
+        try:
+            # Parse inputs
+            if isinstance(resume_input, dict):
+                resume_data = resume_input
+            else:
+                if input_type == "pdf_path":
+                    resume_text = extract_text_from_pdf(resume_input)
+                else:
+                    resume_text = resume_input
+                resume_result = await orchestrator.resume_parser.run(
+                    {"resume_text": resume_text})
+                resume_data = resume_result.get("resume_data_enhanced", {})
+
+            if isinstance(job_input, dict):
+                job_data = job_input
+            else:
+                job_result = await orchestrator.job_parser.run({
+                    "scraped": {"content": job_input},
+                    "enriched": {}
+                })
+                job_data = job_result.get("job_data_enhanced", {})
+
+            # Get detailed skill matches from gap analysis
+            gap_result = await orchestrator.gap_analyzer.run({
+                "resume_data_enhanced": resume_data,
+                "job_data_enhanced": job_data
+            })
+            gap_analysis = gap_result.get("gap_analysis_advanced", {})
+
+            # Extract skill matches
+            skill_matches = gap_analysis.get("detailed_matches", [])
+
+            return {
+                "skill_matches": skill_matches,
+                "summary": {
+                    "total_requirements": len(skill_matches),
+                    "strong_matches": len([m for m in skill_matches
+                                         if m.get('match_score', 0) > 0.8]),
+                    "partial_matches": len([m for m in skill_matches
+                                          if 0.4 <= m.get('match_score', 0) <= 0.8]),
+                    "gaps": len([m for m in skill_matches
+                               if m.get('match_score', 0) < 0.4])
+                }
+            }
+
+        except Exception as e:
+            return {
+                "error": f"Skills matching failed: {e}",
+                "skill_matches": [],
+                "summary": {
+                    "total_requirements": 0,
+                    "strong_matches": 0,
+                    "partial_matches": 0,
+                    "gaps": 0
+                }
+            }
+
+    return asyncio.run(async_generate()) 

interview_orchestrator.py

@@ -0,0 +1,143 @@
+import asyncio
+import time
+from typing import Dict, Any, Optional
+from metrics import log_metric
+
+# Import all micro-functions
+from micro.scrape import ScrapeMicroFunction
+from micro.enrich import EnrichMicroFunction
+from micro.resume_parser import ResumeParserMicroFunction
+from micro.gap_analysis import GapAnalysisMicroFunction
+from micro.interview_guide import InterviewGuideMicroFunction
+from micro.guide_render import GuideRenderMicroFunction
+
+class InterviewGuideOrchestrator:
+    """
+    Orchestrates the complete personalized interview guide generation pipeline.
+    
+    Pipeline: Resume + Job Posting → Gap Analysis → Personalized Interview Guide
+    """
+    
+    def __init__(self):
+        self.scrape = ScrapeMicroFunction()
+        self.enrich = EnrichMicroFunction()
+        self.resume_parser = ResumeParserMicroFunction()
+        self.gap_analysis = GapAnalysisMicroFunction()
+        self.interview_guide = InterviewGuideMicroFunction()
+        self.guide_render = GuideRenderMicroFunction()
+    
+    async def generate_interview_guide(self, resume_text: str, job_input: str) -> Dict[str, Any]:
+        """
+        Generate a personalized interview guide from resume and job posting.
+        
+        Args:
+            resume_text: Raw resume text or file content
+            job_input: Job posting URL or raw text
+            
+        Returns:
+            Dict containing the complete interview guide and analysis
+        """
+        start_time = time.time()
+        
+        try:
+            # Initialize data pipeline
+            data = {
+                "resume_text": resume_text,
+                "raw_input": job_input,
+                "timestamp": start_time
+            }
+            
+            # Step 1: Process job posting (scrape if URL, otherwise use direct text)
+            log_metric("pipeline_start", {"stage": "job_processing"})
+            data = self.scrape.run(data)
+            
+            if not data.get("success", False):
+                return {"error": "Failed to process job posting", "data": data}
+            
+            # Step 2: Enrich job data (extract structured information)
+            log_metric("pipeline_start", {"stage": "job_enrichment"})
+            data = self.enrich.run(data)
+            
+            if data.get("enriched", {}).get("error"):
+                return {"error": "Failed to extract job data", "data": data}
+            
+            # Step 3: Parse resume (extract structured information)
+            log_metric("pipeline_start", {"stage": "resume_parsing"})
+            data = await self.resume_parser.run(data)
+            
+            if data.get("resume_data", {}).get("error"):
+                return {"error": "Failed to parse resume", "data": data}
+            
+            # Step 4: Perform gap analysis (compare resume vs job requirements)
+            log_metric("pipeline_start", {"stage": "gap_analysis"})
+            data = self.gap_analysis.run(data)
+            
+            if data.get("gap_analysis", {}).get("error"):
+                return {"error": "Failed to perform gap analysis", "data": data}
+            
+            # Step 5: Generate personalized interview guide
+            log_metric("pipeline_start", {"stage": "guide_generation"})
+            data = self.interview_guide.run(data)
+            
+            if data.get("interview_guide", {}).get("error"):
+                return {"error": "Failed to generate interview guide", "data": data}
+            
+            # Step 6: Render final markdown guide
+            log_metric("pipeline_start", {"stage": "guide_rendering"})
+            data = self.guide_render.run(data)
+            
+            # Calculate total pipeline time
+            total_time = time.time() - start_time
+            
+            log_metric("interview_guide_pipeline_complete", {
+                "total_seconds": total_time,
+                "match_score": data.get("gap_analysis", {}).get("match_score", 0),
+                "guide_length": len(data.get("rendered_guide", "")),
+                "success": True
+            })
+            
+            return {
+                "success": True,
+                "rendered_guide": data.get("rendered_guide", ""),
+                "gap_analysis": data.get("gap_analysis", {}),
+                "interview_guide": data.get("interview_guide", {}),
+                "job_data": data.get("enriched", {}),
+                "resume_data": data.get("resume_data", {}),
+                "processing_time": total_time
+            }
+            
+        except Exception as e:
+            log_metric("interview_guide_pipeline_error", {"error": str(e)})
+            return {"error": f"Pipeline failed: {e}", "success": False}
+    
+    def generate_interview_guide_sync(self, resume_text: str, job_input: str) -> Dict[str, Any]:
+        """Synchronous wrapper for the async interview guide generation"""
+        try:
+            return asyncio.run(self.generate_interview_guide(resume_text, job_input))
+        except RuntimeError as e:
+            if "asyncio.run() cannot be called from a running event loop" in str(e):
+                # We're already in an event loop, create a new thread
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(
+                        asyncio.run, 
+                        self.generate_interview_guide(resume_text, job_input)
+                    )
+                    return future.result()
+            else:
+                raise e
+
+# Convenience function for direct usage
+def create_personalized_interview_guide(resume_text: str, job_input: str) -> Dict[str, Any]:
+    """
+    Convenience function to generate a personalized interview guide.
+    
+    Args:
+        resume_text: Resume content (text or parsed from PDF)
+        job_input: Job posting URL or raw text
+        
+    Returns:
+        Complete interview guide with analysis
+    """
+    orchestrator = InterviewGuideOrchestrator()
+    return orchestrator.generate_interview_guide_sync(resume_text, job_input) 

llm_client.py

@@ -0,0 +1,292 @@
+import time
+import os
+import requests
+from typing import Any, Dict, Optional, List
+import openai
+import anthropic
+from config import OPENAI_API_KEY, ANTHROPIC_API_KEY, LLM_CONFIG
+from metrics import log_metric
+
+class LLMClient:
+    def __init__(self):
+        self.openai_client = openai.OpenAI(api_key=OPENAI_API_KEY)
+        self.anthropic_client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
+        self.last_request_time = 0
+        self.request_count = 0
+        
+    def _rate_limit(self):
+        """Simple rate limiting"""
+        current_time = time.time()
+        if current_time - self.last_request_time < 2:  # 2 second between requests
+            time.sleep(2 - (current_time - self.last_request_time))
+        self.last_request_time = time.time()
+        
+    def call_llm(self, prompt: str, provider: str = "openai", 
+                 system: Optional[str] = None, timeout: Optional[float] = None, 
+                 **kwargs) -> str:
+        """Call LLM with system prompt and timeout support"""
+        self._rate_limit()
+        
+        config = LLM_CONFIG[provider]
+        start_time = time.time()
+        
+        # Track tokens for metrics
+        prompt_tokens = len(prompt.split())
+        if system:
+            prompt_tokens += len(system.split())
+        
+        try:
+            if provider == "openai":
+                messages = []
+                if system:
+                    messages.append({"role": "system", "content": system})
+                messages.append({"role": "user", "content": prompt})
+                
+                # Build kwargs without temperature conflicts
+                call_kwargs = {
+                    "model": config["model"],
+                    "messages": messages,
+                    "max_tokens": config["max_tokens"]
+                }
+                
+                # Add kwargs except temperature
+                for k, v in kwargs.items():
+                    if k != "temperature":
+                        call_kwargs[k] = v
+                
+                # Set temperature (prioritize kwargs over config)
+                call_kwargs["temperature"] = kwargs.get("temperature", config["temperature"])
+                if timeout:
+                    call_kwargs["timeout"] = timeout
+                
+                response = self.openai_client.chat.completions.create(**call_kwargs)
+                result = response.choices[0].message.content
+                
+                # Log token usage
+                usage = response.usage
+                tokens_in = usage.prompt_tokens if usage else prompt_tokens
+                tokens_out = usage.completion_tokens if usage else len(result.split())
+                
+            elif provider == "anthropic":
+                # Build kwargs without temperature conflicts
+                call_kwargs = {
+                    "model": config["model"],
+                    "messages": [{"role": "user", "content": prompt}],
+                    "max_tokens": config["max_tokens"]
+                }
+                
+                # Add kwargs except temperature
+                for k, v in kwargs.items():
+                    if k != "temperature":
+                        call_kwargs[k] = v
+                
+                # Set temperature (prioritize kwargs over config)
+                call_kwargs["temperature"] = kwargs.get("temperature", config["temperature"])
+                if system:
+                    call_kwargs["system"] = system
+                if timeout:
+                    call_kwargs["timeout"] = timeout
+                
+                response = self.anthropic_client.messages.create(**call_kwargs)
+                result = response.content[0].text
+                
+                # Log token usage
+                usage = response.usage
+                tokens_in = usage.input_tokens if usage else prompt_tokens
+                tokens_out = usage.output_tokens if usage else len(result.split())
+            
+            else:
+                raise ValueError(f"Unknown provider: {provider}")
+                
+            # Calculate approximate cost (rough estimates)
+            usd_cost = self._calculate_cost(provider, tokens_in, tokens_out)
+            
+            # Log metrics with enhanced data
+            log_metric("llm_call", {
+                "provider": provider,
+                "model": config["model"],
+                "latency": time.time() - start_time,
+                "success": True,
+                "prompt_length": len(prompt),
+                "response_length": len(result),
+                "tokens_in": tokens_in,
+                "tokens_out": tokens_out,
+                "usd_cost": usd_cost
+            })
+            
+            return result
+            
+        except Exception as e:
+            log_metric("llm_error", {
+                "provider": provider,
+                "error": str(e),
+                "latency": time.time() - start_time
+            })
+            
+            # Try fallback provider
+            fallback = LLM_CONFIG["fallback_provider"]
+            if provider != fallback:
+                log_metric("fallback_attempt", {"from": provider, "to": fallback})
+                # Remove temperature from kwargs to avoid duplication
+                fallback_kwargs = {k: v for k, v in kwargs.items() if k != "temperature"}
+                return self.call_llm(prompt, fallback, system=system, 
+                                   timeout=timeout, **fallback_kwargs)
+            else:
+                raise Exception(f"Both LLM providers failed. Last error: {e}")
+    
+    def _calculate_cost(self, provider: str, tokens_in: int, tokens_out: int) -> float:
+        """Calculate approximate USD cost based on token usage"""
+        # Rough pricing estimates (as of 2024)
+        pricing = {
+            "openai": {
+                "gpt-4o-mini": {"input": 0.000150, "output": 0.000600}  # per 1K tokens
+            },
+            "anthropic": {
+                "claude-3-5-sonnet-20241022": {"input": 0.003, "output": 0.015}  # per 1K tokens
+            }
+        }
+        
+        model = LLM_CONFIG[provider]["model"]
+        if provider in pricing and model in pricing[provider]:
+            rates = pricing[provider][model]
+            return (tokens_in * rates["input"] + tokens_out * rates["output"]) / 1000
+        return 0.0
+
+
+def openai_call(text: str, timeout: int) -> str:
+    """
+    Call gpt-4o-mini with temp=0 and max_tokens=400.
+    Returns the JSON string from the assistant.
+    Logs tokens_in, tokens_out, usd_cost via metrics.log_metric().
+    Raises TimeoutError if the call exceeds `timeout` seconds.
+    """
+    system_prompt = """You are an information-extraction engine.
+Return ONLY valid JSON with these lowercase keys:
+company, role, location, seniority, posted_hours, salary_low, salary_high, 
+mission, funding, evidence.
+- mission: company's main value proposition/tagline
+- funding: recent funding round info if mentioned
+- evidence maps each non-null key to the sentence fragment (≤120 chars) that proves it
+Use null if value missing. Do NOT output any extra text."""
+
+    user_prompt = f"""Extract the JSON from this job description:
+<<<
+{text[:2000]}
+>>>"""
+
+    start_time = time.time()
+    
+    try:
+        client = openai.OpenAI(api_key=OPENAI_API_KEY)
+        
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            temperature=0,
+            max_tokens=400,
+            timeout=timeout
+        )
+        
+        result = response.choices[0].message.content or ""
+        
+        # Log metrics
+        usage = response.usage
+        tokens_in = usage.prompt_tokens if usage else len((system_prompt + user_prompt).split())
+        tokens_out = usage.completion_tokens if usage else len(result.split())
+        usd_cost = (tokens_in * 0.000150 + tokens_out * 0.000600) / 1000  # GPT-4o-mini pricing
+        
+        log_metric("llm_call", {
+            "provider": "openai",
+            "model": "gpt-4o-mini", 
+            "latency": time.time() - start_time,
+            "success": True,
+            "prompt_length": len(user_prompt),
+            "response_length": len(result),
+            "tokens_in": tokens_in,
+            "tokens_out": tokens_out,
+            "usd_cost": usd_cost
+        })
+        
+        return result
+        
+    except Exception as e:
+        elapsed = time.time() - start_time
+        if elapsed >= timeout:
+            raise TimeoutError(f"OpenAI call exceeded {timeout}s timeout")
+        
+        log_metric("llm_error", {
+            "provider": "openai",
+            "error": str(e),
+            "latency": elapsed
+        })
+        raise
+
+
+def google_search(query: str, top: int = 3, timeout: int = 5) -> List[str]:
+    """
+    SerpAPI/Bing wrapper for Google search.
+    Returns list of relevant text snippets.
+    Logs google_calls, google_latency_ms via metrics.log_metric().
+    """
+    start_time = time.time()
+    
+    try:
+        # Use SerpAPI if available, otherwise fallback to basic search
+        from config import SERPAPI_KEY
+        if SERPAPI_KEY:
+            url = "https://serpapi.com/search.json"
+            params = {
+                "q": query,
+                "api_key": SERPAPI_KEY,
+                "num": top,
+                "hl": "en",
+                "gl": "us"
+            }
+            
+            response = requests.get(url, params=params, timeout=timeout)
+            response.raise_for_status()
+            data = response.json()
+            
+            snippets = []
+            for result in data.get("organic_results", [])[:top]:
+                snippet = result.get("snippet", "")
+                if snippet:
+                    snippets.append(snippet[:200])  # Limit snippet length
+            
+            # Log successful search
+            log_metric("google_search", {
+                "query": query,
+                "results_count": len(snippets),
+                "latency_ms": (time.time() - start_time) * 1000,
+                "success": True
+            })
+            
+            return snippets
+        
+        else:
+            # Fallback: return empty results if no API key
+            log_metric("google_search", {
+                "query": query,
+                "results_count": 0,
+                "latency_ms": (time.time() - start_time) * 1000,
+                "success": False,
+                "error": "No SERPAPI_KEY available"
+            })
+            return []
+            
+    except Exception as e:
+        log_metric("google_search", {
+            "query": query,
+            "results_count": 0,
+            "latency_ms": (time.time() - start_time) * 1000,
+            "success": False,
+            "error": str(e)
+        })
+        return []
+
+
+# Global client instance
+llm_client = LLMClient() 

metrics.py

@@ -0,0 +1,130 @@
+import json
+import time
+from typing import Any, Dict, Optional
+
+def log_metric(event: str, data: Dict[str, Any]) -> None:
+    """Enhanced logging with support for tokens, cost, and latency metrics"""
+    log = {"event": event, "timestamp": time.time(), **data}
+    
+    # Add structured fields for better analytics
+    if event == "llm_call":
+        # Ensure all required fields are present
+        log.setdefault("tokens_in", 0)
+        log.setdefault("tokens_out", 0)
+        log.setdefault("usd_cost", 0.0)
+        log.setdefault("latency", 0.0)
+        log.setdefault("success", False)
+    
+    elif event == "enrich_latency":
+        # Track enrichment performance
+        log.setdefault("enrich_parallel_seconds", data.get("total_seconds", 0))
+        log.setdefault("facts_count", 0)
+    
+    print(json.dumps(log))
+    # TODO: Add hook for HF Analytics API 
+
+def log_cost_summary(provider: str, total_tokens_in: int, total_tokens_out: int, 
+                     total_cost: float, request_count: int) -> None:
+    """Log cost summary for a session"""
+    log_metric("cost_summary", {
+        "provider": provider,
+        "total_tokens_in": total_tokens_in,
+        "total_tokens_out": total_tokens_out,
+        "total_usd_cost": total_cost,
+        "request_count": request_count,
+        "avg_cost_per_request": total_cost / request_count if request_count > 0 else 0.0
+    })
+
+def log_parallel_performance(serial_time_estimate: float, parallel_time_actual: float) -> None:
+    """Log parallel execution performance gains"""
+    speedup = serial_time_estimate / parallel_time_actual if parallel_time_actual > 0 else 1.0
+    log_metric("parallel_performance", {
+        "serial_time_estimate": serial_time_estimate,
+        "parallel_time_actual": parallel_time_actual,
+        "speedup_factor": speedup,
+        "time_saved_seconds": serial_time_estimate - parallel_time_actual
+    })
+
+def log_llm_call(provider: str, model: str, latency: float, success: bool, 
+                 prompt_length: int, response_length: int, tokens_in: int = 0, 
+                 tokens_out: int = 0, usd_cost: float = 0.0) -> None:
+    """Log LLM call metrics with enhanced token and cost tracking."""
+    
+    log_metric("llm_call", {
+        "provider": provider,
+        "model": model,
+        "latency": latency,
+        "success": success,
+        "prompt_length": prompt_length,
+        "response_length": response_length,
+        "tokens_in": tokens_in,
+        "tokens_out": tokens_out,
+        "usd_cost": usd_cost
+    })
+
+def log_google_search(query: str, results_count: int, latency_ms: float, 
+                      success: bool, error: Optional[str] = None) -> None:
+    """Log Google search call metrics."""
+    
+    data = {
+        "query": query,
+        "results_count": results_count,
+        "latency_ms": latency_ms,
+        "success": success
+    }
+    
+    if error:
+        data["error"] = error
+    
+    log_metric("google_search", data)
+
+def log_patch_missing(company: str, patches_applied: int, source_map: Dict[str, str]) -> None:
+    """Log Google patching metrics."""
+    
+    log_metric("patch_missing", {
+        "company": company,
+        "patches_applied": patches_applied,
+        "source_map": source_map,
+        "google_calls": len([v for v in source_map.values() if v == "google"])
+    })
+
+def log_enrich_latency(company: str, total_seconds: float, facts_count: int, 
+                       enrich_parallel_seconds: Optional[float] = None) -> None:
+    """Log enrichment pipeline latency."""
+    
+    data = {
+        "company": company,
+        "total_seconds": total_seconds,
+        "facts_count": facts_count
+    }
+    
+    if enrich_parallel_seconds is not None:
+        data["enrich_parallel_seconds"] = enrich_parallel_seconds
+    
+    log_metric("enrich_latency", data)
+
+def log_render_success(total_length: int, has_qa: bool, has_critique: bool, 
+                       quality_score: Optional[float] = None, has_buckets: bool = False) -> None:
+    """Log successful render metrics."""
+    
+    log_metric("render_success", {
+        "total_length": total_length,
+        "has_qa": has_qa,
+        "has_critique": has_critique,
+        "quality_score": quality_score,
+        "has_buckets": has_buckets
+    })
+
+def log_cache_hit(input_text: str) -> None:
+    """Log cache hit for input."""
+    
+    log_metric("cache_hit", {
+        "input": input_text[:100] + "..." if len(input_text) > 100 else input_text
+    })
+
+def log_cache_miss(input_text: str) -> None:
+    """Log cache miss for input."""
+    
+    log_metric("cache_miss", {
+        "input": input_text[:100] + "..." if len(input_text) > 100 else input_text
+    }) 

micro/__init__.py

@@ -0,0 +1 @@
+# Micro-functions package 

micro/advanced_gap_analysis.py

@@ -0,0 +1,571 @@
+"""
+Advanced Gap Analysis - Provides true skills matching with semantic similarity
+"""
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass
+from difflib import SequenceMatcher
+
+from metrics import log_metric
+from llm_client import LLMClient
+
+
+@dataclass
+class SkillMatch:
+    """Detailed skill matching result"""
+    job_requirement: str
+    resume_skill: str
+    match_score: float
+    match_type: str  # "strong", "partial", "weak", "missing"
+    importance: str  # "required", "preferred", "nice_to_have"
+    recommendation: str
+    category: str
+
+
+@dataclass
+class GapAnalysisResult:
+    """Complete gap analysis result"""
+    overall_match_score: float
+    strong_matches: List[SkillMatch]
+    partial_matches: List[SkillMatch]
+    gaps: List[SkillMatch]
+    strengths_summary: str
+    gaps_summary: str
+    competitive_advantages: List[str]
+    preparation_priority: List[str]
+    interview_focus_areas: List[str]
+    skill_categories_analysis: Dict[str, float]
+
+
+class AdvancedSkillMatcher:
+    """Advanced skill matching with semantic similarity"""
+
+    def __init__(self):
+        self.skill_synonyms = {
+            # Programming Languages
+            "python": ["python3", "py", "python programming"],
+            "javascript": ["js", "ecmascript", "node.js", "nodejs"],
+            "typescript": ["ts"],
+            "react": ["reactjs", "react.js"],
+            "vue": ["vue.js", "vuejs"],
+            "angular": ["angularjs"],
+            # Frameworks & Libraries
+            "express": ["express.js", "expressjs"],
+            "django": ["django framework"],
+            "flask": ["flask framework"],
+            "spring": ["spring boot", "spring framework"],
+            "laravel": ["laravel framework"],
+            # Databases
+            "postgresql": ["postgres", "psql"],
+            "mongodb": ["mongo"],
+            "mysql": ["my sql"],
+            # Cloud Platforms
+            "aws": ["amazon web services"],
+            "gcp": ["google cloud platform", "google cloud"],
+            "azure": ["microsoft azure"],
+            # DevOps & Tools
+            "kubernetes": ["k8s"],
+            "docker": ["containers", "containerization"],
+            "jenkins": ["ci/cd"],
+            "git": ["version control", "github", "gitlab"],
+            # Data & ML
+            "machine learning": ["ml", "artificial intelligence", "ai"],
+            "deep learning": ["dl", "neural networks"],
+            "tensorflow": ["tf"],
+            "pytorch": ["torch"],
+            "pandas": ["data analysis"],
+            "numpy": ["numerical computing"],
+            # Other
+            "agile": ["scrum", "kanban"],
+            "restful": ["rest api", "rest apis", "api development"],
+            "microservices": ["micro services", "service oriented architecture"]
+        }
+
+    def normalize_skill(self, skill: str) -> str:
+        """Normalize skill name using synonyms"""
+        skill_lower = skill.lower().strip()
+
+        # Direct match
+        if skill_lower in self.skill_synonyms:
+            return skill_lower
+
+        # Check if it's a synonym
+        for main_skill, synonyms in self.skill_synonyms.items():
+            if skill_lower in synonyms:
+                return main_skill
+
+        return skill_lower
+
+    def calculate_similarity(self, skill1: str, skill2: str) -> float:
+        """Calculate semantic similarity between two skills"""
+        norm1 = self.normalize_skill(skill1)
+        norm2 = self.normalize_skill(skill2)
+
+        # Direct match after normalization
+        if norm1 == norm2:
+            return 1.0
+
+        # Partial matching using SequenceMatcher
+        similarity = SequenceMatcher(None, norm1, norm2).ratio()
+
+        # Boost for containing relationships
+        if norm1 in norm2 or norm2 in norm1:
+            similarity = max(similarity, 0.8)
+
+        return similarity
+
+    def find_best_match(self, job_requirement: str,
+                       resume_skills: List[str]) -> tuple[str, float]:
+        """Find the best matching resume skill for a job requirement"""
+        best_skill = ""
+        best_score = 0.0
+
+        for resume_skill in resume_skills:
+            score = self.calculate_similarity(job_requirement, resume_skill)
+            if score > best_score:
+                best_score = score
+                best_skill = resume_skill
+
+        return best_skill, best_score
+
+
+class AdvancedGapAnalysis:
+    """Advanced gap analysis with true skills matching"""
+
+    def __init__(self):
+        self.matcher = AdvancedSkillMatcher()
+        self.llm_client = LLMClient()
+
+    async def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Main entry point for gap analysis"""
+        try:
+            # Extract resume and job data
+            resume_data = data.get("resume_data_enhanced", {})
+            job_data = data.get("job_data_enhanced", {})
+
+            if not resume_data or not job_data:
+                return {**data, "gap_analysis_advanced": {
+                    "error": "Missing resume or job data"}}
+
+            # Perform advanced gap analysis
+            analysis_result = await self._analyze_comprehensive_fit(
+                resume_data, job_data)
+
+            log_metric("gap_analysis_advanced_success", {
+                "match_score": analysis_result.overall_match_score,
+                "strong_matches": len(analysis_result.strong_matches),
+                "gaps": len(analysis_result.gaps)
+            })
+
+            return {**data, "gap_analysis_advanced": self._format_result(
+                analysis_result)}
+
+        except Exception as e:
+            log_metric("gap_analysis_advanced_error", {"error": str(e)})
+            return {**data, "gap_analysis_advanced": {
+                "error": f"Advanced gap analysis failed: {e}"}}
+
+    async def _analyze_comprehensive_fit(
+        self, resume_data: Dict[str, Any], job_data: Dict[str, Any]
+    ) -> GapAnalysisResult:
+        """Perform comprehensive fit analysis"""
+
+        # Extract skills from resume
+        resume_skills = self._extract_resume_skills(resume_data)
+
+        # Extract requirements from job
+        job_requirements = self._extract_job_requirements(job_data)
+
+        # Perform detailed matching
+        skill_matches = self._match_skills_detailed(
+            job_requirements, resume_skills)
+
+        # Calculate overall score
+        overall_score = self._calculate_overall_score(skill_matches)
+
+        # Categorize matches
+        strong_matches = [m for m in skill_matches if m.match_score >= 0.8]
+        partial_matches = [m for m in skill_matches
+                          if 0.4 <= m.match_score < 0.8]
+        gaps = [m for m in skill_matches if m.match_score < 0.4]
+
+        # Generate AI-powered analysis
+        strengths_summary = await self._generate_strengths_summary(
+            strong_matches, resume_data)
+        gaps_summary = await self._generate_gaps_summary(gaps, job_data)
+
+        # Extract competitive advantages
+        competitive_advantages = self._identify_competitive_advantages(
+            resume_data, job_data, strong_matches)
+
+        # Generate preparation priorities
+        preparation_priority = self._generate_preparation_priority(
+            gaps, partial_matches)
+
+        # Identify interview focus areas
+        interview_focus = self._identify_interview_focus_areas(
+            strong_matches, gaps)
+
+        # Analyze by skill categories
+        categories_analysis = self._analyze_skill_categories(skill_matches)
+
+        return GapAnalysisResult(
+            overall_match_score=overall_score,
+            strong_matches=strong_matches,
+            partial_matches=partial_matches,
+            gaps=gaps,
+            strengths_summary=strengths_summary,
+            gaps_summary=gaps_summary,
+            competitive_advantages=competitive_advantages,
+            preparation_priority=preparation_priority,
+            interview_focus_areas=interview_focus,
+            skill_categories_analysis=categories_analysis
+        )
+
+    def _extract_resume_skills(self, resume_data: Dict[str, Any]) -> List[str]:
+        """Extract all skills from resume data"""
+        all_skills = []
+
+        # Get skills from structured skills section
+        skills_obj = resume_data.get("skills", {})
+        if isinstance(skills_obj, dict):
+            for category, skills_list in skills_obj.items():
+                if isinstance(skills_list, list):
+                    all_skills.extend(skills_list)
+
+        # Get skills from experience
+        experience = resume_data.get("experience", [])
+        for exp in experience:
+            if isinstance(exp, dict):
+                tech_skills = exp.get("technologies", [])
+                if isinstance(tech_skills, list):
+                    all_skills.extend(tech_skills)
+
+        # Get skills from projects
+        projects = resume_data.get("projects", [])
+        for project in projects:
+            if isinstance(project, dict):
+                tech_skills = project.get("technologies", [])
+                if isinstance(tech_skills, list):
+                    all_skills.extend(tech_skills)
+
+        # Deduplicate and clean
+        return list(set([skill.strip() for skill in all_skills if skill]))
+
+    def _extract_job_requirements(self,
+                                 job_data: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Extract requirements from job data"""
+        requirements = []
+
+        # Handle enhanced job parser structure
+        for req_type in ["tech_requirements", "experience_requirements", 
+                        "education_requirements", "soft_skill_requirements"]:
+            structured_reqs = job_data.get(req_type, [])
+            if isinstance(structured_reqs, list):
+                # Convert JobRequirement objects to dicts if needed
+                for req in structured_reqs:
+                    if isinstance(req, dict):
+                        requirements.append(req)
+                    else:
+                        # Handle dataclass objects
+                        requirements.append({
+                            "skill": getattr(req, 'skill', str(req)),
+                            "importance": getattr(req, 'importance', 'required'),
+                            "category": getattr(req, 'category', 'technical')
+                        })
+
+        # Fallback: legacy requirements key
+        if not requirements:
+            structured_reqs = job_data.get("requirements", [])
+            if isinstance(structured_reqs, list):
+                requirements.extend(structured_reqs)
+
+        # Last fallback: extract from text fields
+        if not requirements:
+            requirements = self._extract_requirements_from_text(job_data)
+
+        return requirements
+
+    def _extract_requirements_from_text(self,
+                                       job_data: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Extract requirements from job description text"""
+        requirements = []
+
+        # Common skill patterns
+        common_skills = [
+            "python", "javascript", "react", "node.js", "sql", "aws",
+            "docker", "kubernetes", "git", "machine learning", "tensorflow",
+            "django", "flask", "express", "mongodb", "postgresql"
+        ]
+
+        # Extract from various text fields
+        text_content = ""
+        for field in ["description", "content", "scraped"]:
+            if field in job_data:
+                if isinstance(job_data[field], str):
+                    text_content += job_data[field]
+                elif isinstance(job_data[field], dict):
+                    text_content += str(job_data[field])
+
+        text_lower = text_content.lower()
+
+        for skill in common_skills:
+            if skill.lower() in text_lower:
+                requirements.append({
+                    "skill": skill,
+                    "importance": "required",
+                    "category": "technical"
+                })
+
+        return requirements
+
+    def _match_skills_detailed(self, job_requirements: List[Dict[str, Any]],
+                              resume_skills: List[str]) -> List[SkillMatch]:
+        """Perform detailed skill matching"""
+        matches = []
+
+        for req in job_requirements:
+            req_skill = req.get("skill", "")
+            importance = req.get("importance", "required")
+            category = req.get("category", "technical")
+
+            # Find best match
+            best_match, score = self.matcher.find_best_match(
+                req_skill, resume_skills)
+
+            # Determine match type
+            if score >= 0.8:
+                match_type = "strong"
+            elif score >= 0.4:
+                match_type = "partial"
+            elif score > 0:
+                match_type = "weak"
+            else:
+                match_type = "missing"
+
+            # Generate recommendation
+            recommendation = self._generate_skill_recommendation(
+                req_skill, best_match, score, importance)
+
+            matches.append(SkillMatch(
+                job_requirement=req_skill,
+                resume_skill=best_match if score > 0 else "Not Found",
+                match_score=score,
+                match_type=match_type,
+                importance=importance,
+                recommendation=recommendation,
+                category=category
+            ))
+
+        return matches
+
+    def _calculate_overall_score(self, matches: List[SkillMatch]) -> float:
+        """Calculate weighted overall match score"""
+        if not matches:
+            return 0.0
+
+        # Weight by importance
+        importance_weights = {
+            "required": 1.0,
+            "preferred": 0.7,
+            "nice_to_have": 0.3
+        }
+
+        total_weighted_score = 0.0
+        total_weight = 0.0
+
+        for match in matches:
+            weight = importance_weights.get(match.importance, 0.5)
+            total_weighted_score += match.match_score * weight
+            total_weight += weight
+
+        return (total_weighted_score / total_weight * 100) if total_weight > 0 else 0
+
+    def _generate_skill_recommendation(self, job_skill: str, resume_skill: str,
+                                     score: float, importance: str) -> str:
+        """Generate actionable recommendation for skill match"""
+        if score >= 0.8:
+            return f"Highlight your {resume_skill} experience"
+        elif score >= 0.4:
+            return f"Connect your {resume_skill} to {job_skill} requirements"
+        elif importance == "required":
+            return f"Critical: Learn {job_skill} before applying"
+        elif importance == "preferred":
+            return f"Important: Gain experience with {job_skill}"
+        else:
+            return f"Nice-to-have: Consider learning {job_skill}"
+
+    async def _generate_strengths_summary(self, strong_matches: List[SkillMatch],
+                                        resume_data: Dict[str, Any]) -> str:
+        """Generate AI-powered strengths summary"""
+        if not strong_matches:
+            return "No strong technical matches found."
+
+        skills_list = [match.job_requirement for match in strong_matches[:5]]
+        experience_years = resume_data.get("years_of_experience", 0)
+
+        prompt = f"""
+        Based on these strong skill matches: {', '.join(skills_list)} and
+        {experience_years} years of experience, write a 2-sentence summary of
+        the candidate's key strengths for this role.
+        Focus on practical value and competitive advantages.
+        """
+
+        try:
+            response = self.llm_client.call_llm(
+                prompt, temperature=0.3, max_tokens=150)
+            return response.strip()
+        except Exception:
+            return (f"Strong technical foundation in {', '.join(skills_list[:3])} "
+                   f"with {experience_years} years of experience.")
+
+    async def _generate_gaps_summary(self, gaps: List[SkillMatch],
+                                   job_data: Dict[str, Any]) -> str:
+        """Generate AI-powered gaps summary"""
+        if not gaps:
+            return "No significant skill gaps identified."
+
+        critical_gaps = [gap.job_requirement for gap in gaps
+                        if gap.importance == "required"]
+
+        if not critical_gaps:
+            return "No critical skill gaps. Focus on strengthening preferences."
+
+        prompt = f"""
+        The candidate is missing these required skills: {', '.join(critical_gaps[:3])}.
+        Write a 2-sentence summary of the main gaps and preparation strategy.
+        Be constructive and actionable.
+        """
+
+        try:
+            response = self.llm_client.call_llm(
+                prompt, temperature=0.3, max_tokens=150)
+            return response.strip()
+        except Exception:
+            return (f"Key gaps in {', '.join(critical_gaps[:2])}. "
+                   "Focus preparation on these critical areas.")
+
+    def _identify_competitive_advantages(self, resume_data: Dict[str, Any],
+                                       job_data: Dict[str, Any],
+                                       strong_matches: List[SkillMatch]) -> List[str]:
+        """Identify unique competitive advantages"""
+        advantages = []
+
+        # Experience level advantage
+        years_exp = resume_data.get("years_of_experience", 0)
+        if years_exp > 5:
+            advantages.append(f"{years_exp}+ years of proven experience")
+
+        # Education advantage
+        education = resume_data.get("education", [])
+        for edu in education:
+            if isinstance(edu, dict) and "degree" in edu:
+                degree = edu["degree"]
+                if "master" in degree.lower() or "phd" in degree.lower():
+                    advantages.append(f"Advanced degree: {degree}")
+                    break
+
+        # Skill combination advantages
+        strong_skills = [match.job_requirement for match in strong_matches]
+        if len(strong_skills) >= 3:
+            advantages.append(
+                f"Strong combination: {', '.join(strong_skills[:3])}")
+
+        # Project portfolio
+        projects = resume_data.get("projects", [])
+        if len(projects) >= 2:
+            advantages.append(f"Proven track record: {len(projects)} projects")
+
+        return advantages[:4]  # Limit to top 4
+
+    def _generate_preparation_priority(self, gaps: List[SkillMatch],
+                                     partial_matches: List[SkillMatch]) -> List[str]:
+        """Generate preparation priority list"""
+        priorities = []
+
+        # Critical gaps first
+        critical_gaps = [gap.job_requirement for gap in gaps
+                        if gap.importance == "required"]
+        priorities.extend(critical_gaps[:3])
+
+        # Important partial matches to strengthen
+        important_partials = [match.job_requirement for match in partial_matches
+                            if match.importance in ["required", "preferred"]]
+        priorities.extend(important_partials[:2])
+
+        return priorities[:5]
+
+    def _identify_interview_focus_areas(self, strong_matches: List[SkillMatch],
+                                      gaps: List[SkillMatch]) -> List[str]:
+        """Identify areas to focus on during interview"""
+        focus_areas = []
+
+        # Highlight strengths
+        if strong_matches:
+            top_strengths = [match.job_requirement for match in strong_matches[:2]]
+            focus_areas.extend([f"Demonstrate {skill} expertise"
+                              for skill in top_strengths])
+
+        # Address concerns proactively
+        critical_gaps = [gap.job_requirement for gap in gaps
+                        if gap.importance == "required"]
+        if critical_gaps:
+            focus_areas.append(
+                f"Address learning plan for {critical_gaps[0]}")
+
+        # General advice
+        focus_areas.extend([
+            "Emphasize problem-solving approach",
+            "Show enthusiasm for learning"
+        ])
+
+        return focus_areas[:5]
+
+    def _analyze_skill_categories(self, matches: List[SkillMatch]) -> Dict[str, float]:
+        """Analyze performance by skill category"""
+        categories = {}
+
+        for match in matches:
+            category = match.category
+            if category not in categories:
+                categories[category] = []
+            categories[category].append(match.match_score)
+
+        # Calculate averages
+        category_scores = {}
+        for category, scores in categories.items():
+            if scores:
+                category_scores[category] = sum(scores) / len(scores) * 100
+
+        return category_scores
+
+    def _format_result(self, result: GapAnalysisResult) -> Dict[str, Any]:
+        """Format result for output"""
+        return {
+            "overall_match_score": result.overall_match_score,
+            "strong_matches": [self._format_skill_match(m)
+                             for m in result.strong_matches],
+            "partial_matches": [self._format_skill_match(m)
+                              for m in result.partial_matches],
+            "gaps": [self._format_skill_match(m) for m in result.gaps],
+            "strengths_summary": result.strengths_summary,
+            "gaps_summary": result.gaps_summary,
+            "competitive_advantages": result.competitive_advantages,
+            "preparation_priority": result.preparation_priority,
+            "interview_focus_areas": result.interview_focus_areas,
+            "skill_categories_analysis": result.skill_categories_analysis,
+            "detailed_matches": [self._format_skill_match(m)
+                               for m in result.strong_matches +
+                               result.partial_matches + result.gaps]
+        }
+
+    def _format_skill_match(self, match: SkillMatch) -> Dict[str, Any]:
+        """Format individual skill match"""
+        return {
+            "job_requirement": match.job_requirement,
+            "resume_skill": match.resume_skill,
+            "match_score": round(match.match_score, 2),
+            "match_type": match.match_type,
+            "importance": match.importance,
+            "recommendation": match.recommendation,
+            "category": match.category
+        } 

micro/bucket_enrich.py

@@ -0,0 +1,301 @@
+import asyncio
+import time
+import re
+from typing import Dict, List, Optional, Any
+import requests
+from bs4 import BeautifulSoup
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.common.exceptions import TimeoutException, WebDriverException
+from webdriver_manager.chrome import ChromeDriverManager
+from selenium.webdriver.chrome.service import Service
+from metrics import log_metric
+
+class BucketEnrichMicroFunction:
+    def __init__(self):
+        self.chrome_options = Options()
+        self.chrome_options.add_argument('--headless')
+        self.chrome_options.add_argument('--no-sandbox')
+        self.chrome_options.add_argument('--disable-dev-shm-usage')
+        self.chrome_options.add_argument('--disable-gpu')
+        self.chrome_options.add_argument('--window-size=1920,1080')
+        self.chrome_options.add_argument('--user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36')
+    
+    def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Main enrichment pipeline with async parallel execution"""
+        start_time = time.time()
+        enriched_data = data.get("enriched", {})
+        
+        company = enriched_data.get("company", "Unknown")
+        location = enriched_data.get("location", "Unknown") 
+        raw_input = data.get("raw_input", "")
+        
+        # Skip if no company identified
+        if company in ["Unknown", "", None, "Not specified"]:
+            log_metric("bucket_enrich_skip", {"reason": "no_company"})
+            return {**data, "bucket_facts": {}}
+        
+        try:
+            # Run enrichments in parallel using asyncio
+            bucket_facts = asyncio.run(self._async_enrich_all(company, location, raw_input))
+            
+            # Log enrichment latency
+            total_time = time.time() - start_time
+            log_metric("enrich_latency", {
+                "company": company,
+                "total_seconds": total_time,
+                "facts_count": len(bucket_facts)
+            })
+            log_metric("enrich_parallel_seconds", {"value": total_time})
+            
+            return {**data, "bucket_facts": bucket_facts}
+            
+        except Exception as e:
+            log_metric("bucket_enrich_error", {"company": company, "error": str(e)})
+            return {**data, "bucket_facts": {}}
+    
+    async def _async_enrich_all(self, company: str, location: str, raw_input: str) -> Dict[str, str]:
+        """Run all enrichments in parallel"""
+        # Prepare tasks for parallel execution
+        tasks = []
+        
+        # Manager & Team enrichment (LinkedIn-based)
+        if "linkedin.com" in raw_input:
+            tasks.append(self._async_manager_enrich(raw_input))
+        else:
+            tasks.append(self._async_empty_result())
+        
+        # Company-based enrichments
+        if company not in ["Unknown", "", None, "Not specified"]:
+            tasks.extend([
+                self._async_stack_enrich(company),
+                self._async_biz_enrich(company),
+                self._async_comp_enrich(company, location),
+                self._async_culture_enrich(company)
+            ])
+        else:
+            tasks.extend([
+                self._async_empty_result(),
+                self._async_empty_result(),
+                self._async_empty_result(),
+                self._async_empty_result()
+            ])
+        
+        # Execute all tasks in parallel
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Merge results
+        bucket_facts = {}
+        for result in results:
+            if isinstance(result, dict):
+                bucket_facts.update(result)
+            elif isinstance(result, Exception):
+                log_metric("async_enrich_error", {"error": str(result)})
+        
+        return bucket_facts
+    
+    async def _async_empty_result(self) -> Dict[str, str]:
+        """Return empty result for skipped enrichments"""
+        return {}
+    
+    async def _async_manager_enrich(self, linkedin_url: str) -> Dict[str, str]:
+        """Async wrapper for manager enrichment"""
+        return await asyncio.get_event_loop().run_in_executor(
+            None, self.manager_enrich, linkedin_url
+        )
+    
+    async def _async_stack_enrich(self, company: str) -> Dict[str, str]:
+        """Async wrapper for stack enrichment"""
+        return await asyncio.get_event_loop().run_in_executor(
+            None, self.stack_enrich, company
+        )
+    
+    async def _async_biz_enrich(self, company: str) -> Dict[str, str]:
+        """Async wrapper for business enrichment"""
+        return await asyncio.get_event_loop().run_in_executor(
+            None, self.biz_enrich, company
+        )
+    
+    async def _async_comp_enrich(self, company: str, location: str) -> Dict[str, str]:
+        """Async wrapper for compensation enrichment"""
+        return await asyncio.get_event_loop().run_in_executor(
+            None, self.comp_enrich, company, location
+        )
+    
+    async def _async_culture_enrich(self, company: str) -> Dict[str, str]:
+        """Async wrapper for culture enrichment"""
+        return await asyncio.get_event_loop().run_in_executor(
+            None, self.culture_enrich, company
+        )
+    
+    def manager_enrich(self, linkedin_url: str) -> Dict[str, str]:
+        """Extract hiring manager and team info from LinkedIn job page"""
+        facts = {}
+            
+        try:
+            options = Options()
+            options.add_argument("--headless")
+            options.add_argument("--no-sandbox")
+            options.add_argument("--disable-dev-shm-usage")
+            options.add_argument("--user-data-dir=/tmp/chrome_user_data")
+            
+            driver = webdriver.Chrome(
+                service=Service(ChromeDriverManager().install()),
+                options=options
+            )
+            
+            driver.get(linkedin_url)
+            time.sleep(2)
+            
+            # Look for hiring manager info
+            try:
+                manager_element = driver.find_element(By.CSS_SELECTOR, '[data-test-id="hiring-manager"]')
+                if manager_element:
+                    facts["hiring_manager"] = manager_element.text.strip()
+            except:
+                pass
+            
+            # Look for team size indicators
+            try:
+                team_elements = driver.find_elements(By.XPATH, "//*[contains(text(), 'team') or contains(text(), 'employees')]")
+                for element in team_elements[:2]:
+                    text = element.text.lower()
+                    if any(keyword in text for keyword in ["team of", "team size", "employees"]):
+                        facts["team_info"] = element.text.strip()
+                        break
+            except:
+                pass
+                
+            driver.quit()
+            
+        except Exception as e:
+            log_metric("manager_enrich_error", {"url": linkedin_url, "error": str(e)})
+            facts["manager_error"] = f"Failed to extract manager info: {str(e)}"
+        
+        return facts
+    
+    def stack_enrich(self, company: str) -> Dict[str, str]:
+        """Get tech stack info from StackShare and GitHub"""
+        facts = {}
+        
+        try:
+            # StackShare lookup (2s timeout)
+            stackshare_url = f"https://stackshare.io/{company.lower().replace(' ', '-')}"
+            response = requests.get(stackshare_url, timeout=2)
+            
+            if response.status_code == 200:
+                soup = BeautifulSoup(response.content, 'html.parser')
+                
+                # Extract popular tools
+                tool_elements = soup.find_all(class_=re.compile("tool|stack"))
+                tools = []
+                for elem in tool_elements[:10]:
+                    text = elem.get_text().strip()
+                    if text and len(text) < 50:
+                        tools.append(text)
+                
+                if tools:
+                    facts["tech_stack"] = f"Popular tools: {', '.join(tools[:5])}"
+        
+        except Exception as e:
+            log_metric("stack_enrich_error", {"company": company, "error": str(e)})
+        
+        return facts
+    
+    def biz_enrich(self, company: str) -> Dict[str, str]:
+        """Get business context from recent news and company info"""
+        facts = {}
+        
+        try:
+            # Recent news search (2s timeout)
+            search_query = f"{company} news site:techcrunch.com OR site:bloomberg.com OR site:reuters.com"
+            search_url = f"https://www.google.com/search?q={search_query}&tbm=nws&tbs=qdr:m2"
+            
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36'
+            }
+            
+            response = requests.get(search_url, headers=headers, timeout=2)
+            if response.status_code == 200:
+                soup = BeautifulSoup(response.content, 'html.parser')
+                
+                # Extract recent headlines
+                headlines = []
+                for elem in soup.find_all(['h3', 'h4'], limit=3):
+                    if elem.text.strip():
+                        headlines.append(elem.text.strip())
+                
+                if headlines:
+                    facts["recent_news"] = " | ".join(headlines[:2])
+                    
+        except Exception:
+            pass
+        
+        # Basic company info
+        try:
+            # Simple company lookup
+            facts["company_domain"] = f"{company.lower().replace(' ', '')}.com"
+            
+        except Exception:
+            pass
+        
+        return facts
+    
+    def comp_enrich(self, company: str, location: str) -> Dict[str, str]:
+        """Get compensation data from levels.fyi"""
+        facts = {}
+        
+        try:
+            # Levels.fyi lookup (2s timeout)
+            levels_url = f"https://www.levels.fyi/companies/{company.lower().replace(' ', '-')}"
+            response = requests.get(levels_url, timeout=2)
+            
+            if response.status_code == 200:
+                soup = BeautifulSoup(response.content, 'html.parser')
+                
+                # Look for salary ranges
+                salary_elements = soup.find_all(text=re.compile(r'\$\d{2,3}[kK]'))
+                if salary_elements:
+                    salaries = [elem.strip() for elem in salary_elements[:3]]
+                    facts["salary_range_levels"] = " - ".join(salaries)
+                    facts["levels_url"] = f"🔗 {levels_url}"
+                    
+        except Exception:
+            pass
+        
+        return facts
+    
+    def culture_enrich(self, company: str) -> Dict[str, str]:
+        """Get culture and work-life balance info from Blind"""
+        facts = {}
+        
+        try:
+            # Blind company lookup (2s timeout)
+            blind_url = f"https://www.teamblind.com/company/{company.lower().replace(' ', '-')}"
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36'
+            }
+            
+            response = requests.get(blind_url, headers=headers, timeout=2)
+            
+            if response.status_code == 200:
+                soup = BeautifulSoup(response.content, 'html.parser')
+                
+                # Look for ratings
+                rating_elements = soup.find_all(text=re.compile(r'\d\.\d'))
+                if rating_elements:
+                    facts["blind_rating"] = rating_elements[0].strip()
+                    facts["blind_url"] = f"🔗 {blind_url}"
+                    
+                # Look for culture keywords
+                culture_keywords = soup.find_all(text=re.compile(r'work.?life|culture|benefits|remote'))
+                if culture_keywords:
+                    facts["culture_mentions"] = " | ".join([kw.strip() for kw in culture_keywords[:2]])
+                    
+        except Exception:
+            pass
+        
+        return facts 

micro/critique.py

@@ -0,0 +1,69 @@
+from typing import Any, Dict
+from llm_client import llm_client
+from prompt_loader import prompt_loader
+from metrics import log_metric
+
+class CritiqueMicroFunction:
+    def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        draft = data.get("draft", "")
+        qa_result = data.get("qa_result", "")
+        enriched_data = data.get("enriched", {})
+        
+        if not draft or "failed" in draft.lower():
+            return {**data, "critique": "Critique skipped due to draft errors."}
+        
+        try:
+            # Use LLM to provide detailed critique
+            prompt = prompt_loader.get_prompt("critique_prompt", draft=draft)
+            
+            critique_prompt = prompt + f"""
+
+Provide a comprehensive critique of this job role preview, focusing on:
+
+## Critical Analysis
+1. **Factual Accuracy**: Cross-check details against source data
+2. **Market Reality**: Are salary/requirements realistic for the role/level?
+3. **Completeness**: Missing critical information?
+4. **Tone & Style**: Appropriate for job seekers?
+5. **Actionability**: Are recommendations specific and useful?
+
+## Context
+- QA Results: {qa_result}
+- Source Job Data: {enriched_data}
+
+## Content to Critique
+{draft}
+
+## Critique Format
+**Strengths**: What works well
+**Weaknesses**: Areas needing improvement  
+**Factual Issues**: Any inaccuracies found
+**Market Insights**: Industry-specific observations
+**Recommendations**: Specific improvements
+**Risk Assessment**: Potential issues for job seekers
+**Overall Score**: [1-10] with justification
+
+Be constructive but thorough. This critique helps ensure job seekers get accurate, helpful guidance.
+"""
+            
+            critique_response = llm_client.call_llm(critique_prompt)
+            
+            # Extract overall score if present
+            score = None
+            if "overall score" in critique_response.lower():
+                import re
+                score_match = re.search(r'(\d+(?:\.\d+)?)/10|(\d+(?:\.\d+)?)\s*(?:out of|/)\s*10', critique_response.lower())
+                if score_match:
+                    score = float(score_match.group(1) or score_match.group(2))
+            
+            log_metric("critique_success", {
+                "content_length": len(draft),
+                "critique_length": len(critique_response),
+                "quality_score": score
+            })
+            
+            return {**data, "critique": critique_response, "quality_score": score}
+            
+        except Exception as e:
+            log_metric("critique_error", {"error": str(e)})
+            return {**data, "critique": f"Critique failed: {e}"} 

micro/draft.py

@@ -0,0 +1,75 @@
+from typing import Any, Dict
+from llm_client import llm_client
+from prompt_loader import prompt_loader
+from metrics import log_metric
+
+class DraftMicroFunction:
+    def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        enriched_data = data.get("enriched", {})
+        scraped_text = data.get("scraped_text", "")
+        
+        if not enriched_data or enriched_data.get("error"):
+            return {**data, "draft": "Unable to draft content due to enrichment errors."}
+        
+        try:
+            # Prepare context for drafting
+            context = {
+                "role": enriched_data.get("role", "Unknown Role"),
+                "company": enriched_data.get("company", "Unknown Company"),
+                "level": enriched_data.get("level", "Unknown Level"),
+                "requirements": enriched_data.get("requirements", []),
+                "responsibilities": enriched_data.get("responsibilities", []),
+                "tech_stack": enriched_data.get("tech_stack", []),
+                "salary_range": enriched_data.get("salary_range", "Not specified"),
+                "work_mode": enriched_data.get("work_mode", "Not specified")
+            }
+            
+            # Use LLM to draft comprehensive content
+            prompt = prompt_loader.get_prompt("draft_prompt", job_data=str(context))
+            
+            detailed_prompt = prompt + f"""
+
+Based on this job data: {context}
+
+Create a comprehensive role preview and interview preparation kit with:
+
+## 🎯 Role Overview
+- Role summary and key focus areas
+- Company context and culture fit
+
+## 📋 Key Responsibilities & Requirements
+- Core responsibilities breakdown
+- Must-have vs nice-to-have skills
+- Technical requirements analysis
+
+## 💰 Compensation & Benefits
+- Salary analysis and market context
+- Benefits and perquisites
+
+## 🎯 Interview Preparation
+- Likely interview questions based on the role
+- Technical topics to review
+- Company-specific research areas
+- Questions to ask the interviewer
+
+## 🚀 Next Steps
+- Application strategy
+- Timeline expectations
+- Follow-up recommendations
+
+Format as clear, actionable markdown suitable for job seekers.
+"""
+            
+            draft_content = llm_client.call_llm(detailed_prompt)
+            
+            log_metric("draft_success", {
+                "role": context["role"],
+                "company": context["company"],
+                "content_length": len(draft_content)
+            })
+            
+            return {**data, "draft": draft_content}
+            
+        except Exception as e:
+            log_metric("draft_error", {"error": str(e)})
+            return {**data, "draft": f"Draft generation failed: {e}"} 

micro/enhanced_guide_renderer.py

@@ -0,0 +1,300 @@
+from typing import Any, Dict, List, Optional
+from metrics import log_metric
+
+class EnhancedGuideRenderer:
+    """Enhanced guide renderer for PersonalizedInterviewGuide data structure"""
+    
+    def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Render PersonalizedInterviewGuide to formatted markdown"""
+        
+        interview_guide = data.get("personalized_guide", {})
+        resume_data = data.get("resume_data_enhanced", {})
+        job_data = data.get("job_data_enhanced", {})
+        gap_analysis = data.get("gap_analysis_advanced", {})
+        
+        if not interview_guide or "error" in interview_guide:
+            return {**data, "rendered_guide": "# Interview Guide Generation Failed\n\nPlease try again with valid resume and job data."}
+        
+        try:
+            # Render comprehensive markdown guide
+            rendered_guide = self._render_personalized_guide(
+                interview_guide, job_data, gap_analysis
+            )
+            
+            log_metric("guide_render_success", {
+                "total_length": len(rendered_guide),
+                "sections_count": 12
+            })
+            
+            return {**data, "rendered_guide": rendered_guide}
+            
+        except Exception as e:
+            log_metric("guide_render_error", {"error": str(e)})
+            fallback = self._create_fallback_guide(interview_guide, job_data, gap_analysis)
+            return {**data, "rendered_guide": fallback}
+    
+    def _render_personalized_guide(self, guide: Dict[str, Any], job_data: Dict[str, Any], gap_analysis: Dict[str, Any]) -> str:
+        """Render complete personalized interview guide"""
+        
+        # Extract data with fallbacks
+        header = guide.get("header", {})
+        role = header.get("role", job_data.get("role", "Data Scientist"))
+        company = header.get("company", job_data.get("company", "Spotify"))
+        match_score = header.get("match_score", gap_analysis.get("overall_match_score", 0))
+        match_level = header.get("match_level", "Good Match")
+        match_emoji = header.get("match_emoji", "🟢")
+        
+        sections = []
+        
+        # Header with correct match score
+        sections.append(f"""# 🎯 Personalized Interview Guide: {role} at {company}
+
+**Match Score**: {match_emoji} {match_level} ({match_score:.1f}%)
+
+---""")
+        
+        # Executive Summary
+        executive_summary = guide.get("executive_summary", "")
+        if executive_summary:
+            sections.append(f"""## Introduction
+
+{executive_summary}""")
+        
+        # Skills Analysis
+        skills_analysis = guide.get("skills_analysis", {})
+        if skills_analysis:
+            sections.append(self._render_skills_analysis(skills_analysis, gap_analysis))
+        
+        # Interview Process
+        interview_process = guide.get("interview_process", {})
+        if interview_process:
+            sections.append(f"""## What Is the Interview Process Like at {company}?
+
+{interview_process.get('content', '')}
+
+**Why This Matters**: {interview_process.get('why_important', '')}
+
+**Action Items** ({interview_process.get('time_to_complete', '30 minutes')}):
+{self._format_action_items(interview_process.get('action_items', []))}""")
+        
+        # Technical Questions
+        technical_questions = guide.get("technical_questions", [])
+        if technical_questions:
+            sections.append(self._render_questions_section(
+                "🔧 Technical & Problem-Solving Questions",
+                technical_questions,
+                f"These questions test your technical knowledge for the {role} role. Focus on demonstrating both your understanding and problem-solving approach."
+            ))
+        
+        # Behavioral Questions  
+        behavioral_questions = guide.get("behavioral_questions", [])
+        if behavioral_questions:
+            sections.append(self._render_questions_section(
+                "🎯 Behavioral & Experience Questions", 
+                behavioral_questions,
+                "Use the STAR method (Situation, Task, Action, Result) to structure your responses. Draw from specific examples in your background."
+            ))
+        
+        # Company Questions
+        company_questions = guide.get("company_questions", [])
+        if company_questions:
+            sections.append(self._render_questions_section(
+                "🏢 Company & Culture Questions",
+                company_questions, 
+                f"These questions assess your interest in {company} and cultural fit. Research thoroughly and be genuine in your responses."
+            ))
+        
+        # Preparation Strategy
+        preparation_strategy = guide.get("preparation_strategy", {})
+        if preparation_strategy:
+            sections.append(f"""## 🎯 Preparation Strategy
+
+{preparation_strategy.get('content', '')}
+
+**Why This Matters**: {preparation_strategy.get('why_important', '')}
+
+**Action Items** ({preparation_strategy.get('time_to_complete', '2-3 hours')}):
+{self._format_action_items(preparation_strategy.get('action_items', []))}""")
+        
+        # Key Talking Points
+        talking_points = guide.get("talking_points", {})
+        if talking_points:
+            sections.append(f"""## 💬 Key Talking Points
+
+Highlight these specific achievements and experiences during your interview:
+
+{talking_points.get('content', '')}
+
+**Why This Matters**: {talking_points.get('why_important', '')}
+
+**Action Items** ({talking_points.get('time_to_complete', '1 hour')}):
+{self._format_action_items(talking_points.get('action_items', []))}""")
+        
+        # Smart Questions to Ask
+        questions_to_ask = guide.get("questions_to_ask", [])
+        if questions_to_ask:
+            sections.append(f"""## ❓ Smart Questions to Ask
+
+Show your engagement and strategic thinking with these questions:
+
+{self._format_questions_list(questions_to_ask)}""")
+        
+        # Day-of Preparation
+        day_of_preparation = guide.get("day_of_preparation", {})
+        if day_of_preparation:
+            sections.append(f"""## 📅 Day-of-Interview Preparation
+
+{day_of_preparation.get('content', '')}
+
+**Action Items** ({day_of_preparation.get('time_to_complete', '1 hour before')}):
+{self._format_action_items(day_of_preparation.get('action_items', []))}""")
+        
+        # Success Metrics
+        success_metrics = guide.get("success_metrics", [])
+        if success_metrics:
+            sections.append(f"""## ✅ Success Metrics
+
+You'll know the interview went well if:
+
+{self._format_success_metrics(success_metrics)}""")
+        
+        # Footer
+        sections.append(f"""## 🚀 Conclusion
+
+You're well-prepared for this {role} interview at {company}! Your {match_score:.1f}% match score indicates strong alignment with their requirements.
+
+**Remember**: 
+- Be authentic and confident
+- Ask thoughtful questions  
+- Show enthusiasm for {company}
+- Highlight your unique value proposition
+
+Good luck with your interview! 🚀
+
+---
+
+*This personalized guide was generated based on your specific background and the target role requirements.*""")
+        
+        return "\n\n".join(sections)
+    
+    def _render_skills_analysis(self, skills_analysis: Dict[str, Any], gap_analysis: Dict[str, Any]) -> str:
+        """Render skills analysis with proper data"""
+        
+        # Get data from gap_analysis as fallback
+        strong_matches = gap_analysis.get("strong_matches", [])
+        partial_matches = gap_analysis.get("partial_matches", [])
+        gaps = gap_analysis.get("gaps", [])
+        
+        # Create visual representation
+        strong_count = len(strong_matches)
+        partial_count = len(partial_matches)
+        gaps_count = len(gaps)
+        total = strong_count + partial_count + gaps_count
+        
+        if total > 0:
+            strong_bar = "█" * min(20, int((strong_count / total) * 20)) if strong_count > 0 else ""
+            partial_bar = "▒" * min(20, int((partial_count / total) * 20)) if partial_count > 0 else ""
+            gaps_bar = "░" * min(20, int((gaps_count / total) * 20)) if gaps_count > 0 else ""
+        else:
+            strong_bar = partial_bar = gaps_bar = ""
+        
+        # Get skill names
+        strong_names = [match.get("resume_skill", match.get("job_requirement", "")) for match in strong_matches[:5]]
+        partial_names = [match.get("resume_skill", match.get("job_requirement", "")) for match in partial_matches[:5]]
+        gap_names = [gap.get("job_requirement", "") for gap in gaps[:5]]
+        
+        return f"""## 📊 Skills Match Analysis
+
+**Overall Assessment**: {skills_analysis.get('summary', 'Strong technical background with relevant experience in data science and analytics.')}
+
+### Skills Breakdown
+```
+Strong Matches  {strong_bar} {strong_count}
+Partial Matches {partial_bar} {partial_count}  
+Skill Gaps      {gaps_bar} {gaps_count}
+```
+
+**✅ Your Strengths**: {', '.join(strong_names) if strong_names else 'Core technical skills identified'}
+
+{f"**⚡ Areas to Highlight**: {', '.join(partial_names)}" if partial_names else ""}
+
+{f"**📚 Priority Learning**: {', '.join(gap_names)}" if gap_names else ""}"""
+    
+    def _render_questions_section(self, title: str, questions: List[Dict], intro: str) -> str:
+        """Render questions with proper formatting"""
+        
+        section = f"""## {title}
+
+{intro}
+
+"""
+        
+        for i, q in enumerate(questions, 1):
+            question_text = q.get("question", "")
+            difficulty = q.get("difficulty", "medium")
+            why_asked = q.get("why_asked", "")
+            approach_strategy = q.get("approach_strategy", "")
+            example_points = q.get("example_points", [])
+            
+            # Difficulty indicator
+            if difficulty == "hard":
+                diff_icon = "🔴"
+            elif difficulty == "medium":
+                diff_icon = "🟡"
+            else:
+                diff_icon = "🟢"
+            
+            section += f"""### {diff_icon} Question {i}: {question_text}
+
+**Why they ask this**: {why_asked}
+
+**How to approach**: {approach_strategy}
+
+{f"**Key points to mention**: {', '.join(example_points[:3])}" if example_points else ""}
+
+---
+
+"""
+        
+        return section.rstrip()
+    
+    def _format_action_items(self, items: List[str]) -> str:
+        """Format action items as bullet list"""
+        return "\n".join([f"- {item}" for item in items]) if items else "- Review your background and prepare examples"
+    
+    def _format_questions_list(self, questions: List[str]) -> str:
+        """Format questions as numbered list"""
+        return "\n".join([f"{i}. {q}" for i, q in enumerate(questions, 1)]) if questions else "1. What excites you most about this role?"
+    
+    def _format_success_metrics(self, metrics: List[str]) -> str:
+        """Format success metrics as bullet list"""
+        return "\n".join([f"- {metric}" for metric in metrics]) if metrics else "- Strong rapport with interviewers\n- Technical discussions flow naturally\n- You feel confident about your responses"
+    
+    def _create_fallback_guide(self, guide: Dict[str, Any], job_data: Dict[str, Any], gap_analysis: Dict[str, Any]) -> str:
+        """Create fallback guide if rendering fails"""
+        
+        role = job_data.get("role", "Data Scientist")
+        company = job_data.get("company", "the company")
+        match_score = gap_analysis.get("overall_match_score", 0)
+        
+        return f"""# 🎯 Interview Guide: {role} at {company}
+
+**Match Score**: {match_score:.1f}%
+
+## Summary
+You have a strong background that aligns well with this {role} position. Focus your preparation on highlighting your relevant experience and technical skills.
+
+## Key Preparation Areas
+- Review your technical projects and be ready to discuss them in detail
+- Prepare specific examples using the STAR method
+- Research {company} and prepare thoughtful questions
+- Practice explaining complex concepts in simple terms
+
+## Technical Focus Areas
+Based on your background, be prepared to discuss:
+- Data analysis and visualization
+- Programming experience (Python, SQL, etc.)
+- Statistical methods and machine learning
+- Project outcomes and business impact
+
+Good luck with your interview! 🚀""" 

micro/enhanced_job_parser.py

@@ -0,0 +1,472 @@
+"""
+Enhanced Job Requirements Parser
+Extracts structured job requirements with experience levels, context, and priorities
+"""
+
+from typing import Any, Dict, List, Optional, Tuple
+import re
+from dataclasses import dataclass, asdict
+from llm_client import LLMClient
+from metrics import log_metric
+import json
+
+@dataclass
+class JobRequirement:
+    skill: str
+    category: str  # technical, experience, education, soft_skill, certification
+    importance: str  # required, preferred, nice_to_have
+    experience_level: str  # entry, mid, senior, expert
+    context: str  # Where this requirement was mentioned
+    synonyms: Optional[List[str]] = None
+    
+    def __post_init__(self):
+        if self.synonyms is None:
+            self.synonyms = []
+
+@dataclass
+class JobStructuredData:
+    role: str
+    company: str
+    location: str
+    seniority_level: str
+    tech_requirements: List[JobRequirement]
+    experience_requirements: List[JobRequirement]
+    education_requirements: List[JobRequirement]
+    soft_skill_requirements: List[JobRequirement]
+    responsibilities: List[str]
+    nice_to_haves: List[str]
+    years_experience_required: int
+    salary_range: Tuple[Optional[int], Optional[int]]
+    remote_type: str  # remote, hybrid, onsite
+    company_stage: str  # startup, scale-up, enterprise
+    
+    def __post_init__(self):
+        if not self.tech_requirements:
+            self.tech_requirements = []
+        if not self.experience_requirements:
+            self.experience_requirements = []
+        if not self.education_requirements:
+            self.education_requirements = []
+        if not self.soft_skill_requirements:
+            self.soft_skill_requirements = []
+        if not self.responsibilities:
+            self.responsibilities = []
+        if not self.nice_to_haves:
+            self.nice_to_haves = []
+
+class RequirementsNormalizer:
+    """Normalizes job requirements and identifies synonyms"""
+    
+    def __init__(self):
+        self.experience_indicators = {
+            "entry": ["entry", "junior", "0-2 years", "new grad", "graduate", "recent grad", "0+ years"],
+            "mid": ["mid", "intermediate", "2-5 years", "3-5 years", "2+ years", "3+ years"],
+            "senior": ["senior", "5+ years", "5-8 years", "experienced", "6+ years", "7+ years"],
+            "expert": ["expert", "lead", "principal", "8+ years", "10+ years", "architect"]
+        }
+        
+        self.importance_indicators = {
+            "required": ["required", "must have", "essential", "mandatory", "necessary"],
+            "preferred": ["preferred", "desired", "strong preference", "ideal"],
+            "nice_to_have": ["nice to have", "plus", "bonus", "would be great", "advantageous"]
+        }
+        
+        self.category_patterns = {
+            "technical": [
+                r"\b(python|javascript|java|react|angular|vue|django|flask|aws|azure|docker|kubernetes)\b",
+                r"\b(sql|nosql|postgresql|mongodb|redis|git|linux|api|rest|graphql)\b",
+                r"\b(machine learning|ml|ai|data science|tensorflow|pytorch|pandas|numpy)\b"
+            ],
+            "experience": [
+                r"\b(\d+)[\+\-\s]*years?\s+(of\s+)?experience\b",
+                r"\bexperience\s+with\b",
+                r"\bproficient\s+in\b",
+                r"\bworked\s+with\b"
+            ],
+            "education": [
+                r"\b(bachelor|master|phd|degree|bs|ms|ba|ma)\b",
+                r"\b(computer science|engineering|mathematics|statistics)\b"
+            ],
+            "soft_skill": [
+                r"\b(communication|leadership|teamwork|problem.solving|analytical)\b",
+                r"\b(collaboration|mentoring|presentation|writing)\b"
+            ]
+        }
+    
+    def extract_experience_level(self, text: str) -> str:
+        """Extract experience level from requirement text"""
+        text_lower = text.lower()
+        
+        for level, indicators in self.experience_indicators.items():
+            for indicator in indicators:
+                if indicator in text_lower:
+                    return level
+        
+        return "mid"  # Default
+    
+    def extract_importance(self, text: str, context: str = "") -> str:
+        """Extract importance level from requirement text"""
+        combined_text = (text + " " + context).lower()
+        
+        for importance, indicators in self.importance_indicators.items():
+            for indicator in indicators:
+                if indicator in combined_text:
+                    return importance
+        
+        return "required"  # Default
+    
+    def categorize_requirement(self, text: str) -> str:
+        """Categorize a requirement"""
+        text_lower = text.lower()
+        
+        for category, patterns in self.category_patterns.items():
+            for pattern in patterns:
+                if re.search(pattern, text_lower):
+                    return category
+        
+        return "technical"  # Default
+
+class EnhancedJobParser:
+    """Enhanced job parser that extracts structured requirements with context"""
+    
+    def __init__(self):
+        self.normalizer = RequirementsNormalizer()
+        self.llm_client = LLMClient()
+    
+    async def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        job_text = data.get("scraped", {}).get("content", "")
+        enriched_data = data.get("enriched", {})
+        
+        if not job_text and not enriched_data:
+            return {**data, "job_data_enhanced": {"error": "No job content available"}}
+        
+        try:
+            # Extract structured job requirements
+            job_data = await self._extract_job_requirements_structured(job_text, enriched_data)
+            
+            log_metric("job_parse_enhanced_success", {
+                "tech_requirements": len(job_data.tech_requirements),
+                "total_requirements": len(job_data.tech_requirements) + len(job_data.experience_requirements),
+                "years_required": job_data.years_experience_required
+            })
+            
+            return {**data, "job_data_enhanced": asdict(job_data)}
+            
+        except Exception as e:
+            log_metric("job_parse_enhanced_error", {"error": str(e)})
+            return {**data, "job_data_enhanced": {"error": f"Enhanced job parsing failed: {e}"}}
+    
+    async def _extract_job_requirements_structured(self, job_text: str, enriched_data: Dict[str, Any]) -> JobStructuredData:
+        """Extract structured job requirements using LLM and pattern matching"""
+        
+        # First try LLM extraction for detailed analysis
+        try:
+            llm_data = await self._llm_extract_requirements(job_text)
+            if llm_data:
+                return llm_data
+        except Exception as e:
+            log_metric("job_llm_extraction_error", {"error": str(e)})
+        
+        # Fallback to pattern-based extraction
+        return self._pattern_based_extraction(job_text, enriched_data)
+    
+    async def _llm_extract_requirements(self, job_text: str) -> Optional[JobStructuredData]:
+        """Use LLM to extract detailed job requirements"""
+        
+        prompt = f"""
+Analyze this job posting and extract structured requirements. Return ONLY valid JSON:
+
+{{
+  "role": "Job Title",
+  "company": "Company Name", 
+  "location": "City, State",
+  "seniority_level": "entry|mid|senior|lead",
+  "years_experience_required": 5,
+  "salary_range": [100000, 150000],
+  "remote_type": "remote|hybrid|onsite",
+  "company_stage": "startup|scale-up|enterprise",
+  "tech_requirements": [
+    {{
+      "skill": "Python",
+      "category": "technical",
+      "importance": "required|preferred|nice_to_have", 
+      "experience_level": "entry|mid|senior|expert",
+      "context": "Where this was mentioned in the posting",
+      "synonyms": ["Python3", "py"]
+    }}
+  ],
+  "experience_requirements": [
+    {{
+      "skill": "Web development experience",
+      "category": "experience",
+      "importance": "required",
+      "experience_level": "mid",
+      "context": "Must have 3+ years building web applications",
+      "synonyms": ["full-stack development", "web dev"]
+    }}
+  ],
+  "education_requirements": [
+    {{
+      "skill": "Bachelor's degree",
+      "category": "education", 
+      "importance": "preferred",
+      "experience_level": "entry",
+      "context": "BS in Computer Science or equivalent",
+      "synonyms": ["BS", "undergraduate degree"]
+    }}
+  ],
+  "soft_skill_requirements": [
+    {{
+      "skill": "Communication",
+      "category": "soft_skill",
+      "importance": "required", 
+      "experience_level": "mid",
+      "context": "Strong written and verbal communication",
+      "synonyms": ["written communication", "verbal skills"]
+    }}
+  ],
+  "responsibilities": [
+    "Design and develop web applications",
+    "Collaborate with cross-functional teams"
+  ],
+  "nice_to_haves": [
+    "Experience with cloud platforms",
+    "Open source contributions"
+  ]
+}}
+
+Guidelines:
+1. Extract ALL technical skills, tools, frameworks, languages mentioned
+2. Identify experience level indicators (junior, senior, X+ years)
+3. Categorize by importance (required vs preferred vs nice-to-have)
+4. Include context of where each requirement was mentioned
+5. Add synonyms for technologies (React/ReactJS, ML/Machine Learning)
+6. Parse salary ranges and years of experience
+7. Determine company stage from description
+8. Identify remote work policy
+
+Job posting:
+{job_text}
+"""
+        
+        try:
+            response = self.llm_client.call_llm(prompt, temperature=0, max_tokens=4000)
+            
+            # Clean response to extract JSON
+            json_start = response.find('{')
+            json_end = response.rfind('}') + 1
+            if json_start != -1 and json_end > json_start:
+                json_str = response[json_start:json_end]
+            else:
+                json_str = response
+            
+            data = json.loads(json_str)
+            
+            # Convert to structured objects
+            return self._convert_to_job_data(data)
+            
+        except json.JSONDecodeError as e:
+            log_metric("job_json_parse_error", {"error": str(e), "response": response[:500]})
+            return None
+        except Exception as e:
+            log_metric("job_llm_error", {"error": str(e)})
+            return None
+    
+    def _pattern_based_extraction(self, job_text: str, enriched_data: Dict[str, Any]) -> JobStructuredData:
+        """Fallback pattern-based extraction"""
+        
+        # Extract basic info from enriched data
+        role = enriched_data.get("role", "Unknown Role")
+        company = enriched_data.get("company", "Unknown Company")
+        location = enriched_data.get("location", "")
+        
+        # Extract years of experience
+        years_exp = self._extract_years_experience(job_text)
+        
+        # Extract technical requirements using patterns
+        tech_requirements = self._extract_technical_requirements_pattern(job_text)
+        
+        # Extract salary range
+        salary_range = self._extract_salary_range(job_text)
+        
+        return JobStructuredData(
+            role=role,
+            company=company,
+            location=location,
+            seniority_level=self._determine_seniority(job_text, years_exp),
+            tech_requirements=tech_requirements,
+            experience_requirements=[],
+            education_requirements=[],
+            soft_skill_requirements=[],
+            responsibilities=[],
+            nice_to_haves=[],
+            years_experience_required=years_exp,
+            salary_range=salary_range,
+            remote_type=self._extract_remote_type(job_text),
+            company_stage=self._determine_company_stage(job_text)
+        )
+    
+    def _convert_to_job_data(self, data: Dict[str, Any]) -> JobStructuredData:
+        """Convert parsed JSON to JobStructuredData objects"""
+        
+        # Convert requirement lists
+        tech_reqs = []
+        for req_data in data.get("tech_requirements", []):
+            tech_reqs.append(JobRequirement(**req_data))
+        
+        exp_reqs = []
+        for req_data in data.get("experience_requirements", []):
+            exp_reqs.append(JobRequirement(**req_data))
+        
+        edu_reqs = []
+        for req_data in data.get("education_requirements", []):
+            edu_reqs.append(JobRequirement(**req_data))
+        
+        soft_reqs = []
+        for req_data in data.get("soft_skill_requirements", []):
+            soft_reqs.append(JobRequirement(**req_data))
+        
+        # Handle salary range
+        salary_data = data.get("salary_range", [None, None])
+        if isinstance(salary_data, list) and len(salary_data) >= 2:
+            salary_range = (salary_data[0], salary_data[1])
+        else:
+            salary_range = (None, None)
+        
+        return JobStructuredData(
+            role=data.get("role", "Unknown Role"),
+            company=data.get("company", "Unknown Company"),
+            location=data.get("location", ""),
+            seniority_level=data.get("seniority_level", "mid"),
+            tech_requirements=tech_reqs,
+            experience_requirements=exp_reqs,
+            education_requirements=edu_reqs,
+            soft_skill_requirements=soft_reqs,
+            responsibilities=data.get("responsibilities", []),
+            nice_to_haves=data.get("nice_to_haves", []),
+            years_experience_required=data.get("years_experience_required", 0),
+            salary_range=salary_range,
+            remote_type=data.get("remote_type", "onsite"),
+            company_stage=data.get("company_stage", "enterprise")
+        )
+    
+    def _extract_years_experience(self, text: str) -> int:
+        """Extract years of experience required"""
+        
+        # Pattern for X+ years
+        pattern = r'(\d+)\+?\s*years?\s+(?:of\s+)?experience'
+        matches = re.findall(pattern, text.lower())
+        
+        if matches:
+            return int(matches[0])
+        
+        # Check for seniority indicators
+        if any(word in text.lower() for word in ['senior', 'lead', 'principal']):
+            return 5
+        elif any(word in text.lower() for word in ['junior', 'entry', 'graduate']):
+            return 0
+        
+        return 2  # Default
+    
+    def _extract_technical_requirements_pattern(self, text: str) -> List[JobRequirement]:
+        """Extract technical requirements using pattern matching"""
+        
+        # Common tech patterns
+        tech_patterns = [
+            r'\b(Python|JavaScript|Java|C\+\+|C#|Ruby|Go|Rust|Swift|Kotlin)\b',
+            r'\b(React|Angular|Vue|Django|Flask|Spring|Rails|Laravel)\b',
+            r'\b(AWS|Azure|GCP|Docker|Kubernetes|Git|SQL|NoSQL)\b',
+            r'\b(Machine Learning|ML|AI|Deep Learning|TensorFlow|PyTorch)\b',
+            r'\b(PostgreSQL|MongoDB|Redis|MySQL|Elasticsearch)\b'
+        ]
+        
+        requirements = []
+        
+        for pattern in tech_patterns:
+            matches = re.findall(pattern, text, re.IGNORECASE)
+            for match in matches:
+                # Determine importance and experience level from context
+                context_start = max(0, text.lower().find(match.lower()) - 50)
+                context_end = min(len(text), text.lower().find(match.lower()) + len(match) + 50)
+                context = text[context_start:context_end]
+                
+                importance = self.normalizer.extract_importance(match, context)
+                experience_level = self.normalizer.extract_experience_level(context)
+                
+                req = JobRequirement(
+                    skill=match,
+                    category="technical",
+                    importance=importance,
+                    experience_level=experience_level,
+                    context=context.strip(),
+                    synonyms=[]
+                )
+                requirements.append(req)
+        
+        return requirements
+    
+    def _extract_salary_range(self, text: str) -> Tuple[Optional[int], Optional[int]]:
+        """Extract salary range from text"""
+        
+        # Pattern for salary ranges
+        patterns = [
+            r'\$(\d+)k?\s*-\s*\$?(\d+)k?',
+            r'\$(\d+),?(\d+)?\s*-\s*\$?(\d+),?(\d+)?',
+            r'(\d+)k?\s*-\s*(\d+)k?\s*(?:per\s+year|annually|\$)'
+        ]
+        
+        for pattern in patterns:
+            matches = re.findall(pattern, text, re.IGNORECASE)
+            if matches:
+                match = matches[0]
+                try:
+                    if len(match) >= 2:
+                        low = int(match[0]) * 1000 if 'k' in text.lower() else int(match[0])
+                        high = int(match[1]) * 1000 if 'k' in text.lower() else int(match[1])
+                        return (low, high)
+                except:
+                    continue
+        
+        return (None, None)
+    
+    def _determine_seniority(self, text: str, years_exp: int) -> str:
+        """Determine seniority level"""
+        
+        text_lower = text.lower()
+        
+        if any(word in text_lower for word in ['senior', 'sr.', 'lead', 'principal']):
+            return "senior"
+        elif any(word in text_lower for word in ['junior', 'jr.', 'entry', 'graduate']):
+            return "entry"
+        elif years_exp >= 5:
+            return "senior"
+        elif years_exp <= 1:
+            return "entry"
+        else:
+            return "mid"
+    
+    def _extract_remote_type(self, text: str) -> str:
+        """Extract remote work type"""
+        
+        text_lower = text.lower()
+        
+        if any(word in text_lower for word in ['remote', 'work from home', 'distributed']):
+            return "remote"
+        elif any(word in text_lower for word in ['hybrid', 'flexible', 'part remote']):
+            return "hybrid"
+        else:
+            return "onsite"
+    
+    def _determine_company_stage(self, text: str) -> str:
+        """Determine company stage"""
+        
+        text_lower = text.lower()
+        
+        if any(word in text_lower for word in ['startup', 'early stage', 'seed', 'series a']):
+            return "startup"
+        elif any(word in text_lower for word in ['scale up', 'series b', 'series c', 'growth']):
+            return "scale-up"
+        elif any(word in text_lower for word in ['fortune', 'enterprise', 'established', 'public company']):
+            return "enterprise"
+        else:
+            return "enterprise"  # Default 

micro/enhanced_resume_parser.py

@@ -0,0 +1,630 @@
+"""
+Enhanced Resume Parser v2.0
+Provides structured extraction of skills, experience, projects, and education
+with proper normalization and context understanding.
+"""
+
+from typing import Any, Dict, List, Optional
+import re
+import json
+from dataclasses import dataclass, asdict, field
+from llm_client import LLMClient
+from metrics import log_metric
+import tiktoken
+
+@dataclass
+class Experience:
+    title: str
+    company: str
+    duration: str
+    location: str = ""
+    responsibilities: List[str] = field(default_factory=list)
+    achievements: List[str] = field(default_factory=list)
+    technologies: List[str] = field(default_factory=list)
+    start_date: str = ""
+    end_date: str = ""
+    is_current: bool = False
+    
+    def __post_init__(self):
+        if self.responsibilities is None:
+            self.responsibilities = []
+        if self.achievements is None:
+            self.achievements = []
+        if self.technologies is None:
+            self.technologies = []
+
+@dataclass
+class Project:
+    name: str
+    description: str
+    technologies: List[str] = field(default_factory=list)
+    github_url: str = ""
+    demo_url: str = ""
+    duration: str = ""
+    key_features: List[str] = field(default_factory=list)
+    
+    def __post_init__(self):
+        if self.technologies is None:
+            self.technologies = []
+        if self.key_features is None:
+            self.key_features = []
+
+@dataclass
+class Education:
+    degree: str
+    field: str
+    school: str
+    graduation_year: str = ""
+    gpa: str = ""
+    relevant_courses: List[str] = None
+    honors: List[str] = None
+    
+    def __post_init__(self):
+        if self.relevant_courses is None:
+            self.relevant_courses = []
+        if self.honors is None:
+            self.honors = []
+
+@dataclass
+class Skills:
+    technical: List[str] = None
+    programming_languages: List[str] = None
+    frameworks: List[str] = None
+    tools: List[str] = None
+    databases: List[str] = None
+    cloud_platforms: List[str] = None
+    methodologies: List[str] = None
+    soft_skills: List[str] = None
+    
+    def __post_init__(self):
+        for field in ['technical', 'programming_languages', 'frameworks', 'tools', 
+                      'databases', 'cloud_platforms', 'methodologies', 'soft_skills']:
+            if getattr(self, field) is None:
+                setattr(self, field, [])
+
+@dataclass
+class ResumeData:
+    personal_info: Dict[str, str]
+    summary: str
+    skills: Skills
+    experience: List[Experience]
+    education: List[Education]
+    projects: List[Project]
+    certifications: List[Dict[str, str]]
+    languages: List[str]
+    years_of_experience: int = 0
+    
+    def __post_init__(self):
+        if not self.certifications:
+            self.certifications = []
+        if not self.languages:
+            self.languages = []
+
+class SkillsNormalizer:
+    """Normalizes and categorizes skills with synonym detection"""
+    
+    def __init__(self):
+        self.skill_synonyms = {
+            # Programming Languages
+            "python": ["python", "python3", "python 3", "py"],
+            "javascript": ["javascript", "js", "node.js", "nodejs", "node js"],
+            "typescript": ["typescript", "ts"],
+            "java": ["java", "java 8", "java 11", "java 17"],
+            "csharp": ["c#", "csharp", "c sharp", ".net", "dotnet"],
+            "cpp": ["c++", "cpp", "c plus plus"],
+            "go": ["go", "golang"],
+            "rust": ["rust", "rust-lang"],
+            "swift": ["swift", "ios development"],
+            "kotlin": ["kotlin", "android development"],
+            "r": ["r", "r programming"],
+            "scala": ["scala"],
+            "php": ["php", "php 7", "php 8"],
+            "ruby": ["ruby", "ruby on rails", "ror"],
+            
+            # Web Frameworks
+            "react": ["react", "reactjs", "react.js", "react js"],
+            "angular": ["angular", "angularjs", "angular 2+"],
+            "vue": ["vue", "vue.js", "vuejs", "vue js"],
+            "svelte": ["svelte", "sveltekit"],
+            "django": ["django", "django rest framework", "drf"],
+            "flask": ["flask", "flask-restful"],
+            "fastapi": ["fastapi", "fast api"],
+            "express": ["express", "express.js", "expressjs"],
+            "spring": ["spring", "spring boot", "spring framework"],
+            "laravel": ["laravel"],
+            "rails": ["rails", "ruby on rails", "ror"],
+            
+            # Databases
+            "postgresql": ["postgresql", "postgres", "pg", "psql"],
+            "mysql": ["mysql", "my sql"],
+            "mongodb": ["mongodb", "mongo", "mongo db"],
+            "redis": ["redis"],
+            "elasticsearch": ["elasticsearch", "elastic search"],
+            "cassandra": ["cassandra", "apache cassandra"],
+            "dynamodb": ["dynamodb", "dynamo db"],
+            "sqlite": ["sqlite", "sqlite3"],
+            
+            # Cloud Platforms
+            "aws": ["aws", "amazon web services", "amazon aws"],
+            "azure": ["azure", "microsoft azure"],
+            "gcp": ["gcp", "google cloud", "google cloud platform"],
+            "heroku": ["heroku"],
+            "digitalocean": ["digitalocean", "digital ocean"],
+            "vercel": ["vercel"],
+            "netlify": ["netlify"],
+            
+            # DevOps & Tools
+            "docker": ["docker", "containerization", "containers"],
+            "kubernetes": ["kubernetes", "k8s", "container orchestration"],
+            "jenkins": ["jenkins", "ci/cd"],
+            "github actions": ["github actions", "gh actions"],
+            "terraform": ["terraform", "infrastructure as code", "iac"],
+            "ansible": ["ansible"],
+            "git": ["git", "version control", "source control"],
+            "linux": ["linux", "unix", "ubuntu", "centos"],
+            
+            # Data Science & ML
+            "machine learning": ["machine learning", "ml", "artificial intelligence", "ai"],
+            "deep learning": ["deep learning", "neural networks"],
+            "tensorflow": ["tensorflow", "tf"],
+            "pytorch": ["pytorch", "torch"],
+            "scikit-learn": ["scikit-learn", "sklearn", "scikit learn"],
+            "pandas": ["pandas", "data manipulation"],
+            "numpy": ["numpy", "numerical computing"],
+            "matplotlib": ["matplotlib", "data visualization"],
+            "seaborn": ["seaborn"],
+            "jupyter": ["jupyter", "jupyter notebooks"],
+            
+            # Testing
+            "pytest": ["pytest", "python testing"],
+            "jest": ["jest", "javascript testing"],
+            "selenium": ["selenium", "web automation"],
+            "cypress": ["cypress", "e2e testing"],
+            
+            # Methodologies
+            "agile": ["agile", "scrum", "kanban"],
+            "devops": ["devops", "dev ops"],
+            "microservices": ["microservices", "micro services"],
+            "rest api": ["rest", "rest api", "restful", "api development"],
+            "graphql": ["graphql", "graph ql"],
+        }
+        
+        self.skill_categories = {
+            "programming_languages": ["python", "javascript", "typescript", "java", "csharp", "cpp", "go", "rust", "swift", "kotlin", "r", "scala", "php", "ruby"],
+            "frameworks": ["react", "angular", "vue", "svelte", "django", "flask", "fastapi", "express", "spring", "laravel", "rails"],
+            "databases": ["postgresql", "mysql", "mongodb", "redis", "elasticsearch", "cassandra", "dynamodb", "sqlite"],
+            "cloud_platforms": ["aws", "azure", "gcp", "heroku", "digitalocean", "vercel", "netlify"],
+            "tools": ["docker", "kubernetes", "jenkins", "github actions", "terraform", "ansible", "git", "linux", "pytest", "jest", "selenium", "cypress"],
+            "methodologies": ["agile", "devops", "microservices", "rest api", "graphql"]
+        }
+    
+    def normalize_skill(self, skill: str) -> Optional[str]:
+        """Normalize a skill to its canonical form"""
+        skill_lower = skill.lower().strip()
+        
+        for canonical, synonyms in self.skill_synonyms.items():
+            if skill_lower in synonyms:
+                return canonical
+        
+        return skill_lower if len(skill_lower) > 1 else None
+    
+    def categorize_skill(self, normalized_skill: str) -> str:
+        """Categorize a normalized skill"""
+        for category, skills in self.skill_categories.items():
+            if normalized_skill in skills:
+                return category
+        return "technical"
+    
+    def normalize_skill_list(self, skills: List[str]) -> Dict[str, List[str]]:
+        """Normalize and categorize a list of skills"""
+        categorized = {
+            "programming_languages": [],
+            "frameworks": [],
+            "databases": [],
+            "cloud_platforms": [],
+            "tools": [],
+            "methodologies": [],
+            "technical": []
+        }
+        
+        for skill in skills:
+            normalized = self.normalize_skill(skill)
+            if normalized:
+                category = self.categorize_skill(normalized)
+                if normalized not in categorized[category]:
+                    categorized[category].append(normalized)
+        
+        return categorized
+
+class EnhancedResumeParser:
+    """Enhanced resume parser with structured extraction and normalization"""
+    
+    def __init__(self):
+        self.skills_normalizer = SkillsNormalizer()
+        self.llm_client = LLMClient()
+    
+    async def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        resume_text = data.get("resume_text", "")
+        
+        if not resume_text:
+            return {**data, "resume_data_enhanced": {"error": "No resume content provided"}}
+        
+        try:
+            # Extract structured resume data
+            resume_data = await self._extract_resume_data_structured(resume_text)
+            
+            log_metric("resume_parse_enhanced_success", {
+                "skills_count": len(self._get_all_skills(resume_data.skills)),
+                "experience_count": len(resume_data.experience),
+                "projects_count": len(resume_data.projects),
+                "years_experience": resume_data.years_of_experience
+            })
+            
+            return {**data, "resume_data_enhanced": asdict(resume_data)}
+            
+        except Exception as e:
+            log_metric("resume_parse_enhanced_error", {"error": str(e)})
+            return {**data, "resume_data_enhanced": {"error": f"Enhanced resume parsing failed: {e}"}}
+    
+    async def _extract_resume_data_structured(self, resume_text: str) -> ResumeData:
+        """Extract structured resume data using multiple approaches"""
+        
+        # First, try comprehensive LLM extraction
+        try:
+            structured_data = await self._llm_extract_structured(resume_text)
+            if structured_data:
+                return structured_data
+        except Exception as e:
+            log_metric("resume_llm_extraction_error", {"error": str(e)})
+        
+        # Fallback to section-based extraction
+        return await self._section_based_extraction(resume_text)
+    
+    async def _llm_extract_structured(self, resume_text: str) -> Optional[ResumeData]:
+        """Use LLM to extract structured resume data"""
+        
+        # Check token count and chunk if necessary
+        token_count = self._count_tokens(resume_text)
+        if token_count > 15000:
+            # For very long resumes, extract in sections
+            return await self._chunked_extraction(resume_text)
+        
+        prompt = f"""
+Extract comprehensive structured data from this resume. Return ONLY valid JSON with this exact structure:
+
+{{
+  "personal_info": {{
+    "name": "Full Name",
+    "email": "email@domain.com",
+    "phone": "+1234567890",
+    "location": "City, State",
+    "linkedin": "linkedin.com/in/username",
+    "github": "github.com/username",
+    "website": "personal-website.com"
+  }},
+  "summary": "Professional summary or objective statement",
+  "skills": {{
+    "technical": ["skill1", "skill2"],
+    "programming_languages": ["Python", "JavaScript"],
+    "frameworks": ["React", "Django"],
+    "tools": ["Git", "Docker"],
+    "databases": ["PostgreSQL", "MongoDB"],
+    "cloud_platforms": ["AWS", "Azure"],
+    "methodologies": ["Agile", "DevOps"],
+    "soft_skills": ["Leadership", "Communication"]
+  }},
+  "experience": [
+    {{
+      "title": "Job Title",
+      "company": "Company Name",
+      "duration": "Jan 2020 - Present",
+      "location": "City, State",
+      "start_date": "2020-01",
+      "end_date": "Present",
+      "is_current": true,
+      "responsibilities": ["responsibility 1", "responsibility 2"],
+      "achievements": ["achievement 1", "achievement 2"],
+      "technologies": ["tech1", "tech2"]
+    }}
+  ],
+  "education": [
+    {{
+      "degree": "Bachelor of Science",
+      "field": "Computer Science",
+      "school": "University Name",
+      "graduation_year": "2020",
+      "gpa": "3.8",
+      "relevant_courses": ["Data Structures", "Algorithms"],
+      "honors": ["Dean's List", "Magna Cum Laude"]
+    }}
+  ],
+  "projects": [
+    {{
+      "name": "Project Name",
+      "description": "Brief description of the project",
+      "technologies": ["tech1", "tech2"],
+      "github_url": "github.com/user/repo",
+      "demo_url": "live-demo-url.com",
+      "duration": "3 months",
+      "key_features": ["feature1", "feature2"]
+    }}
+  ],
+  "certifications": [
+    {{
+      "name": "Certification Name",
+      "issuer": "Organization",
+      "date": "2023",
+      "credential_id": "123456"
+    }}
+  ],
+  "languages": ["English (Native)", "Spanish (Conversational)"],
+  "years_of_experience": 5
+}}
+
+Important guidelines:
+1. Extract ALL skills mentioned, including those in job descriptions and projects
+2. Normalize technology names (e.g., "React.js" → "React", "ML" → "Machine Learning")
+3. Calculate years_of_experience from work history
+4. Parse dates in YYYY-MM format when possible
+5. Group similar skills appropriately
+6. Extract quantifiable achievements when possible
+7. If information is missing, omit the field or use empty array/string
+
+Resume text:
+{resume_text}
+"""
+        
+        try:
+            response = self.llm_client.call_llm(prompt, temperature=0, max_tokens=4000)
+            
+            # Clean response to extract just JSON
+            json_start = response.find('{')
+            json_end = response.rfind('}') + 1
+            if json_start != -1 and json_end > json_start:
+                json_str = response[json_start:json_end]
+            else:
+                json_str = response
+            
+            data = json.loads(json_str)
+            
+            # Convert to structured objects
+            return self._convert_to_resume_data(data)
+            
+        except json.JSONDecodeError as e:
+            log_metric("resume_json_parse_error", {"error": str(e), "response": response[:500]})
+            return None
+        except Exception as e:
+            log_metric("resume_llm_error", {"error": str(e)})
+            return None
+    
+    async def _chunked_extraction(self, resume_text: str) -> ResumeData:
+        """Extract data from long resumes by processing in chunks"""
+        
+        sections = self._split_resume_sections(resume_text)
+        
+        # Extract each section separately
+        personal_info = await self._extract_personal_info(sections.get("header", ""))
+        summary = await self._extract_summary(sections.get("summary", ""))
+        skills = await self._extract_skills(sections.get("skills", ""))
+        experience = await self._extract_experience(sections.get("experience", ""))
+        education = await self._extract_education(sections.get("education", ""))
+        projects = await self._extract_projects(sections.get("projects", ""))
+        certifications = await self._extract_certifications(sections.get("certifications", ""))
+        
+        # Calculate years of experience
+        years_exp = self._calculate_years_experience(experience)
+        
+        return ResumeData(
+            personal_info=personal_info,
+            summary=summary,
+            skills=skills,
+            experience=experience,
+            education=education,
+            projects=projects,
+            certifications=certifications,
+            languages=[],
+            years_of_experience=years_exp
+        )
+    
+    async def _section_based_extraction(self, resume_text: str) -> ResumeData:
+        """Fallback extraction using regex and basic parsing"""
+        
+        # Basic regex-based extraction
+        personal_info = self._extract_personal_info_regex(resume_text)
+        skills = self._extract_skills_regex(resume_text)
+        
+        return ResumeData(
+            personal_info=personal_info,
+            summary="",
+            skills=skills,
+            experience=[],
+            education=[],
+            projects=[],
+            certifications=[],
+            languages=[],
+            years_of_experience=0
+        )
+    
+    def _convert_to_resume_data(self, data: Dict[str, Any]) -> ResumeData:
+        """Convert parsed JSON to ResumeData objects"""
+        
+        # Parse skills with normalization
+        skills_data = data.get("skills", {})
+        all_skills = []
+        for skill_list in skills_data.values():
+            if isinstance(skill_list, list):
+                all_skills.extend(skill_list)
+        
+        normalized_skills = self.skills_normalizer.normalize_skill_list(all_skills)
+        skills = Skills(**normalized_skills)
+        
+        # Parse experience
+        experience = []
+        for exp_data in data.get("experience", []):
+            exp = Experience(**exp_data)
+            experience.append(exp)
+        
+        # Parse education
+        education = []
+        for edu_data in data.get("education", []):
+            edu = Education(**edu_data)
+            education.append(edu)
+        
+        # Parse projects
+        projects = []
+        for proj_data in data.get("projects", []):
+            proj = Project(**proj_data)
+            projects.append(proj)
+        
+        return ResumeData(
+            personal_info=data.get("personal_info", {}),
+            summary=data.get("summary", ""),
+            skills=skills,
+            experience=experience,
+            education=education,
+            projects=projects,
+            certifications=data.get("certifications", []),
+            languages=data.get("languages", []),
+            years_of_experience=data.get("years_of_experience", 0)
+        )
+    
+    def _get_all_skills(self, skills: Skills) -> List[str]:
+        """Get all skills as a flat list"""
+        all_skills = []
+        for field in ['technical', 'programming_languages', 'frameworks', 'tools', 
+                      'databases', 'cloud_platforms', 'methodologies']:
+            all_skills.extend(getattr(skills, field, []))
+        return all_skills
+    
+    def _split_resume_sections(self, resume_text: str) -> Dict[str, str]:
+        """Split resume into sections using common headers"""
+        
+        sections = {}
+        current_section = "header"
+        current_content = []
+        
+        # Common section headers
+        section_patterns = {
+            r'(experience|work experience|employment|professional experience)': 'experience',
+            r'(education|academic background)': 'education',
+            r'(skills|technical skills|core competencies)': 'skills',
+            r'(projects|personal projects|side projects)': 'projects',
+            r'(summary|objective|profile)': 'summary',
+            r'(certifications|licenses)': 'certifications'
+        }
+        
+        lines = resume_text.split('\n')
+        
+        for line in lines:
+            line_lower = line.lower().strip()
+            
+            # Check if this line is a section header
+            section_found = False
+            for pattern, section_name in section_patterns.items():
+                if re.search(pattern, line_lower):
+                    # Save previous section
+                    if current_content:
+                        sections[current_section] = '\n'.join(current_content)
+                    
+                    current_section = section_name
+                    current_content = []
+                    section_found = True
+                    break
+            
+            if not section_found:
+                current_content.append(line)
+        
+        # Save final section
+        if current_content:
+            sections[current_section] = '\n'.join(current_content)
+        
+        return sections
+    
+    def _extract_personal_info_regex(self, text: str) -> Dict[str, str]:
+        """Extract personal information using regex"""
+        
+        # Email
+        email_match = re.search(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', text)
+        email = email_match.group() if email_match else ""
+        
+        # Phone
+        phone_match = re.search(r'(\+?1[-.\s]?)?\(?([0-9]{3})\)?[-.\s]?([0-9]{3})[-.\s]?([0-9]{4})', text)
+        phone = phone_match.group() if phone_match else ""
+        
+        # LinkedIn
+        linkedin_match = re.search(r'linkedin\.com/in/[\w-]+', text, re.IGNORECASE)
+        linkedin = f"https://{linkedin_match.group()}" if linkedin_match else ""
+        
+        # GitHub
+        github_match = re.search(r'github\.com/[\w-]+', text, re.IGNORECASE)
+        github = f"https://{github_match.group()}" if github_match else ""
+        
+        return {
+            "email": email,
+            "phone": phone,
+            "linkedin": linkedin,
+            "github": github
+        }
+    
+    def _extract_skills_regex(self, text: str) -> Skills:
+        """Extract skills using regex patterns"""
+        
+        # Common technical skills to look for
+        tech_keywords = [
+            'Python', 'JavaScript', 'Java', 'C++', 'React', 'Node.js', 'SQL', 
+            'AWS', 'Docker', 'Git', 'Machine Learning', 'Data Science',
+            'TensorFlow', 'PyTorch', 'Pandas', 'NumPy', 'Django', 'Flask',
+            'PostgreSQL', 'MongoDB', 'Redis', 'Kubernetes', 'Jenkins'
+        ]
+        
+        found_skills = []
+        for skill in tech_keywords:
+            if re.search(rf'\b{re.escape(skill)}\b', text, re.IGNORECASE):
+                found_skills.append(skill)
+        
+        # Normalize skills
+        normalized = self.skills_normalizer.normalize_skill_list(found_skills)
+        
+        return Skills(**normalized)
+    
+    def _calculate_years_experience(self, experience: List[Experience]) -> int:
+        """Calculate total years of experience"""
+        if not experience:
+            return 0
+        
+        # Simple calculation based on number of roles
+        # In practice, you'd want to parse dates and calculate overlap
+        return len(experience)
+    
+    def _count_tokens(self, text: str) -> int:
+        """Count tokens in text"""
+        try:
+            encoding = tiktoken.encoding_for_model("gpt-4o-mini")
+            return len(encoding.encode(text))
+        except:
+            # Fallback: approximate as 4 chars per token
+            return len(text) // 4
+    
+    # Placeholder methods for individual section extraction
+    # These would be implemented with specific LLM calls for each section
+    
+    async def _extract_personal_info(self, text: str) -> Dict[str, str]:
+        return self._extract_personal_info_regex(text)
+    
+    async def _extract_summary(self, text: str) -> str:
+        return text.strip()
+    
+    async def _extract_skills(self, text: str) -> Skills:
+        return self._extract_skills_regex(text)
+    
+    async def _extract_experience(self, text: str) -> List[Experience]:
+        return []
+    
+    async def _extract_education(self, text: str) -> List[Education]:
+        return []
+    
+    async def _extract_projects(self, text: str) -> List[Project]:
+        return []
+    
+    async def _extract_certifications(self, text: str) -> List[Dict[str, str]]:
+        return [] 

micro/enrich.py

@@ -0,0 +1,205 @@
+import json
+from typing import Any, Dict
+from llm_client import llm_client
+from prompt_loader import prompt_loader
+from metrics import log_metric
+
+class EnrichMicroFunction:
+    def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        scraped_text = data.get("scraped_text", "")
+        
+        if not scraped_text or scraped_text == "No content found":
+            return {**data, "enriched": {"role": "", "company": "", "level": "", "error": "No content to enrich"}}
+        
+        try:
+            # Pre-process to extract obvious info
+            company = self._extract_company(scraped_text, data.get("raw_input", ""))
+            role = self._extract_role(scraped_text, data.get("raw_input", ""))
+            
+            # Use LLM to extract structured data
+            enrichment_prompt = prompt_loader.get_prompt("enrich_prompt", 
+                                                       job_posting=scraped_text,
+                                                       pre_company=company,
+                                                       pre_role=role)
+            
+            llm_response = llm_client.call_llm(enrichment_prompt)
+            
+            # Parse JSON response
+            try:
+                enriched_data = json.loads(llm_response)
+                
+                # Override with pre-extracted data if LLM missed it
+                if enriched_data.get("company") in ["Unknown", "", None] and company:
+                    enriched_data["company"] = company
+                if enriched_data.get("role") in ["Unknown", "", None] and role:
+                    enriched_data["role"] = role
+                    
+            except json.JSONDecodeError:
+                # Fallback: use pre-extracted data and simple LLM call
+                simple_prompt = f"""Extract job information from this text and respond with just the key details:
+
+Job posting: {scraped_text[:1500]}
+
+What is the job title, company, and seniority level?"""
+                
+                simple_response = llm_client.call_llm(simple_prompt)
+                
+                enriched_data = {
+                    "role": role or "Unknown",
+                    "company": company or "Unknown", 
+                    "level": self._extract_level(scraped_text, simple_response),
+                    "location": "Unknown",
+                    "requirements": [],
+                    "responsibilities": [],
+                    "parsed_response": simple_response
+                }
+            
+            log_metric("enrich_success", {
+                "has_role": bool(enriched_data.get("role")),
+                "has_company": bool(enriched_data.get("company")),
+                "has_requirements": bool(enriched_data.get("requirements"))
+            })
+            
+            return {**data, "enriched": enriched_data}
+            
+        except Exception as e:
+            log_metric("enrich_error", {"error": str(e)})
+            return {**data, "enriched": {"error": f"Enrichment failed: {e}"}}
+    
+    def _extract_company(self, scraped_text: str, raw_input: str) -> str:
+        """Extract company name from text or URL"""
+        import re
+        
+        # Check URL for company indicators (expanded list)
+        url_company_map = {
+            "microsoft.com": "Microsoft",
+            "google.com": "Google", 
+            "apple.com": "Apple",
+            "amazon.com": "Amazon",
+            "amazon.jobs": "Amazon",
+            # Note: LinkedIn is excluded here because linkedin.com hosts jobs for OTHER companies
+            "paypal.com": "PayPal",
+            "paypal.eightfold.ai": "PayPal",
+            "meta.com": "Meta",
+            "facebook.com": "Meta",
+            "netflix.com": "Netflix",
+            "spotify.com": "Spotify",
+            "uber.com": "Uber",
+            "airbnb.com": "Airbnb",
+            "salesforce.com": "Salesforce",
+            "oracle.com": "Oracle",
+            "adobe.com": "Adobe",
+            "nvidia.com": "NVIDIA",
+            "tesla.com": "Tesla",
+            "stripe.com": "Stripe",
+            "ing.com": "ING"
+        }
+        
+        for domain, company in url_company_map.items():
+            if domain in raw_input.lower():
+                return company
+        
+        # Look for company patterns in scraped text (improved patterns)
+        company_patterns = [
+            # Direct company mentions (case-insensitive)
+            r"\b(ING|Microsoft|Google|Apple|Amazon|Meta|Facebook|Netflix|Tesla|Uber|Airbnb|Spotify|PayPal|Salesforce|Oracle|Adobe|NVIDIA|Stripe|Parambil)\b",
+            # Company in context patterns
+            r"(?:at|with|for|join)\s+([A-Z][a-zA-Z\s&.,-]+(?:Inc|LLC|Corp|Corporation|Ltd|Limited|Bank|Group)?)\b",
+            r"The Benefits Of Working With Us At\s+([A-Z][a-zA-Z\s&.-]+)",
+            r"About\s+([A-Z][a-zA-Z\s&.-]+)(?:\s+Include|\s*$)",
+            # Job posting patterns
+            r"Company:\s*([^\n\r]+)",
+            r"Company Name:\s*([^\n\r]+)",
+            r"Organization:\s*([^\n\r]+)",
+            r"Employer:\s*([^\n\r]+)",
+            # Common job title patterns with "at Company"
+            r"(?:Engineer|Scientist|Manager|Analyst|Developer|Designer|Specialist|Coordinator|Director)\s+at\s+([^\n\r,]+)",
+            r"(?:Senior|Junior|Lead|Staff|Principal)\s+\w+\s+at\s+([^\n\r,]+)",
+            # First line company extraction (common format)
+            r"^([A-Z][a-zA-Z\s&.,-]+(?:Inc|LLC|Corp|Corporation|Ltd|Limited)?)\s*$"
+        ]
+        
+        for pattern in company_patterns:
+            matches = re.finditer(pattern, scraped_text, re.IGNORECASE | re.MULTILINE)
+            for match in matches:
+                company = match.group(1) if match.lastindex else match.group(0)
+                # Clean up formatting
+                company = company.strip()
+                # Remove markdown formatting
+                company = re.sub(r'^\*+\s*', '', company)  # Remove leading asterisks
+                company = re.sub(r'\s*\*+$', '', company)  # Remove trailing asterisks
+                company = re.sub(r'\s+', ' ', company)  # Normalize whitespace
+                
+                # Filter out non-company names and LinkedIn
+                excluded = ['linkedin', 'linkedin corporation', 'show more', 'about the job', 'about', 'include', 'benefits']
+                if (company.lower() not in excluded and 
+                    len(company.strip()) >= 2 and 
+                    len(company.strip()) <= 50 and
+                    not company.lower().startswith('http')):
+                    return company
+        
+        return ""
+    
+    def _extract_role(self, scraped_text: str, raw_input: str) -> str:
+        """Extract job role/title from text or URL"""
+        import re
+        
+        # Look for title patterns in scraped text first (more reliable)
+        title_patterns = [
+            # Specific title patterns for this job
+            r"(Regulatory Engagement and Oversight Specialist[^.\n]*)",
+            r"(Financial Risk Specialist[^.\n]*)",
+            # Generic title patterns
+            r"Title:\s*([^\n\r]+)",
+            r"Position:\s*([^\n\r]+)",
+            r"Role:\s*([^\n\r]+)",
+            r"Job Title:\s*([^\n\r]+)",
+            r"Job:\s*([^\n\r]+)",
+            # First line of job posting (often the title)
+            r"^([A-Z][a-zA-Z\s/-]+(?:Specialist|Engineer|Manager|Analyst|Developer|Designer|Coordinator|Director|Scientist))\s*$",
+            # Common job title patterns
+            r"\b((?:Senior|Jr|Junior|Lead|Staff|Principal)?\s*(?:Software|Data|Applied|Research|Machine Learning|AI|Product|Marketing|Sales|Business|Regulatory|Financial|Risk)\s*(?:Engineer|Scientist|Manager|Analyst|Developer|Designer|Specialist|Coordinator|Director))\b",
+            r"\b((?:Senior|Jr|Junior|Lead|Staff|Principal)?\s*(?:Full Stack|Frontend|Backend|DevOps|Cloud|Security|Mobile|Web)\s*(?:Engineer|Developer))\b"
+        ]
+        
+        for pattern in title_patterns:
+            match = re.search(pattern, scraped_text, re.IGNORECASE | re.MULTILINE)
+            if match:
+                title = match.group(1).strip() if match.lastindex else match.group(0).strip()
+                # Clean up common formatting issues
+                title = re.sub(r'^\*+\s*', '', title)  # Remove leading asterisks
+                title = re.sub(r'\s*\*+$', '', title)  # Remove trailing asterisks
+                title = re.sub(r'\s+', ' ', title)  # Normalize whitespace
+                title = re.sub(r'\s*for\s*$', '', title, flags=re.IGNORECASE)  # Remove trailing "for"
+                if 5 <= len(title) <= 100:  # Reasonable length check
+                    return title
+        
+        # Extract from URL if it contains job title (fallback)
+        if raw_input and "/" in raw_input:
+            url_parts = raw_input.split("/")
+            for part in reversed(url_parts):  # Check from end first
+                if any(keyword in part.lower() for keyword in ["scientist", "engineer", "developer", "manager", "analyst", "designer", "specialist"]):
+                    # Clean up URL formatting
+                    role = part.replace("-", " ").replace("_", " ").replace("%20", " ")
+                    role = re.sub(r'\([^)]*\)', '', role)  # Remove parentheses content
+                    role = re.sub(r'\?.*', '', role)  # Remove query parameters
+                    role = " ".join(word.capitalize() for word in role.split() if word)
+                    if 10 <= len(role) <= 80:
+                        return role.strip()
+        
+        return ""
+    
+    def _extract_level(self, scraped_text: str, llm_response: str) -> str:
+        """Extract seniority level from text"""
+        import re
+        
+        text_to_check = f"{scraped_text} {llm_response}".lower()
+        
+        if any(term in text_to_check for term in ["senior", "sr.", "lead", "staff", "principal"]):
+            return "Senior"
+        elif any(term in text_to_check for term in ["junior", "jr.", "entry", "associate", "grad"]):
+            return "Junior"
+        elif any(term in text_to_check for term in ["mid", "intermediate", "ii", "2"]):
+            return "Mid"
+        else:
+            return "Mid"  # Default assumption 

micro/gap_analysis.py

@@ -0,0 +1,253 @@
+from typing import Any, Dict, List, Optional, Set
+import re
+from llm_client import llm_client
+from prompt_loader import prompt_loader
+from metrics import log_metric
+
+class GapAnalysisMicroFunction:
+    def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        resume_data = data.get("resume_data", {})
+        enriched_data = data.get("enriched", {})
+        
+        if not resume_data or "error" in resume_data:
+            return {**data, "gap_analysis": {"error": "No resume data available"}}
+        
+        if not enriched_data or enriched_data.get("error"):
+            return {**data, "gap_analysis": {"error": "No job data available"}}
+        
+        try:
+            # Perform comprehensive gap analysis
+            gap_analysis = self._analyze_gaps(resume_data, enriched_data)
+            
+            log_metric("gap_analysis_success", {
+                "match_score": gap_analysis.get("match_score", 0),
+                "strong_matches": len(gap_analysis.get("strong_matches", [])),
+                "gaps": len(gap_analysis.get("gaps", []))
+            })
+            
+            return {**data, "gap_analysis": gap_analysis}
+            
+        except Exception as e:
+            log_metric("gap_analysis_error", {"error": str(e)})
+            return {**data, "gap_analysis": {"error": f"Gap analysis failed: {e}"}}
+    
+    def _analyze_gaps(self, resume_data: Dict[str, Any], job_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Perform detailed gap analysis between resume and job requirements"""
+        
+        # Extract skills from resume
+        resume_skills = self._extract_resume_skills(resume_data)
+        
+        # Extract requirements from job
+        job_requirements = self._extract_job_requirements(job_data)
+        
+        # Perform skill matching
+        strong_matches = []
+        partial_matches = []
+        gaps = []
+        
+        for req in job_requirements:
+            req_lower = req.lower()
+            match_type = self._find_skill_match(req_lower, resume_skills)
+            
+            if match_type == "strong":
+                strong_matches.append(req)
+            elif match_type == "partial":
+                partial_matches.append(req)
+            else:
+                gaps.append(req)
+        
+        # Calculate match score (0-100)
+        total_requirements = len(job_requirements)
+        if total_requirements == 0:
+            match_score = 50  # Default if no requirements found
+        else:
+            strong_weight = 1.0
+            partial_weight = 0.5
+            score = (len(strong_matches) * strong_weight + len(partial_matches) * partial_weight) / total_requirements * 100
+            match_score = min(100, max(0, round(score)))
+        
+        # Generate narrative summary
+        summary = self._generate_summary(strong_matches, partial_matches, gaps, match_score)
+        
+        # Create skills map for visualization
+        skills_map = self._create_skills_map(strong_matches, partial_matches, gaps)
+        
+        return {
+            "match_score": match_score,
+            "strong_matches": strong_matches,
+            "partial_matches": partial_matches,
+            "gaps": gaps,
+            "summary": summary,
+            "skills_map": skills_map,
+            "resume_skills_count": len(resume_skills),
+            "job_requirements_count": total_requirements
+        }
+    
+    def _extract_resume_skills(self, resume_data: Dict[str, Any]) -> Set[str]:
+        """Extract all skills from resume data"""
+        skills = set()
+        
+        # Technical skills
+        skills_section = resume_data.get("skills", {})
+        if isinstance(skills_section, dict):
+            for skill_category in skills_section.values():
+                if isinstance(skill_category, list):
+                    skills.update([skill.lower() for skill in skill_category])
+        
+        # Skills from experience
+        experience = resume_data.get("experience", [])
+        for exp in experience:
+            if isinstance(exp, dict):
+                technologies = exp.get("technologies", [])
+                if isinstance(technologies, list):
+                    skills.update([tech.lower() for tech in technologies])
+        
+        # Skills from projects
+        projects = resume_data.get("projects", [])
+        for proj in projects:
+            if isinstance(proj, dict):
+                technologies = proj.get("technologies", [])
+                if isinstance(technologies, list):
+                    skills.update([tech.lower() for tech in technologies])
+        
+        return skills
+    
+    def _extract_job_requirements(self, job_data: Dict[str, Any]) -> List[str]:
+        """Extract requirements from job data"""
+        requirements = []
+        
+        # From requirements field
+        job_reqs = job_data.get("requirements", [])
+        if isinstance(job_reqs, list):
+            requirements.extend(job_reqs)
+        elif isinstance(job_reqs, str):
+            # Split by common delimiters
+            requirements.extend(re.split(r'[,;\n•\-]', job_reqs))
+        
+        # From tech stack
+        tech_stack = job_data.get("tech_stack", [])
+        if isinstance(tech_stack, list):
+            requirements.extend(tech_stack)
+        elif isinstance(tech_stack, str):
+            requirements.extend(re.split(r'[,;\n•\-]', tech_stack))
+        
+        # From responsibilities (extract technical terms)
+        responsibilities = job_data.get("responsibilities", [])
+        if isinstance(responsibilities, list):
+            for resp in responsibilities:
+                if isinstance(resp, str):
+                    # Extract technical terms
+                    tech_terms = self._extract_tech_terms(resp)
+                    requirements.extend(tech_terms)
+        
+        # Clean and deduplicate
+        cleaned_requirements = []
+        for req in requirements:
+            if isinstance(req, str):
+                cleaned = req.strip().strip('•-').strip()
+                if cleaned and len(cleaned) > 2:
+                    cleaned_requirements.append(cleaned)
+        
+        return list(set(cleaned_requirements))
+    
+    def _extract_tech_terms(self, text: str) -> List[str]:
+        """Extract technical terms from text"""
+        # Common tech terms and patterns
+        tech_patterns = [
+            r'\b(Python|JavaScript|Java|C\+\+|C#|Ruby|Go|Rust|Swift|Kotlin)\b',
+            r'\b(React|Angular|Vue|Django|Flask|Spring|Rails|Laravel)\b',
+            r'\b(AWS|Azure|GCP|Docker|Kubernetes|Git|SQL|NoSQL)\b',
+            r'\b(Machine Learning|ML|AI|Deep Learning|TensorFlow|PyTorch)\b',
+            r'\b(Data Science|Analytics|Statistics|Pandas|NumPy)\b',
+            r'\b(API|REST|GraphQL|Microservices|DevOps|CI/CD)\b'
+        ]
+        
+        terms = []
+        for pattern in tech_patterns:
+            matches = re.findall(pattern, text, re.IGNORECASE)
+            terms.extend([match.lower() for match in matches])
+        
+        return terms
+    
+    def _find_skill_match(self, requirement: str, resume_skills: Set[str]) -> str:
+        """Find the type of match between requirement and resume skills"""
+        req_clean = requirement.lower().strip()
+        
+        # Strong match: exact match or very close
+        if req_clean in resume_skills:
+            return "strong"
+        
+        # Check for partial matches
+        for skill in resume_skills:
+            # Substring match (both directions)
+            if (req_clean in skill and len(req_clean) > 2) or (skill in req_clean and len(skill) > 2):
+                return "partial"
+            
+            # Similar technologies (e.g., React/ReactJS, Python/Python3)
+            if self._are_similar_technologies(req_clean, skill):
+                return "strong"
+        
+        return "none"
+    
+    def _are_similar_technologies(self, tech1: str, tech2: str) -> bool:
+        """Check if two technologies are similar/related"""
+        similar_groups = [
+            ["python", "python3", "python2"],
+            ["javascript", "js", "node.js", "nodejs"],
+            ["react", "reactjs", "react.js"],
+            ["angular", "angularjs"],
+            ["vue", "vue.js", "vuejs"],
+            ["docker", "containerization"],
+            ["kubernetes", "k8s"],
+            ["aws", "amazon web services"],
+            ["gcp", "google cloud platform", "google cloud"],
+            ["azure", "microsoft azure"],
+            ["sql", "mysql", "postgresql", "postgres"],
+            ["nosql", "mongodb", "cassandra"],
+            ["machine learning", "ml", "artificial intelligence", "ai"],
+            ["tensorflow", "tf"],
+            ["pytorch", "torch"]
+        ]
+        
+        for group in similar_groups:
+            if tech1 in group and tech2 in group:
+                return True
+        
+        return False
+    
+    def _generate_summary(self, strong_matches: List[str], partial_matches: List[str], 
+                         gaps: List[str], match_score: int) -> str:
+        """Generate narrative summary of the gap analysis"""
+        
+        summary_parts = []
+        
+        # Overall assessment
+        if match_score >= 80:
+            summary_parts.append(f"Excellent match ({match_score}% compatibility)!")
+        elif match_score >= 60:
+            summary_parts.append(f"Good match ({match_score}% compatibility) with some areas for growth.")
+        elif match_score >= 40:
+            summary_parts.append(f"Moderate match ({match_score}% compatibility) requiring focused preparation.")
+        else:
+            summary_parts.append(f"Challenging match ({match_score}% compatibility) needing significant upskilling.")
+        
+        # Strengths
+        if strong_matches:
+            top_strengths = strong_matches[:3]
+            summary_parts.append(f"Your strongest assets are {', '.join(top_strengths)}.")
+        
+        # Gaps to address
+        if gaps:
+            priority_gaps = gaps[:3]
+            summary_parts.append(f"Focus your preparation on {', '.join(priority_gaps)}.")
+        
+        return " ".join(summary_parts)
+    
+    def _create_skills_map(self, strong_matches: List[str], partial_matches: List[str], 
+                          gaps: List[str]) -> Dict[str, List[str]]:
+        """Create a skills map for visualization"""
+        return {
+            "strong": strong_matches[:10],  # Limit for display
+            "partial": partial_matches[:10],
+            "gaps": gaps[:10]
+        } 

micro/guide_render.py

@@ -0,0 +1,301 @@
+from typing import Any, Dict, List, Optional
+from metrics import log_metric
+
+class GuideRenderMicroFunction:
+    def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        interview_guide = data.get("interview_guide", {})
+        
+        if not interview_guide or "error" in interview_guide:
+            return {**data, "rendered_guide": "# Interview Guide Generation Failed\n\nPlease try again with valid resume and job data."}
+        
+        try:
+            # Render comprehensive markdown guide
+            rendered_guide = self._render_interview_guide(interview_guide)
+            
+            log_metric("guide_render_success", {
+                "total_length": len(rendered_guide),
+                "sections_count": len(interview_guide.keys())
+            })
+            
+            return {**data, "rendered_guide": rendered_guide}
+            
+        except Exception as e:
+            log_metric("guide_render_error", {"error": str(e)})
+            fallback = self._create_fallback_guide(interview_guide)
+            return {**data, "rendered_guide": fallback}
+    
+    def _render_interview_guide(self, guide: Dict[str, Any]) -> str:
+        """Render complete interview guide in Interview Query style"""
+        
+        metadata = guide.get("metadata", {})
+        role = metadata.get("role", "Unknown Role")
+        company = metadata.get("company", "Unknown Company")
+        match_score = metadata.get("match_score", 0)
+        
+        # Build comprehensive guide
+        sections = []
+        
+        # Header
+        sections.append(self._render_header(role, company, match_score))
+        
+        # Introduction
+        sections.append(self._render_introduction(guide.get("introduction", "")))
+        
+        # Skills Analysis with visual
+        sections.append(self._render_skills_analysis(guide.get("skills_analysis", {})))
+        
+        # Interview Process
+        sections.append(self._render_interview_process(company, guide.get("interview_process", "")))
+        
+        # Question Sections
+        sections.append(self._render_questions(guide.get("questions", {}), role))
+        
+        # Preparation Strategy
+        sections.append(self._render_preparation_tips(guide.get("preparation_tips", {})))
+        
+        # Talking Points
+        sections.append(self._render_talking_points(guide.get("talking_points", [])))
+        
+        # Smart Questions to Ask
+        sections.append(self._render_smart_questions(guide.get("smart_questions", [])))
+        
+        # Conclusion with Resources
+        sections.append(self._render_conclusion(guide.get("conclusion", {})))
+        
+        return "\n\n".join(sections)
+    
+    def _render_header(self, role: str, company: str, match_score: int) -> str:
+        """Render header with match score indicator"""
+        
+        # Match score indicator
+        if match_score >= 80:
+            score_indicator = "🟢 Excellent Match"
+            score_color = "green"
+        elif match_score >= 60:
+            score_indicator = "🟡 Good Match"
+            score_color = "yellow"
+        elif match_score >= 40:
+            score_indicator = "🟠 Moderate Match"
+            score_color = "orange"
+        else:
+            score_indicator = "🔴 Challenging Match"
+            score_color = "red"
+        
+        return f"""# 🎯 Personalized Interview Guide: {role} at {company}
+
+**Match Score**: {score_indicator} ({match_score}%)
+
+---"""
+    
+    def _render_introduction(self, introduction: str) -> str:
+        """Render introduction section"""
+        return f"""## Introduction
+
+{introduction}"""
+    
+    def _render_skills_analysis(self, skills_analysis: Dict[str, Any]) -> str:
+        """Render skills analysis with visual chart"""
+        
+        match_score = skills_analysis.get("match_score", 0)
+        summary = skills_analysis.get("summary", "")
+        skills_breakdown = skills_analysis.get("skills_breakdown", {})
+        chart_data = skills_analysis.get("chart_data", {})
+        
+        # Create text-based bar chart
+        strong_count = chart_data.get("strong_matches", 0)
+        partial_count = chart_data.get("partial_matches", 0)
+        gaps_count = chart_data.get("gaps", 0)
+        total = strong_count + partial_count + gaps_count
+        
+        if total > 0:
+            strong_bar = "█" * min(20, int((strong_count / total) * 20))
+            partial_bar = "▒" * min(20, int((partial_count / total) * 20))
+            gaps_bar = "░" * min(20, int((gaps_count / total) * 20))
+        else:
+            strong_bar = partial_bar = gaps_bar = ""
+        
+        chart = f"""
+### Skills Match Analysis
+
+**Overall Assessment**: {summary}
+
+#### Skills Breakdown
+```
+Strong Matches  {strong_bar} {strong_count}
+Partial Matches {partial_bar} {partial_count}  
+Skill Gaps      {gaps_bar} {gaps_count}
+```
+"""
+        
+        # Add detailed breakdowns
+        if skills_breakdown:
+            if skills_breakdown.get("strong"):
+                chart += f"\n**✅ Your Strengths**: {', '.join(skills_breakdown['strong'][:5])}"
+            
+            if skills_breakdown.get("partial"):
+                chart += f"\n\n**⚡ Areas to Highlight**: {', '.join(skills_breakdown['partial'][:5])}"
+            
+            if skills_breakdown.get("gaps"):
+                chart += f"\n\n**📚 Priority Learning**: {', '.join(skills_breakdown['gaps'][:5])}"
+        
+        return chart
+    
+    def _render_interview_process(self, company: str, process_content: str) -> str:
+        """Render interview process section"""
+        return f"""## What Is the Interview Process Like at {company}?
+
+{process_content}"""
+    
+    def _render_questions(self, questions: Dict[str, List[Dict]], role: str) -> str:
+        """Render all question sections"""
+        
+        sections = []
+        
+        # Technical Questions
+        if questions.get("technical"):
+            sections.append(self._render_question_section(
+                "Technical & Problem-Solving Questions",
+                questions["technical"],
+                f"These questions test your technical knowledge for the {role} role. Focus on demonstrating both your understanding and problem-solving approach."
+            ))
+        
+        # Behavioral Questions
+        if questions.get("behavioral"):
+            sections.append(self._render_question_section(
+                "Behavioral & Experience Questions",
+                questions["behavioral"],
+                "Use the STAR method (Situation, Task, Action, Result) to structure your responses. Draw from specific examples in your background."
+            ))
+        
+        # Company Questions
+        if questions.get("company"):
+            sections.append(self._render_question_section(
+                "Company & Culture Questions",
+                questions["company"],
+                "These questions assess your interest in the company and cultural fit. Research thoroughly and be genuine in your responses."
+            ))
+        
+        return "\n\n".join(sections)
+    
+    def _render_question_section(self, title: str, questions: List[Dict], intro: str) -> str:
+        """Render individual question section"""
+        
+        section = f"""## {title}
+
+{intro}
+
+"""
+        
+        for i, q in enumerate(questions, 1):
+            question_text = q.get("question", "")
+            approach = q.get("approach", "")
+            difficulty = q.get("difficulty", "")
+            
+            # Add difficulty indicator
+            if difficulty == "advanced":
+                diff_icon = "🔴"
+            elif difficulty == "intermediate":
+                diff_icon = "🟡"
+            else:
+                diff_icon = "🟢"
+            
+            section += f"""**{i}. {question_text}** {diff_icon}
+
+{approach}
+
+"""
+        
+        return section.strip()
+    
+    def _render_preparation_tips(self, tips: Dict[str, List[str]]) -> str:
+        """Render preparation tips section"""
+        
+        section = "## Preparation Strategy\n\n"
+        
+        # Priority areas (gaps)
+        if tips.get("priority_areas"):
+            section += "### 🎯 Priority Focus Areas\n\n"
+            for tip in tips["priority_areas"]:
+                section += f"- {tip}\n"
+            section += "\n"
+        
+        # Leverage strengths
+        if tips.get("leverage_strengths"):
+            section += "### 💪 Leverage Your Strengths\n\n"
+            for tip in tips["leverage_strengths"]:
+                section += f"- {tip}\n"
+            section += "\n"
+        
+        # General tips
+        if tips.get("general"):
+            section += "### 📋 General Interview Tips\n\n"
+            for tip in tips["general"]:
+                section += f"- {tip}\n"
+            section += "\n"
+        
+        return section.strip()
+    
+    def _render_talking_points(self, talking_points: List[str]) -> str:
+        """Render talking points section"""
+        
+        if not talking_points:
+            return ""
+        
+        section = "## Key Talking Points\n\n"
+        section += "Highlight these specific achievements and experiences during your interview:\n\n"
+        
+        for point in talking_points:
+            section += f"- {point}\n"
+        
+        return section
+    
+    def _render_smart_questions(self, questions: List[str]) -> str:
+        """Render smart questions section"""
+        
+        if not questions:
+            return ""
+        
+        section = "## Smart Questions to Ask\n\n"
+        section += "End your interview strong by asking thoughtful questions:\n\n"
+        
+        for question in questions:
+            section += f"- {question}\n"
+        
+        return section
+    
+    def _render_conclusion(self, conclusion: Dict[str, str]) -> str:
+        """Render conclusion with resources"""
+        
+        summary = conclusion.get("summary", "")
+        
+        section = f"""## Conclusion
+
+{summary}
+
+### Additional Resources
+
+- [Success Story]({conclusion.get('success_story_link', '#')})
+- [Learning Resources]({conclusion.get('learning_resource_link', '#')})
+- [Practice Questions]({conclusion.get('questions_practice_link', '#')})
+
+---
+
+**Good luck with your interview!** 🚀
+
+*This personalized guide was generated based on your specific background and the target role requirements.*"""
+        
+        return section
+    
+    def _create_fallback_guide(self, guide: Dict[str, Any]) -> str:
+        """Create fallback guide if rendering fails"""
+        
+        return f"""# Personalized Interview Guide
+
+## Summary
+This guide was generated to help you prepare for your interview.
+
+## Content
+{str(guide)}
+
+---
+*Please try regenerating for better formatting.*""" 

micro/interview_guide.py

@@ -0,0 +1,408 @@
+from typing import Any, Dict, List, Optional
+from llm_client import llm_client
+from prompt_loader import prompt_loader
+from metrics import log_metric
+import json
+
+class InterviewGuideMicroFunction:
+    def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        resume_data = data.get("resume_data", {})
+        enriched_data = data.get("enriched", {})
+        gap_analysis = data.get("gap_analysis", {})
+        
+        if not resume_data or "error" in resume_data:
+            return {**data, "interview_guide": {"error": "No resume data available"}}
+        
+        if not enriched_data or enriched_data.get("error"):
+            return {**data, "interview_guide": {"error": "No job data available"}}
+        
+        if not gap_analysis or "error" in gap_analysis:
+            return {**data, "interview_guide": {"error": "No gap analysis available"}}
+        
+        try:
+            # Generate personalized interview guide
+            guide = self._generate_interview_guide(resume_data, enriched_data, gap_analysis)
+            
+            log_metric("interview_guide_success", {
+                "sections_count": len(guide.get("sections", {})),
+                "questions_count": sum(len(q) for q in guide.get("questions", {}).values()),
+                "match_score": gap_analysis.get("match_score", 0)
+            })
+            
+            return {**data, "interview_guide": guide}
+            
+        except Exception as e:
+            log_metric("interview_guide_error", {"error": str(e)})
+            return {**data, "interview_guide": {"error": f"Interview guide generation failed: {e}"}}
+    
+    def _generate_interview_guide(self, resume_data: Dict[str, Any], 
+                                 job_data: Dict[str, Any], 
+                                 gap_analysis: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate comprehensive personalized interview guide"""
+        
+        # Extract key information
+        role = job_data.get("role", "Unknown Role")
+        company = job_data.get("company", "Unknown Company")
+        match_score = gap_analysis.get("match_score", 0)
+        strong_matches = gap_analysis.get("strong_matches", [])
+        gaps = gap_analysis.get("gaps", [])
+        
+        # Generate introduction
+        introduction = self._generate_introduction(role, company, resume_data, gap_analysis)
+        
+        # Generate skills analysis section
+        skills_analysis = self._generate_skills_analysis(gap_analysis)
+        
+        # Generate interview process section
+        interview_process = self._generate_interview_process(company, role)
+        
+        # Generate question sections
+        questions = self._generate_question_sections(role, strong_matches, gaps, resume_data)
+        
+        # Generate preparation tips
+        preparation_tips = self._generate_preparation_tips(gaps, strong_matches, match_score)
+        
+        # Generate talking points
+        talking_points = self._generate_talking_points(resume_data, strong_matches)
+        
+        # Generate smart questions to ask
+        smart_questions = self._generate_smart_questions(company, role, job_data)
+        
+        # Generate conclusion with resources
+        conclusion = self._generate_conclusion(role, company, gaps)
+        
+        return {
+            "introduction": introduction,
+            "skills_analysis": skills_analysis,
+            "interview_process": interview_process,
+            "questions": questions,
+            "preparation_tips": preparation_tips,
+            "talking_points": talking_points,
+            "smart_questions": smart_questions,
+            "conclusion": conclusion,
+            "metadata": {
+                "role": role,
+                "company": company,
+                "match_score": match_score,
+                "generated_at": self._get_timestamp()
+            }
+        }
+    
+    def _generate_introduction(self, role: str, company: str, 
+                              resume_data: Dict[str, Any], 
+                              gap_analysis: Dict[str, Any]) -> str:
+        """Generate personalized introduction"""
+        
+        match_score = gap_analysis.get("match_score", 0)
+        summary = gap_analysis.get("summary", "")
+        
+        # Extract user's background
+        experience = resume_data.get("experience", [])
+        years_exp = len(experience)
+        
+        recent_role = ""
+        if experience:
+            recent_role = experience[0].get("title", "") if isinstance(experience[0], dict) else ""
+        
+        prompt = f"""
+Write a personalized interview guide introduction for:
+- Target Role: {role} at {company}
+- Candidate Background: {recent_role} with {years_exp} roles
+- Match Score: {match_score}%
+- Gap Summary: {summary}
+
+Use a confident, mentor-like tone. Start with the primary keyword "{role} interview" in the first 100 words.
+Address the candidate directly ("you") and reference their specific background.
+Keep it ≤150 words, 3 sentences max per paragraph.
+
+Focus on:
+1. What makes this role exciting for someone with their background
+2. Their competitive advantages 
+3. What this guide will help them achieve
+"""
+        
+        return llm_client.call_llm(prompt)
+    
+    def _generate_skills_analysis(self, gap_analysis: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate visual skills analysis section"""
+        
+        skills_map = gap_analysis.get("skills_map", {})
+        match_score = gap_analysis.get("match_score", 0)
+        summary = gap_analysis.get("summary", "")
+        
+        # Create bar chart data for visualization
+        chart_data = {
+            "strong_matches": len(skills_map.get("strong", [])),
+            "partial_matches": len(skills_map.get("partial", [])),
+            "gaps": len(skills_map.get("gaps", []))
+        }
+        
+        return {
+            "match_score": match_score,
+            "summary": summary,
+            "skills_breakdown": skills_map,
+            "chart_data": chart_data
+        }
+    
+    def _generate_interview_process(self, company: str, role: str) -> str:
+        """Generate interview process section"""
+        
+        prompt = f"""
+Describe the typical interview process for a {role} position at {company}.
+If you don't know the specific company process, describe the general process for this role type.
+
+Include:
+1. Number of rounds typically
+2. Types of interviews (phone, technical, behavioral, onsite)
+3. Who you'll likely meet with
+4. Timeline expectations
+5. Any company-specific details if known
+
+Use markdown formatting with headers. Keep conversational and actionable.
+Max 200 words.
+"""
+        
+        return llm_client.call_llm(prompt)
+    
+    def _generate_question_sections(self, role: str, strong_matches: List[str], 
+                                   gaps: List[str], resume_data: Dict[str, Any]) -> Dict[str, List[Dict]]:
+        """Generate categorized interview questions with personalized advice"""
+        
+        questions = {}
+        
+        # Technical questions (prioritize gaps)
+        technical_questions = self._generate_technical_questions(role, gaps, strong_matches)
+        if technical_questions:
+            questions["technical"] = technical_questions
+        
+        # Behavioral questions
+        behavioral_questions = self._generate_behavioral_questions(role, resume_data)
+        if behavioral_questions:
+            questions["behavioral"] = behavioral_questions
+        
+        # Company-specific questions
+        company_questions = self._generate_company_questions(role)
+        if company_questions:
+            questions["company"] = company_questions
+        
+        return questions
+    
+    def _generate_technical_questions(self, role: str, gaps: List[str], 
+                                     strong_matches: List[str]) -> List[Dict[str, str]]:
+        """Generate technical questions with personalized approach guidance"""
+        
+        # Prioritize gap areas for question focus
+        focus_areas = gaps[:3] if gaps else strong_matches[:3]
+        
+        prompt = f"""
+Generate 5 technical interview questions for a {role} position.
+Focus areas based on candidate needs: {', '.join(focus_areas)}
+
+For each question, provide:
+1. The question
+2. A 2-3 sentence approach tailored to someone who needs to strengthen {focus_areas[0] if focus_areas else 'general skills'}
+
+Format as JSON array:
+[
+  {{
+    "question": "Question text",
+    "approach": "Personalized approach advice",
+    "difficulty": "beginner|intermediate|advanced"
+  }}
+]
+
+Focus on practical, real-world questions that test understanding.
+"""
+        
+        try:
+            response = llm_client.call_llm(prompt)
+            # Parse JSON response
+            import json
+            from text_extractor import robust_json_parse
+            questions_data = robust_json_parse(response)
+            if isinstance(questions_data, list):
+                return questions_data
+        except:
+            pass
+        
+        # Fallback questions
+        return [
+            {
+                "question": f"How would you approach solving a {role.lower()} problem?",
+                "approach": "Focus on your systematic problem-solving process and mention relevant experience.",
+                "difficulty": "intermediate"
+            }
+        ]
+    
+    def _generate_behavioral_questions(self, role: str, resume_data: Dict[str, Any]) -> List[Dict[str, str]]:
+        """Generate behavioral questions with personalized advice"""
+        
+        # Extract key experiences for STAR method guidance
+        experience = resume_data.get("experience", [])
+        recent_achievements = []
+        
+        for exp in experience[:2]:  # Focus on recent experience
+            if isinstance(exp, dict):
+                achievements = exp.get("achievements", [])
+                if achievements:
+                    recent_achievements.extend(achievements[:2])
+        
+        prompt = f"""
+Generate 5 behavioral interview questions for a {role} position.
+Candidate's recent achievements: {', '.join(recent_achievements[:3])}
+
+For each question, provide specific STAR method guidance using their background.
+
+Format as JSON array:
+[
+  {{
+    "question": "Question text",
+    "approach": "STAR method guidance referencing their specific experience",
+    "difficulty": "standard"
+  }}
+]
+
+Focus on leadership, problem-solving, teamwork, and role-specific scenarios.
+"""
+        
+        try:
+            response = llm_client.call_llm(prompt)
+            from text_extractor import robust_json_parse
+            questions_data = robust_json_parse(response)
+            if isinstance(questions_data, list):
+                return questions_data
+        except:
+            pass
+        
+        # Fallback questions
+        return [
+            {
+                "question": "Tell me about a challenging project you worked on.",
+                "approach": "Use STAR method: Situation, Task, Action, Result. Draw from your recent experience.",
+                "difficulty": "standard"
+            }
+        ]
+    
+    def _generate_company_questions(self, role: str) -> List[Dict[str, str]]:
+        """Generate company-specific questions"""
+        
+        return [
+            {
+                "question": "Why are you interested in this role?",
+                "approach": "Connect your career goals with the company's mission and this specific role's impact.",
+                "difficulty": "standard"
+            },
+            {
+                "question": "What do you know about our company?",
+                "approach": "Research their recent news, mission, and values. Show genuine interest in their work.",
+                "difficulty": "standard"
+            }
+        ]
+    
+    def _generate_preparation_tips(self, gaps: List[str], strong_matches: List[str], 
+                                  match_score: int) -> Dict[str, List[str]]:
+        """Generate personalized preparation tips"""
+        
+        tips = {}
+        
+        # Tips for gap areas (priority)
+        if gaps:
+            gap_tips = []
+            for gap in gaps[:3]:
+                gap_tips.append(f"Study {gap} fundamentals - focus on practical applications")
+                gap_tips.append(f"Find online tutorials or courses for {gap}")
+                gap_tips.append(f"Practice explaining {gap} concepts in simple terms")
+            tips["priority_areas"] = gap_tips[:5]
+        
+        # Tips for strength areas
+        if strong_matches:
+            strength_tips = []
+            for strength in strong_matches[:3]:
+                strength_tips.append(f"Prepare advanced examples showcasing your {strength} expertise")
+                strength_tips.append(f"Think of specific metrics/results from {strength} projects")
+            tips["leverage_strengths"] = strength_tips[:5]
+        
+        # General tips based on match score
+        if match_score < 60:
+            tips["general"] = [
+                "Focus heavily on demonstrating learning ability and enthusiasm",
+                "Prepare questions that show your eagerness to grow",
+                "Research the company thoroughly to show genuine interest"
+            ]
+        else:
+            tips["general"] = [
+                "Practice articulating your experience clearly and confidently",
+                "Prepare specific examples that align with job requirements",
+                "Focus on cultural fit and long-term career alignment"
+            ]
+        
+        return tips
+    
+    def _generate_talking_points(self, resume_data: Dict[str, Any], 
+                                strong_matches: List[str]) -> List[str]:
+        """Generate specific talking points based on resume"""
+        
+        talking_points = []
+        
+        # From recent experience
+        experience = resume_data.get("experience", [])
+        if experience:
+            recent_exp = experience[0]
+            if isinstance(recent_exp, dict):
+                achievements = recent_exp.get("achievements", [])
+                talking_points.extend(achievements[:2])
+        
+        # From projects
+        projects = resume_data.get("projects", [])
+        for project in projects[:2]:
+            if isinstance(project, dict):
+                name = project.get("name", "")
+                description = project.get("description", "")
+                if name and description:
+                    talking_points.append(f"{name}: {description}")
+        
+        # From strong matches
+        for match in strong_matches[:3]:
+            talking_points.append(f"Deep experience with {match} from multiple projects")
+        
+        return talking_points[:6]
+    
+    def _generate_smart_questions(self, company: str, role: str, 
+                                 job_data: Dict[str, Any]) -> List[str]:
+        """Generate thoughtful questions for the candidate to ask"""
+        
+        questions = [
+            f"What does success look like for someone in this {role} role after 6 months?",
+            f"What are the biggest challenges facing the team/company right now?",
+            "What opportunities for growth and learning does this role offer?",
+            "How does this role contribute to the company's strategic goals?",
+            "What do you enjoy most about working at this company?"
+        ]
+        
+        # Add role-specific questions
+        if "engineer" in role.lower():
+            questions.append("What's the team's approach to code reviews and technical debt?")
+            questions.append("How do you balance feature development with technical improvements?")
+        elif "data" in role.lower():
+            questions.append("What data infrastructure and tools does the team use?")
+            questions.append("How do you ensure data quality and reliability?")
+        
+        return questions[:7]
+    
+    def _generate_conclusion(self, role: str, company: str, gaps: List[str]) -> Dict[str, str]:
+        """Generate conclusion with resource links"""
+        
+        # Focus on top gap for learning resource
+        primary_gap = gaps[0] if gaps else "general interview skills"
+        
+        return {
+            "summary": f"This personalized guide gives you a strategic advantage for your {role} interview at {company}. Focus your preparation on the priority areas identified, leverage your strengths, and demonstrate your learning mindset.",
+            "success_story_link": f"Read about someone who successfully landed a {role} role",
+            "learning_resource_link": f"Top {primary_gap} learning resources for interview prep",
+            "questions_practice_link": f"Practice {role} interview questions"
+        }
+    
+    def _get_timestamp(self) -> str:
+        """Get current timestamp"""
+        import datetime
+        return datetime.datetime.now().isoformat() 

micro/patch_missing.py

@@ -0,0 +1,169 @@
+import re
+import os
+from typing import Optional
+from text_extractor import JobCore
+from llm_client import google_search
+from metrics import log_metric
+
+
+def patch_missing(core: JobCore) -> JobCore:
+    """Patch missing fields in JobCore using Google search."""
+    
+    # Check if Google patching is enabled
+    if not os.getenv("GOOGLE_PATCH_ENABLED", "true").lower() in ["true", "1", "yes"]:
+        return core
+    
+    # Only patch if we have basic company info
+    if not core.company:
+        return core
+    
+    patches_applied = 0
+    
+    # Patch salary if missing
+    if not core.salary_low and not core.salary_high:
+        salary_info = _patch_salary(core.company, core.role)
+        if salary_info:
+            core.salary_low, core.salary_high = salary_info
+            core.source_map["salary"] = "google"
+            patches_applied += 1
+    
+    # Patch funding if missing
+    if not core.funding:
+        funding_info = _patch_funding(core.company)
+        if funding_info:
+            core.funding = funding_info
+            core.source_map["funding"] = "google"
+            patches_applied += 1
+    
+    # Patch mission if missing
+    if not core.mission:
+        mission_info = _patch_mission(core.company)
+        if mission_info:
+            core.mission = mission_info
+            core.source_map["mission"] = "google"
+            patches_applied += 1
+    
+    # Patch location if missing
+    if not core.location:
+        location_info = _patch_location(core.company)
+        if location_info:
+            core.location = location_info
+            core.source_map["location"] = "google"
+            patches_applied += 1
+    
+    log_metric("patch_missing", {
+        "company": core.company,
+        "patches_applied": patches_applied,
+        "source_map": core.source_map
+    })
+    
+    return core
+
+
+def _patch_salary(company: str, role: str) -> Optional[tuple[int, int]]:
+    """Search for salary information and extract range."""
+    if not company or not role:
+        return None
+    
+    query = f'"{company}" "{role}" salary range'
+    snippets = google_search(query, top=3, timeout=5)
+    
+    for snippet in snippets:
+        # Look for salary patterns like "$120k-$180k", "$150,000-$200,000"
+        salary_patterns = [
+            r'\$(\d+)k?[-–]\$?(\d+)k?',
+            r'\$(\d+),?(\d+)[-–]\$?(\d+),?(\d+)',
+            r'(\d+)k?[-–](\d+)k?\s*(?:per|/)?\s*year',
+        ]
+        
+        for pattern in salary_patterns:
+            match = re.search(pattern, snippet, re.IGNORECASE)
+            if match:
+                try:
+                    if 'k' in match.group(0).lower():
+                        low = int(match.group(1)) * 1000
+                        high = int(match.group(2)) * 1000
+                    else:
+                        low = int(match.group(1))
+                        high = int(match.group(2))
+                    
+                    # Sanity check: reasonable salary range
+                    if 30000 <= low <= 500000 and 30000 <= high <= 500000 and low < high:
+                        return (low, high)
+                except (ValueError, IndexError):
+                    continue
+    
+    return None
+
+
+def _patch_funding(company: str) -> Optional[str]:
+    """Search for funding information."""
+    if not company:
+        return None
+    
+    query = f'"{company}" funding round raised'
+    snippets = google_search(query, top=3, timeout=5)
+    
+    for snippet in snippets:
+        # Look for funding patterns
+        funding_patterns = [
+            r'raised \$(\d+(?:\.\d+)?[MB]?)',
+            r'Series [A-Z] \$(\d+(?:\.\d+)?[MB]?)',
+            r'\$(\d+(?:\.\d+)?[MB]?) (?:Series|round|funding)',
+            r'(\$\d+(?:\.\d+)?[MB]? (?:million|billion))',
+        ]
+        
+        for pattern in funding_patterns:
+            match = re.search(pattern, snippet, re.IGNORECASE)
+            if match:
+                return match.group(0)[:50]  # Limit length
+    
+    return None
+
+
+def _patch_mission(company: str) -> Optional[str]:
+    """Search for company mission/tagline."""
+    if not company:
+        return None
+    
+    query = f'"{company}" company mission tagline about'
+    snippets = google_search(query, top=3, timeout=5)
+    
+    for snippet in snippets:
+        # Look for mission-like sentences
+        sentences = re.split(r'[.!?]+', snippet)
+        for sentence in sentences:
+            sentence = sentence.strip()
+            # Look for sentences that describe what the company does
+            if (len(sentence) > 20 and len(sentence) < 200 and 
+                any(word in sentence.lower() for word in ['build', 'create', 'develop', 'provide', 'help', 'enable', 'platform'])):
+                return sentence
+    
+    return None
+
+
+def _patch_location(company: str) -> Optional[str]:
+    """Search for company headquarters location."""
+    if not company:
+        return None
+    
+    query = f'"{company}" headquarters location'
+    snippets = google_search(query, top=3, timeout=5)
+    
+    for snippet in snippets:
+        # Look for location patterns
+        location_patterns = [
+            r'([A-Z][a-z]+,\s*[A-Z]{2})',  # City, State
+            r'([A-Z][a-z]+\s+[A-Z][a-z]+,\s*[A-Z]{2})',  # City City, State
+            r'([A-Z][a-z]+,\s*[A-Z][a-z]+)',  # City, Country
+        ]
+        
+        for pattern in location_patterns:
+            match = re.search(pattern, snippet)
+            if match:
+                location = match.group(1).strip()
+                # Sanity check for common US locations
+                if any(state in location for state in ['CA', 'NY', 'WA', 'TX', 'MA']):
+                    return location
+    
+    return None 

micro/personalized_interview_guide.py

@@ -0,0 +1,755 @@
+"""
+Personalized Interview Guide Generator
+Uses advanced gap analysis to create truly personalized interview preparation content
+"""
+
+from typing import Any, Dict, List, Optional
+from llm_client import LLMClient
+from metrics import log_metric
+import json
+from dataclasses import dataclass, asdict
+
+@dataclass
+class InterviewQuestion:
+    question: str
+    category: str  # technical, behavioral, company, situational
+    difficulty: str  # easy, medium, hard
+    why_asked: str  # Why this question is relevant for this candidate
+    approach_strategy: str  # How to approach answering
+    example_points: List[str]  # Specific points from candidate's background to mention
+    follow_up_questions: List[str]  # Likely follow-up questions
+
+@dataclass
+class PersonalizedGuideSection:
+    title: str
+    content: str
+    why_important: str  # Why this section matters for this specific candidate
+    action_items: List[str]
+    time_to_complete: str
+
+@dataclass
+class PersonalizedInterviewGuide:
+    header: Dict[str, Any]  # Match score, company info, etc.
+    executive_summary: str
+    skills_analysis: Dict[str, Any]
+    interview_process: PersonalizedGuideSection
+    technical_questions: List[InterviewQuestion]
+    behavioral_questions: List[InterviewQuestion]
+    company_questions: List[InterviewQuestion]
+    preparation_strategy: PersonalizedGuideSection
+    talking_points: PersonalizedGuideSection
+    questions_to_ask: List[str]
+    day_of_preparation: PersonalizedGuideSection
+    success_metrics: List[str]
+
+class PersonalizedInterviewGuideGenerator:
+    """Generates truly personalized interview guides based on advanced gap analysis"""
+    
+    def __init__(self):
+        self.llm_client = LLMClient()
+    
+    async def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        resume_data = data.get("resume_data_enhanced", {})
+        job_data = data.get("job_data_enhanced", {})
+        gap_analysis = data.get("gap_analysis_advanced", {})
+        
+        if not all([resume_data, job_data, gap_analysis]):
+            return {**data, "personalized_guide": {"error": "Missing required data for personalized guide"}}
+        
+        try:
+            # Generate personalized interview guide
+            guide = await self._generate_personalized_guide(resume_data, job_data, gap_analysis)
+            
+            log_metric("personalized_guide_success", {
+                "overall_match_score": gap_analysis.get("overall_match_score", 0),
+                "technical_questions": len(guide.technical_questions),
+                "behavioral_questions": len(guide.behavioral_questions),
+                "total_action_items": sum(len(section.action_items) for section in [
+                    guide.preparation_strategy, guide.talking_points, guide.day_of_preparation
+                ])
+            })
+            
+            return {**data, "personalized_guide": asdict(guide)}
+            
+        except Exception as e:
+            log_metric("personalized_guide_error", {"error": str(e)})
+            return {**data, "personalized_guide": {"error": f"Personalized guide generation failed: {e}"}}
+    
+    async def _generate_personalized_guide(self, resume_data: Dict[str, Any], 
+                                         job_data: Dict[str, Any], 
+                                         gap_analysis: Dict[str, Any]) -> PersonalizedInterviewGuide:
+        """Generate the complete personalized interview guide"""
+        
+        # Extract key information
+        role = job_data.get("role", "Unknown Role")
+        company = job_data.get("company", "Unknown Company")
+        match_score = gap_analysis.get("overall_match_score", 0)
+        candidate_name = resume_data.get("personal_info", {}).get("name", "")
+        
+        # Generate header information
+        header = self._create_header(role, company, match_score, gap_analysis)
+        
+        # Generate executive summary
+        executive_summary = await self._generate_executive_summary(
+            resume_data, job_data, gap_analysis
+        )
+        
+        # Create skills analysis visualization
+        skills_analysis = self._create_skills_analysis(gap_analysis)
+        
+        # Generate personalized sections
+        interview_process = await self._generate_interview_process_section(
+            job_data, gap_analysis
+        )
+        
+        technical_questions = await self._generate_technical_questions(
+            job_data, gap_analysis, resume_data
+        )
+        
+        behavioral_questions = await self._generate_behavioral_questions(
+            job_data, resume_data, gap_analysis
+        )
+        
+        company_questions = await self._generate_company_questions(
+            job_data, gap_analysis
+        )
+        
+        preparation_strategy = await self._generate_preparation_strategy(
+            gap_analysis, job_data
+        )
+        
+        talking_points = await self._generate_talking_points(
+            resume_data, gap_analysis
+        )
+        
+        questions_to_ask = await self._generate_questions_to_ask(
+            job_data, gap_analysis
+        )
+        
+        day_of_preparation = await self._generate_day_of_preparation(
+            gap_analysis, job_data
+        )
+        
+        success_metrics = self._generate_success_metrics(gap_analysis)
+        
+        return PersonalizedInterviewGuide(
+            header=header,
+            executive_summary=executive_summary,
+            skills_analysis=skills_analysis,
+            interview_process=interview_process,
+            technical_questions=technical_questions,
+            behavioral_questions=behavioral_questions,
+            company_questions=company_questions,
+            preparation_strategy=preparation_strategy,
+            talking_points=talking_points,
+            questions_to_ask=questions_to_ask,
+            day_of_preparation=day_of_preparation,
+            success_metrics=success_metrics
+        )
+    
+    def _create_header(self, role: str, company: str, match_score: float, 
+                      gap_analysis: Dict[str, Any]) -> Dict[str, Any]:
+        """Create header with match visualization"""
+        
+        # Determine match level and color
+        if match_score >= 85:
+            match_level = "Excellent Match"
+            match_emoji = "🟢"
+        elif match_score >= 70:
+            match_level = "Strong Match"
+            match_emoji = "🟡"
+        elif match_score >= 55:
+            match_level = "Good Match"
+            match_emoji = "🟠"
+        else:
+            match_level = "Developing Match"
+            match_emoji = "🔴"
+        
+        strong_matches = len(gap_analysis.get("strong_matches", []))
+        missing_skills = len(gap_analysis.get("missing_skills", []))
+        
+        return {
+            "role": role,
+            "company": company,
+            "match_score": round(match_score, 1),
+            "match_level": match_level,
+            "match_emoji": match_emoji,
+            "strong_matches_count": strong_matches,
+            "missing_skills_count": missing_skills,
+            "total_requirements": gap_analysis.get("total_requirements", 0)
+        }
+    
+    async def _generate_executive_summary(self, resume_data: Dict[str, Any], 
+                                        job_data: Dict[str, Any], 
+                                        gap_analysis: Dict[str, Any]) -> str:
+        """Generate personalized executive summary"""
+        
+        role = job_data.get("role", "Unknown Role")
+        company = job_data.get("company", "Unknown Company")
+        match_score = gap_analysis.get("overall_match_score", 0)
+        years_exp = resume_data.get("years_of_experience", 0)
+        strengths = gap_analysis.get("strengths_summary", "")
+        gaps = gap_analysis.get("gaps_summary", "")
+        competitive_advantages = gap_analysis.get("competitive_advantages", [])
+        
+        prompt = f"""
+Write a personalized executive summary for an interview guide. This should sound like a knowledgeable mentor who has analyzed their specific background.
+
+Candidate Profile:
+- Years of experience: {years_exp}
+- Target role: {role} at {company}
+- Match score: {match_score}%
+- Strengths: {strengths}
+- Gaps to address: {gaps}
+- Competitive advantages: {', '.join(competitive_advantages[:3])}
+
+Guidelines:
+- Start with "{role} interview" in first 100 words
+- Address the candidate directly ("you")
+- Be specific about their unique position
+- Reference their actual background
+- Confident, mentor-like tone
+- 3-4 sentences max
+- Actionable and encouraging
+
+Example tone: "Your background in Python and machine learning puts you in a strong position for this Data Scientist role at TechCorp. With 5+ years of experience, you bring the technical depth they're seeking, and your AWS skills differentiate you from other candidates. Focus your preparation on demonstrating your model deployment experience and be ready to discuss your specific ML project outcomes."
+"""
+        
+        try:
+            return self.llm_client.call_llm(prompt, temperature=0.3, max_tokens=300)
+        except:
+            return f"You're well-positioned for this {role} role at {company} with a {match_score}% match score."
+    
+    def _create_skills_analysis(self, gap_analysis: Dict[str, Any]) -> Dict[str, Any]:
+        """Create visual skills analysis"""
+        
+        strong_matches = gap_analysis.get("strong_matches", [])
+        partial_matches = gap_analysis.get("partial_matches", [])
+        missing_skills = gap_analysis.get("missing_skills", [])
+        
+        # Create text-based visualization
+        skills_breakdown = {
+            "strong": [match.get("skill_name", "") for match in strong_matches[:8]],
+            "partial": [match.get("skill_name", "") for match in partial_matches[:6]],
+            "missing": [match.get("skill_name", "") for match in missing_skills[:6]]
+        }
+        
+        # Generate bar chart representation
+        total_skills = len(strong_matches) + len(partial_matches) + len(missing_skills)
+        
+        if total_skills > 0:
+            strong_percentage = len(strong_matches) / total_skills * 100
+            partial_percentage = len(partial_matches) / total_skills * 100
+            missing_percentage = len(missing_skills) / total_skills * 100
+        else:
+            strong_percentage = partial_percentage = missing_percentage = 0
+        
+        return {
+            "skills_breakdown": skills_breakdown,
+            "percentages": {
+                "strong": round(strong_percentage, 1),
+                "partial": round(partial_percentage, 1),
+                "missing": round(missing_percentage, 1)
+            },
+            "summary": gap_analysis.get("strengths_summary", ""),
+            "categories_analysis": gap_analysis.get("skill_categories_analysis", {})
+        }
+    
+    async def _generate_interview_process_section(self, job_data: Dict[str, Any], 
+                                                gap_analysis: Dict[str, Any]) -> PersonalizedGuideSection:
+        """Generate personalized interview process section"""
+        
+        company = job_data.get("company", "Unknown Company")
+        role = job_data.get("role", "Unknown Role")
+        seniority = job_data.get("seniority_level", "mid")
+        company_stage = job_data.get("company_stage", "enterprise")
+        match_score = gap_analysis.get("overall_match_score", 0)
+        
+        prompt = f"""
+Describe the likely interview process for a {role} position at {company} ({company_stage} company, {seniority} level).
+
+Context:
+- Candidate match score: {match_score}%
+- Company stage: {company_stage}
+- Role level: {seniority}
+
+Include:
+1. Typical number of rounds
+2. Types of interviews expected
+3. Key stakeholders they'll meet
+4. Timeline and logistics
+5. Company-specific insights if available
+6. What to expect given their match score
+
+Keep it practical and specific. Use markdown formatting.
+Max 250 words.
+"""
+        
+        try:
+            content = self.llm_client.call_llm(prompt, temperature=0, max_tokens=400)
+        except:
+            content = f"Typical {role} interviews include 3-4 rounds: phone screen, technical assessment, team interviews, and final round."
+        
+        why_important = f"Understanding {company}'s process helps you prepare appropriately for each stage and set proper expectations."
+        
+        action_items = [
+            f"Research {company}'s interview style on Glassdoor",
+            "Prepare for technical screening",
+            "Ready examples for behavioral questions",
+            "Prepare thoughtful questions for each interviewer"
+        ]
+        
+        return PersonalizedGuideSection(
+            title="Interview Process",
+            content=content,
+            why_important=why_important,
+            action_items=action_items,
+            time_to_complete="30 minutes research"
+        )
+    
+    async def _generate_technical_questions(self, job_data: Dict[str, Any], 
+                                          gap_analysis: Dict[str, Any], 
+                                          resume_data: Dict[str, Any]) -> List[InterviewQuestion]:
+        """Generate personalized technical questions"""
+        
+        strong_matches = gap_analysis.get("strong_matches", [])
+        missing_skills = gap_analysis.get("missing_skills", [])
+        role = job_data.get("role", "Unknown Role")
+        
+        # Focus on areas where candidate has gaps or needs to demonstrate strength
+        focus_areas = []
+        
+        # Add strong areas to showcase
+        for match in strong_matches[:3]:
+            focus_areas.append({
+                "skill": match.get("skill_name", ""),
+                "type": "strength",
+                "context": f"Highlight your {match.get('skill_name', '')} expertise"
+            })
+        
+        # Add gap areas they need to address
+        for match in missing_skills[:3]:
+            if match.get("importance") == "required":
+                focus_areas.append({
+                    "skill": match.get("skill_name", ""),
+                    "type": "gap",
+                    "context": f"Be prepared for basic {match.get('skill_name', '')} questions"
+                })
+        
+        questions = []
+        
+        for area in focus_areas[:6]:  # Limit to 6 technical questions
+            question = await self._generate_single_technical_question(
+                area, role, resume_data
+            )
+            if question:
+                questions.append(question)
+        
+        return questions
+    
+    async def _generate_single_technical_question(self, focus_area: Dict[str, Any], 
+                                                role: str, resume_data: Dict[str, Any]) -> Optional[InterviewQuestion]:
+        """Generate a single personalized technical question"""
+        
+        skill = focus_area["skill"]
+        area_type = focus_area["type"]
+        
+        # Get candidate's relevant experience
+        relevant_projects = []
+        for project in resume_data.get("projects", []):
+            if isinstance(project, dict):
+                if skill.lower() in str(project.get("technologies", [])).lower():
+                    relevant_projects.append(project.get("name", ""))
+        
+        # Get relevant work experience
+        relevant_experience = []
+        for exp in resume_data.get("experience", []):
+            if isinstance(exp, dict):
+                if skill.lower() in str(exp.get("technologies", [])).lower():
+                    relevant_experience.append(exp.get("title", ""))
+        
+        prompt = f"""
+Generate a technical interview question for a {role} position focusing on {skill}.
+
+Context:
+- Question type: {"showcase strength" if area_type == "strength" else "assess knowledge"}
+- Candidate has {skill} in: {', '.join(relevant_projects + relevant_experience) or 'limited context'}
+- This should be {"medium-hard" if area_type == "strength" else "easy-medium"} difficulty
+
+Return JSON:
+{{
+  "question": "Specific technical question",
+  "difficulty": "easy|medium|hard",
+  "why_asked": "Why this matters for this candidate specifically",
+  "approach_strategy": "How candidate should approach answering",
+  "example_points": ["Specific points from their background to mention"],
+  "follow_up_questions": ["Likely follow-up questions"]
+}}
+
+Make it specific to their background and the role.
+"""
+        
+        try:
+            response = self.llm_client.call_llm(prompt, temperature=0.3, max_tokens=600)
+            
+            # Parse JSON response
+            json_start = response.find('{')
+            json_end = response.rfind('}') + 1
+            if json_start != -1 and json_end > json_start:
+                data = json.loads(response[json_start:json_end])
+                
+                return InterviewQuestion(
+                    question=data.get("question", ""),
+                    category="technical",
+                    difficulty=data.get("difficulty", "medium"),
+                    why_asked=data.get("why_asked", ""),
+                    approach_strategy=data.get("approach_strategy", ""),
+                    example_points=data.get("example_points", []),
+                    follow_up_questions=data.get("follow_up_questions", [])
+                )
+        except:
+            pass
+        
+        return None
+    
+    async def _generate_behavioral_questions(self, job_data: Dict[str, Any], 
+                                           resume_data: Dict[str, Any], 
+                                           gap_analysis: Dict[str, Any]) -> List[InterviewQuestion]:
+        """Generate personalized behavioral questions"""
+        
+        role = job_data.get("role", "Unknown Role")
+        company_stage = job_data.get("company_stage", "enterprise")
+        years_exp = resume_data.get("years_of_experience", 0)
+        
+        # Generate questions based on candidate's background and role requirements
+        behavioral_focus = []
+        
+        if years_exp < 3:
+            behavioral_focus.extend(["learning agility", "collaboration", "problem-solving"])
+        elif years_exp >= 5:
+            behavioral_focus.extend(["leadership", "mentoring", "conflict resolution"])
+        else:
+            behavioral_focus.extend(["project management", "cross-functional collaboration", "initiative"])
+        
+        if company_stage == "startup":
+            behavioral_focus.append("adaptability")
+        elif company_stage == "enterprise":
+            behavioral_focus.append("process improvement")
+        
+        questions = []
+        
+        for focus in behavioral_focus[:4]:  # Limit to 4 behavioral questions
+            question = await self._generate_single_behavioral_question(
+                focus, role, resume_data
+            )
+            if question:
+                questions.append(question)
+        
+        return questions
+    
+    async def _generate_single_behavioral_question(self, focus_area: str, role: str, 
+                                                 resume_data: Dict[str, Any]) -> Optional[InterviewQuestion]:
+        """Generate a single personalized behavioral question"""
+        
+        # Get relevant experience for this behavioral area
+        recent_roles = []
+        for exp in resume_data.get("experience", [])[:2]:  # Last 2 roles
+            if isinstance(exp, dict):
+                recent_roles.append({
+                    "title": exp.get("title", ""),
+                    "company": exp.get("company", ""),
+                    "achievements": exp.get("achievements", [])
+                })
+        
+        prompt = f"""
+Generate a behavioral interview question for a {role} position focusing on {focus_area}.
+
+Candidate context:
+- Recent roles: {', '.join([r['title'] for r in recent_roles])}
+- Key achievements: {', '.join([ach for role in recent_roles for ach in role.get('achievements', [])[:2]])}
+
+Return JSON:
+{{
+  "question": "STAR-format behavioral question",
+  "difficulty": "medium",
+  "why_asked": "Why this matters for this specific candidate and role",
+  "approach_strategy": "How to structure the STAR response",
+  "example_points": ["Specific experiences from their background to reference"],
+  "follow_up_questions": ["Likely follow-up questions"]
+}}
+
+Make the question specific and give them concrete examples from their background to use.
+"""
+        
+        try:
+            response = self.llm_client.call_llm(prompt, temperature=0.3, max_tokens=600)
+            
+            json_start = response.find('{')
+            json_end = response.rfind('}') + 1
+            if json_start != -1 and json_end > json_start:
+                data = json.loads(response[json_start:json_end])
+                
+                return InterviewQuestion(
+                    question=data.get("question", ""),
+                    category="behavioral",
+                    difficulty=data.get("difficulty", "medium"),
+                    why_asked=data.get("why_asked", ""),
+                    approach_strategy=data.get("approach_strategy", ""),
+                    example_points=data.get("example_points", []),
+                    follow_up_questions=data.get("follow_up_questions", [])
+                )
+        except:
+            pass
+        
+        return None
+    
+    async def _generate_company_questions(self, job_data: Dict[str, Any], 
+                                        gap_analysis: Dict[str, Any]) -> List[InterviewQuestion]:
+        """Generate company-specific questions"""
+        
+        company = job_data.get("company", "Unknown Company")
+        role = job_data.get("role", "Unknown Role")
+        company_stage = job_data.get("company_stage", "enterprise")
+        
+        questions = []
+        
+        # Generate 2-3 company-specific questions
+        for topic in ["company culture", "role challenges", "team dynamics"][:3]:
+            question = await self._generate_single_company_question(
+                topic, company, role, company_stage
+            )
+            if question:
+                questions.append(question)
+        
+        return questions
+    
+    async def _generate_single_company_question(self, topic: str, company: str, 
+                                              role: str, stage: str) -> Optional[InterviewQuestion]:
+        """Generate a single company-specific question"""
+        
+        prompt = f"""
+Generate a company-specific interview question about {topic} for {role} at {company} ({stage} company).
+
+Return JSON:
+{{
+  "question": "Company-specific question they might ask",
+  "difficulty": "medium",
+  "why_asked": "Why this company asks this question",
+  "approach_strategy": "How to answer effectively",
+  "example_points": ["Key points to include in answer"],
+  "follow_up_questions": ["Likely follow-up questions"]
+}}
+
+Make it specific to the company stage and role.
+"""
+        
+        try:
+            response = self.llm_client.call_llm(prompt, temperature=0.3, max_tokens=500)
+            
+            json_start = response.find('{')
+            json_end = response.rfind('}') + 1
+            if json_start != -1 and json_end > json_start:
+                data = json.loads(response[json_start:json_end])
+                
+                return InterviewQuestion(
+                    question=data.get("question", ""),
+                    category="company",
+                    difficulty=data.get("difficulty", "medium"),
+                    why_asked=data.get("why_asked", ""),
+                    approach_strategy=data.get("approach_strategy", ""),
+                    example_points=data.get("example_points", []),
+                    follow_up_questions=data.get("follow_up_questions", [])
+                )
+        except:
+            pass
+        
+        return None
+    
+    async def _generate_preparation_strategy(self, gap_analysis: Dict[str, Any], 
+                                           job_data: Dict[str, Any]) -> PersonalizedGuideSection:
+        """Generate personalized preparation strategy"""
+        
+        priority_items = gap_analysis.get("preparation_priority", [])
+        missing_skills = gap_analysis.get("missing_skills", [])
+        match_score = gap_analysis.get("overall_match_score", 0)
+        
+        strategy_content = f"""
+## Your Preparation Roadmap
+
+Based on your {match_score}% match score, here's your personalized preparation strategy:
+
+### Immediate Priorities (Next 2-3 Days)
+{chr(10).join([f'- {item}' for item in priority_items[:3]])}
+
+        ### This Week
+{chr(10).join([f'- Review {skill.get("job_requirement", skill.get("skill_name", ""))} basics' for skill in missing_skills[:3] if skill.get("importance") == "required" and (skill.get("job_requirement") or skill.get("skill_name"))])}
+
+### Study Schedule
+- **Technical prep**: 60% of time on gap areas
+- **Behavioral prep**: 25% of time on STAR examples  
+- **Company research**: 15% of time on culture/mission
+"""
+        
+        why_important = f"This targeted approach maximizes your preparation time by focusing on your specific gaps and strengths."
+        
+        action_items = [
+            "Complete priority technical reviews",
+            "Prepare 5-7 STAR behavioral examples",
+            "Practice explaining your project experiences",
+            "Research company's recent news and developments"
+        ]
+        
+        return PersonalizedGuideSection(
+            title="Preparation Strategy",
+            content=strategy_content,
+            why_important=why_important,
+            action_items=action_items,
+            time_to_complete="5-7 hours over 3-5 days"
+        )
+    
+    async def _generate_talking_points(self, resume_data: Dict[str, Any], 
+                                     gap_analysis: Dict[str, Any]) -> PersonalizedGuideSection:
+        """Generate personalized talking points from resume"""
+        
+        strong_matches = gap_analysis.get("strong_matches", [])
+        competitive_advantages = gap_analysis.get("competitive_advantages", [])
+        
+        # Extract key achievements
+        key_achievements = []
+        for exp in resume_data.get("experience", [])[:2]:
+            if isinstance(exp, dict):
+                achievements = exp.get("achievements", [])[:2]
+                key_achievements.extend(achievements)
+        
+        # Extract notable projects
+        notable_projects = []
+        for project in resume_data.get("projects", [])[:3]:
+            if isinstance(project, dict):
+                notable_projects.append({
+                    "name": project.get("name", ""),
+                    "description": project.get("description", ""),
+                    "technologies": project.get("technologies", [])
+                })
+        
+        content = f"""
+## Your Key Talking Points
+
+### Lead with Your Strengths
+{chr(10).join([f'- **{match.get("resume_skill", match.get("job_requirement", ""))}**: Highlight your {match.get("resume_skill", "")} experience' for match in strong_matches[:3] if match.get("resume_skill") or match.get("job_requirement")])}
+
+### Competitive Advantages
+{chr(10).join([f'- {advantage}' for advantage in competitive_advantages[:3]])}
+
+### Project Highlights
+{chr(10).join([f'- **{proj["name"]}**: {proj["description"][:100]}...' for proj in notable_projects[:3] if proj.get("name") and proj.get("description")])}
+
+### Achievement Examples
+{chr(10).join([f'- {achievement[:100]}...' for achievement in key_achievements[:3] if achievement])}
+"""
+        
+        why_important = "These talking points are directly pulled from your background and align with what this role values most."
+        
+        action_items = [
+            "Practice describing each project in 2-3 minutes",
+            "Quantify achievements with specific numbers",
+            "Prepare follow-up details for each talking point",
+            "Connect each point back to the role requirements"
+        ]
+        
+        return PersonalizedGuideSection(
+            title="Key Talking Points",
+            content=content,
+            why_important=why_important,
+            action_items=action_items,
+            time_to_complete="2 hours preparation"
+        )
+    
+    async def _generate_questions_to_ask(self, job_data: Dict[str, Any], 
+                                       gap_analysis: Dict[str, Any]) -> List[str]:
+        """Generate smart questions for the candidate to ask"""
+        
+        company = job_data.get("company", "Unknown Company")
+        role = job_data.get("role", "Unknown Role")
+        company_stage = job_data.get("company_stage", "enterprise")
+        missing_skills = gap_analysis.get("missing_skills", [])
+        
+        questions = [
+            f"What does success look like for a {role} in the first 90 days?",
+            f"How does the team approach professional development and learning?",
+            f"What are the biggest technical challenges facing the team right now?",
+            f"How does {company} support career growth for {role}s?",
+            f"What's the collaboration like between {role} and other teams?"
+        ]
+        
+        # Add questions about learning opportunities for missing skills
+        if missing_skills:
+            skill_names = [skill.get("job_requirement", skill.get("skill_name", "")) for skill in missing_skills[:2] if skill.get("job_requirement") or skill.get("skill_name")]
+            if skill_names:
+                questions.append(f"Are there opportunities to develop skills in {', '.join(skill_names)}?")
+        
+        return questions[:6]
+    
+    async def _generate_day_of_preparation(self, gap_analysis: Dict[str, Any], 
+                                         job_data: Dict[str, Any]) -> PersonalizedGuideSection:
+        """Generate day-of interview preparation"""
+        
+        match_score = gap_analysis.get("overall_match_score", 0)
+        strong_matches = gap_analysis.get("strong_matches", [])
+        
+        content = f"""
+## Day-of-Interview Checklist
+
+### Morning Review (30 minutes)
+- Review your top 3 strengths: {', '.join([m.get('resume_skill', m.get('job_requirement', '')) for m in strong_matches[:3] if m.get('resume_skill') or m.get('job_requirement')])}
+- Practice your 2-minute elevator pitch
+- Review company's recent news/updates
+- Check logistics (time, location, interviewer names)
+
+### Mental Preparation
+- Confidence booster: You have a {match_score}% match score
+- Remember your competitive advantages
+- Focus on learning and growth mindset for any gaps
+
+### Final Reminders
+- Bring copies of resume and portfolio
+- Prepare notepad for notes and questions
+- Arrive 10 minutes early
+- Dress appropriately for company culture
+"""
+        
+        why_important = "Last-minute preparation builds confidence and ensures you're mentally ready to showcase your best self."
+        
+        action_items = [
+            "Set up outfit and materials the night before",
+            "Do a practice run of your travel route",
+            "Review your talking points one final time",
+            "Get good sleep and eat a proper breakfast"
+        ]
+        
+        return PersonalizedGuideSection(
+            title="Day-of Preparation",
+            content=content,
+            why_important=why_important,
+            action_items=action_items,
+            time_to_complete="30 minutes morning of"
+        )
+    
+    def _generate_success_metrics(self, gap_analysis: Dict[str, Any]) -> List[str]:
+        """Generate success metrics for the interview"""
+        
+        match_score = gap_analysis.get("overall_match_score", 0)
+        strong_matches = len(gap_analysis.get("strong_matches", []))
+        
+        metrics = [
+            f"Successfully demonstrate {strong_matches} core strengths",
+            "Ask 3-4 thoughtful questions about the role/team",
+            "Share specific examples from your background",
+            "Show enthusiasm for learning and growth"
+        ]
+        
+        if match_score >= 70:
+            metrics.append("Position yourself as a strong candidate ready to contribute immediately")
+        else:
+            metrics.append("Show strong learning agility and potential for growth")
+        
+        return metrics 

micro/qa.py

@@ -0,0 +1,92 @@
+from typing import Any, Dict
+from llm_client import llm_client
+from prompt_loader import prompt_loader
+from metrics import log_metric
+
+class QAMicroFunction:
+    def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        draft = data.get("draft", "")
+        enriched_data = data.get("enriched", {})
+        
+        if not draft or "failed" in draft.lower():
+            return {**data, "qa_result": "QA skipped due to draft errors."}
+        
+        try:
+            # Use LLM to perform quality assurance
+            prompt = prompt_loader.get_prompt("qa_prompt", draft=draft)
+            
+            qa_prompt = prompt + f"""
+
+Review this job role preview and interview kit for:
+
+1. **Accuracy**: Does the content match the job data?
+2. **Completeness**: Are all sections well-developed?
+3. **Clarity**: Is the language clear and actionable?
+4. **Formatting**: Is the markdown properly structured?
+5. **Relevance**: Is the advice practical and current?
+
+Job data context: {enriched_data}
+
+Content to review:
+{draft}
+
+Provide feedback in this format:
+## QA Results
+- **Overall Quality**: [Pass/Needs Improvement/Fail]
+- **Issues Found**: [List specific issues or "None"]
+- **Suggestions**: [Improvement recommendations]
+- **Auto-fixes Applied**: [Any corrections made]
+
+If minor issues are found, provide the corrected version after your analysis.
+"""
+            
+            qa_response = llm_client.call_llm(qa_prompt)
+            
+            # Add bucket verification
+            bucket_markdown = data.get("bucket_markdown", "")
+            
+            if bucket_markdown:
+                required_headers = [
+                    "### Team & Manager",
+                    "### Tech Stack Snapshot", 
+                    "### Business Context",
+                    "### Comp & Leveling",
+                    "### Career Trajectory",
+                    "### Culture/WLB",
+                    "### Interview Runway",
+                    "### Onboarding & Tooling",
+                    "### Location/Remote",
+                    "### Strategic Risks"
+                ]
+                
+                missing_headers = []
+                for header in required_headers:
+                    if header not in bucket_markdown:
+                        missing_headers.append(header)
+                
+                if missing_headers:
+                    log_metric("qa_grade", {"bucket_verification": "FAIL", "missing": missing_headers})
+                    qa_response += f"\n\n**BUCKET VERIFICATION FAILED**: Missing headers: {missing_headers}"
+                else:
+                    log_metric("qa_grade", {"bucket_verification": "PASS"})
+                    qa_response += f"\n\n**BUCKET VERIFICATION PASSED**: All 10 bucket headers present"
+            
+            # Check if auto-fixes were applied
+            if "corrected version" in qa_response.lower() or "auto-fixes applied" in qa_response.lower():
+                # Extract corrected content if available
+                parts = qa_response.split("## Corrected Version")
+                if len(parts) > 1:
+                    corrected_draft = parts[1].strip()
+                    data["draft"] = corrected_draft
+                    log_metric("qa_auto_fix", {"fixes_applied": True})
+            
+            log_metric("qa_success", {
+                "content_length": len(draft),
+                "qa_response_length": len(qa_response)
+            })
+            
+            return {**data, "qa_result": qa_response}
+            
+        except Exception as e:
+            log_metric("qa_error", {"error": str(e)})
+            return {**data, "qa_result": f"QA failed: {e}"} 

micro/render.py

@@ -0,0 +1,123 @@
+from typing import Any, Dict, Optional
+from metrics import log_metric
+
+class RenderMicroFunction:
+    def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        draft = data.get("draft", "")
+        qa_result = data.get("qa_result", "")
+        critique = data.get("critique", "")
+        enriched_data = data.get("enriched", {})
+        quality_score = data.get("quality_score")
+        
+        try:
+            # Create comprehensive markdown output
+            rendered = self._create_final_output(draft, qa_result, critique, enriched_data, quality_score)
+            
+            # Add bucket processing
+            bucket_facts = data.get("bucket_facts", {})
+            bucket_markdown = ""
+            if bucket_facts:
+                from bucket_map import map_facts
+                from render_buckets import render_buckets
+                
+                buckets = map_facts(bucket_facts)
+                bucket_markdown = render_buckets(bucket_facts, buckets)
+                
+                log_metric("bucket_missing", {
+                    "empty_buckets": len([k for k, v in buckets.items() if not v or (len(v) == 1 and "research needed" in v[0].lower())])
+                })
+            
+            log_metric("render_success", {
+                "total_length": len(rendered),
+                "has_qa": bool(qa_result),
+                "has_critique": bool(critique),
+                "quality_score": quality_score,
+                "has_buckets": bool(bucket_markdown)
+            })
+            
+            return {**data, "rendered_markdown": rendered, "bucket_markdown": bucket_markdown}
+            
+        except Exception as e:
+            log_metric("render_error", {"error": str(e)})
+            fallback = f"# Job Analysis Results\n\n{draft}\n\n---\n\nQA: {qa_result}\n\nCritique: {critique}"
+            return {**data, "rendered_markdown": fallback, "bucket_markdown": ""}
+    
+    def _create_final_output(self, draft: str, qa_result: str, critique: str, enriched_data: Dict, quality_score: Optional[float] = None) -> str:
+        """Create comprehensive final output"""
+        
+        # Header with quality indicator
+        quality_indicator = ""
+        if quality_score:
+            if quality_score >= 8:
+                quality_indicator = "🟢 High Quality"
+            elif quality_score >= 6:
+                quality_indicator = "🟡 Good Quality"
+            else:
+                quality_indicator = "🔴 Needs Improvement"
+        
+        # Extract key job info for header
+        role = enriched_data.get("role", "Unknown Role")
+        company = enriched_data.get("company", "Unknown Company")
+        level = enriched_data.get("level", "")
+        
+        header = f"""# 🎯 {role} at {company}
+{f"**Level**: {level}" if level else ""}
+{f"**Quality**: {quality_indicator}" if quality_indicator else ""}
+
+---
+"""
+        
+        # Main content (the draft)
+        main_content = draft if draft else "Content generation failed."
+        
+        # QA and Critique sections (collapsible)
+        qa_section = ""
+        if qa_result and qa_result != "QA skipped due to draft errors.":
+            qa_section = f"""
+
+<details>
+<summary>📋 Quality Assurance Results</summary>
+
+{qa_result}
+
+</details>
+"""
+        
+        critique_section = ""
+        if critique and critique != "Critique skipped due to draft errors.":
+            critique_section = f"""
+
+<details>
+<summary>🔍 Expert Critique</summary>
+
+{critique}
+
+</details>
+"""
+        
+        # Footer with metadata
+        tech_stack = enriched_data.get("tech_stack", [])
+        work_mode = enriched_data.get("work_mode", "")
+        salary_range = enriched_data.get("salary_range", "")
+        
+        metadata = []
+        if tech_stack:
+            metadata.append(f"**Tech Stack**: {', '.join(tech_stack[:5])}")
+        if work_mode:
+            metadata.append(f"**Work Mode**: {work_mode}")
+        if salary_range and salary_range != "Not specified":
+            metadata.append(f"**Salary**: {salary_range}")
+        
+        footer = ""
+        if metadata:
+            footer = f"""
+
+---
+## 📊 Quick Facts
+{chr(10).join([f"- {item}" for item in metadata])}
+"""
+        
+        # Combine all sections
+        final_output = header + main_content + qa_section + critique_section + footer
+        
+        return final_output 

micro/resume_parser.py

@@ -0,0 +1,163 @@
+from typing import Any, Dict, List, Optional
+import re
+from llm_client import llm_client
+from prompt_loader import prompt_loader
+from metrics import log_metric
+from text_extractor import extract_nobs, robust_json_parse
+
+class ResumeParserMicroFunction:
+    async def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        resume_text = data.get("resume_text", "")
+        
+        if not resume_text:
+            return {**data, "resume_data": {"error": "No resume content provided"}}
+        
+        try:
+            # Extract structured resume data
+            resume_data = await self._extract_resume_data(resume_text)
+            
+            log_metric("resume_parse_success", {
+                "skills_count": len(resume_data.get("skills", {}).get("technical", [])),
+                "experience_count": len(resume_data.get("experience", [])),
+                "projects_count": len(resume_data.get("projects", []))
+            })
+            
+            return {**data, "resume_data": resume_data}
+            
+        except Exception as e:
+            log_metric("resume_parse_error", {"error": str(e)})
+            return {**data, "resume_data": {"error": f"Resume parsing failed: {e}"}}
+    
+    async def _extract_resume_data(self, resume_text: str) -> Dict[str, Any]:
+        """Extract structured data from resume using LLM"""
+        
+        # Use robust extraction for large resumes
+        structured_data = await extract_nobs(resume_text)
+        
+        if not structured_data or "error" in structured_data:
+            # Fallback to basic LLM extraction
+            prompt = f"""
+Extract structured data from this resume:
+
+{resume_text}
+
+Return JSON with:
+{{
+  "personal_info": {{
+    "name": "string",
+    "email": "string", 
+    "phone": "string",
+    "location": "string",
+    "linkedin": "string",
+    "github": "string"
+  }},
+  "summary": "professional summary/objective",
+  "skills": {{
+    "technical": ["skill1", "skill2"],
+    "programming_languages": ["Python", "JavaScript"],
+    "frameworks": ["React", "Django"],
+    "tools": ["Git", "Docker"],
+    "databases": ["PostgreSQL", "MongoDB"],
+    "cloud": ["AWS", "Azure"]
+  }},
+  "experience": [
+    {{
+      "title": "Job Title",
+      "company": "Company Name",
+      "duration": "Jan 2020 - Present",
+      "location": "City, State",
+      "responsibilities": ["bullet point 1", "bullet point 2"],
+      "achievements": ["achievement 1", "achievement 2"],
+      "technologies": ["tech1", "tech2"]
+    }}
+  ],
+  "education": [
+    {{
+      "degree": "Bachelor of Science",
+      "field": "Computer Science", 
+      "school": "University Name",
+      "graduation": "2020",
+      "gpa": "3.8",
+      "relevant_courses": ["Data Structures", "Algorithms"]
+    }}
+  ],
+  "projects": [
+    {{
+      "name": "Project Name",
+      "description": "Brief description",
+      "technologies": ["tech1", "tech2"],
+      "github": "github.com/repo",
+      "demo": "live-demo-url"
+    }}
+  ],
+  "certifications": [
+    {{
+      "name": "Certification Name",
+      "issuer": "Organization",
+      "date": "2023",
+      "credential_id": "123456"
+    }}
+  ]
+}}
+
+Only return valid JSON, no extra text.
+"""
+            
+            llm_response = llm_client.call_llm(prompt)
+            
+            # Parse JSON response
+            try:
+                resume_data = robust_json_parse(llm_response)
+                if not resume_data:
+                    raise ValueError("No valid JSON returned")
+                return resume_data
+            except Exception as e:
+                log_metric("resume_llm_parse_error", {"error": str(e)})
+                # Return basic extracted data as fallback
+                return self._basic_extraction(resume_text)
+        
+        return structured_data
+    
+    def _basic_extraction(self, resume_text: str) -> Dict[str, Any]:
+        """Basic regex-based extraction as fallback"""
+        
+        # Extract email
+        email_match = re.search(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', resume_text)
+        email = email_match.group() if email_match else ""
+        
+        # Extract phone
+        phone_match = re.search(r'(\+?1[-.\s]?)?\(?([0-9]{3})\)?[-.\s]?([0-9]{3})[-.\s]?([0-9]{4})', resume_text)
+        phone = phone_match.group() if phone_match else ""
+        
+        # Extract GitHub
+        github_match = re.search(r'github\.com/[\w-]+', resume_text, re.IGNORECASE)
+        github = f"https://{github_match.group()}" if github_match else ""
+        
+        # Extract LinkedIn
+        linkedin_match = re.search(r'linkedin\.com/in/[\w-]+', resume_text, re.IGNORECASE)
+        linkedin = f"https://{linkedin_match.group()}" if linkedin_match else ""
+        
+        # Extract common technical skills
+        tech_keywords = [
+            'Python', 'JavaScript', 'Java', 'C++', 'React', 'Node.js', 'SQL', 
+            'AWS', 'Docker', 'Git', 'Machine Learning', 'Data Science',
+            'TensorFlow', 'PyTorch', 'Pandas', 'NumPy', 'Django', 'Flask'
+        ]
+        
+        found_skills = []
+        for skill in tech_keywords:
+            if re.search(rf'\b{re.escape(skill)}\b', resume_text, re.IGNORECASE):
+                found_skills.append(skill)
+        
+        return {
+            "personal_info": {
+                "email": email,
+                "phone": phone,
+                "github": github,
+                "linkedin": linkedin
+            },
+            "skills": {
+                "technical": found_skills
+            },
+            "extraction_method": "basic_fallback"
+        } 

micro/resume_parser_v2.py

@@ -0,0 +1,620 @@
+"""
+Enhanced Resume Parser v2.0
+Provides structured extraction of skills, experience, projects, and education
+with proper normalization and context understanding.
+"""
+
+from typing import Any, Dict, List, Optional, Set, Tuple
+import re
+import json
+from dataclasses import dataclass, asdict
+from llm_client import llm_client
+from metrics import log_metric
+import tiktoken
+
+@dataclass
+class Experience:
+    title: str
+    company: str
+    duration: str
+    location: str = ""
+    responsibilities: List[str] = None
+    achievements: List[str] = None
+    technologies: List[str] = None
+    start_date: str = ""
+    end_date: str = ""
+    is_current: bool = False
+    
+    def __post_init__(self):
+        if self.responsibilities is None:
+            self.responsibilities = []
+        if self.achievements is None:
+            self.achievements = []
+        if self.technologies is None:
+            self.technologies = []
+
+@dataclass
+class Project:
+    name: str
+    description: str
+    technologies: List[str] = None
+    github_url: str = ""
+    demo_url: str = ""
+    duration: str = ""
+    key_features: List[str] = None
+    
+    def __post_init__(self):
+        if self.technologies is None:
+            self.technologies = []
+        if self.key_features is None:
+            self.key_features = []
+
+@dataclass
+class Education:
+    degree: str
+    field: str
+    school: str
+    graduation_year: str = ""
+    gpa: str = ""
+    relevant_courses: List[str] = None
+    honors: List[str] = None
+    
+    def __post_init__(self):
+        if self.relevant_courses is None:
+            self.relevant_courses = []
+        if self.honors is None:
+            self.honors = []
+
+@dataclass
+class Skills:
+    technical: List[str] = None
+    programming_languages: List[str] = None
+    frameworks: List[str] = None
+    tools: List[str] = None
+    databases: List[str] = None
+    cloud_platforms: List[str] = None
+    methodologies: List[str] = None
+    soft_skills: List[str] = None
+    
+    def __post_init__(self):
+        for field in ['technical', 'programming_languages', 'frameworks', 'tools', 
+                      'databases', 'cloud_platforms', 'methodologies', 'soft_skills']:
+            if getattr(self, field) is None:
+                setattr(self, field, [])
+
+@dataclass
+class ResumeData:
+    personal_info: Dict[str, str]
+    summary: str
+    skills: Skills
+    experience: List[Experience]
+    education: List[Education]
+    projects: List[Project]
+    certifications: List[Dict[str, str]]
+    languages: List[str]
+    years_of_experience: int = 0
+    
+    def __post_init__(self):
+        if not self.certifications:
+            self.certifications = []
+        if not self.languages:
+            self.languages = []
+
+class SkillsNormalizer:
+    """Normalizes and categorizes skills with synonym detection"""
+    
+    def __init__(self):
+        self.skill_synonyms = {
+            # Programming Languages
+            "python": ["python", "python3", "python 3", "py"],
+            "javascript": ["javascript", "js", "node.js", "nodejs", "node js"],
+            "typescript": ["typescript", "ts"],
+            "java": ["java", "java 8", "java 11", "java 17"],
+            "csharp": ["c#", "csharp", "c sharp", ".net", "dotnet"],
+            "cpp": ["c++", "cpp", "c plus plus"],
+            "go": ["go", "golang"],
+            "rust": ["rust", "rust-lang"],
+            "swift": ["swift", "ios development"],
+            "kotlin": ["kotlin", "android development"],
+            "r": ["r", "r programming"],
+            "scala": ["scala"],
+            "php": ["php", "php 7", "php 8"],
+            "ruby": ["ruby", "ruby on rails", "ror"],
+            
+            # Web Frameworks
+            "react": ["react", "reactjs", "react.js", "react js"],
+            "angular": ["angular", "angularjs", "angular 2+"],
+            "vue": ["vue", "vue.js", "vuejs", "vue js"],
+            "svelte": ["svelte", "sveltekit"],
+            "django": ["django", "django rest framework", "drf"],
+            "flask": ["flask", "flask-restful"],
+            "fastapi": ["fastapi", "fast api"],
+            "express": ["express", "express.js", "expressjs"],
+            "spring": ["spring", "spring boot", "spring framework"],
+            "laravel": ["laravel"],
+            "rails": ["rails", "ruby on rails", "ror"],
+            
+            # Databases
+            "postgresql": ["postgresql", "postgres", "pg", "psql"],
+            "mysql": ["mysql", "my sql"],
+            "mongodb": ["mongodb", "mongo", "mongo db"],
+            "redis": ["redis"],
+            "elasticsearch": ["elasticsearch", "elastic search"],
+            "cassandra": ["cassandra", "apache cassandra"],
+            "dynamodb": ["dynamodb", "dynamo db"],
+            "sqlite": ["sqlite", "sqlite3"],
+            
+            # Cloud Platforms
+            "aws": ["aws", "amazon web services", "amazon aws"],
+            "azure": ["azure", "microsoft azure"],
+            "gcp": ["gcp", "google cloud", "google cloud platform"],
+            "heroku": ["heroku"],
+            "digitalocean": ["digitalocean", "digital ocean"],
+            "vercel": ["vercel"],
+            "netlify": ["netlify"],
+            
+            # DevOps & Tools
+            "docker": ["docker", "containerization", "containers"],
+            "kubernetes": ["kubernetes", "k8s", "container orchestration"],
+            "jenkins": ["jenkins", "ci/cd"],
+            "github actions": ["github actions", "gh actions"],
+            "terraform": ["terraform", "infrastructure as code", "iac"],
+            "ansible": ["ansible"],
+            "git": ["git", "version control", "source control"],
+            "linux": ["linux", "unix", "ubuntu", "centos"],
+            
+            # Data Science & ML
+            "machine learning": ["machine learning", "ml", "artificial intelligence", "ai"],
+            "deep learning": ["deep learning", "neural networks"],
+            "tensorflow": ["tensorflow", "tf"],
+            "pytorch": ["pytorch", "torch"],
+            "scikit-learn": ["scikit-learn", "sklearn", "scikit learn"],
+            "pandas": ["pandas", "data manipulation"],
+            "numpy": ["numpy", "numerical computing"],
+            "matplotlib": ["matplotlib", "data visualization"],
+            "seaborn": ["seaborn"],
+            "jupyter": ["jupyter", "jupyter notebooks"],
+            
+            # Testing
+            "pytest": ["pytest", "python testing"],
+            "jest": ["jest", "javascript testing"],
+            "selenium": ["selenium", "web automation"],
+            "cypress": ["cypress", "e2e testing"],
+            
+            # Methodologies
+            "agile": ["agile", "scrum", "kanban"],
+            "devops": ["devops", "dev ops"],
+            "microservices": ["microservices", "micro services"],
+            "rest api": ["rest", "rest api", "restful", "api development"],
+            "graphql": ["graphql", "graph ql"],
+        }
+        
+        self.skill_categories = {
+            "programming_languages": ["python", "javascript", "typescript", "java", "csharp", "cpp", "go", "rust", "swift", "kotlin", "r", "scala", "php", "ruby"],
+            "frameworks": ["react", "angular", "vue", "svelte", "django", "flask", "fastapi", "express", "spring", "laravel", "rails"],
+            "databases": ["postgresql", "mysql", "mongodb", "redis", "elasticsearch", "cassandra", "dynamodb", "sqlite"],
+            "cloud_platforms": ["aws", "azure", "gcp", "heroku", "digitalocean", "vercel", "netlify"],
+            "tools": ["docker", "kubernetes", "jenkins", "github actions", "terraform", "ansible", "git", "linux", "pytest", "jest", "selenium", "cypress"],
+            "methodologies": ["agile", "devops", "microservices", "rest api", "graphql"]
+        }
+    
+    def normalize_skill(self, skill: str) -> Optional[str]:
+        """Normalize a skill to its canonical form"""
+        skill_lower = skill.lower().strip()
+        
+        for canonical, synonyms in self.skill_synonyms.items():
+            if skill_lower in synonyms:
+                return canonical
+        
+        return skill_lower if len(skill_lower) > 1 else None
+    
+    def categorize_skill(self, normalized_skill: str) -> str:
+        """Categorize a normalized skill"""
+        for category, skills in self.skill_categories.items():
+            if normalized_skill in skills:
+                return category
+        return "technical"
+    
+    def normalize_skill_list(self, skills: List[str]) -> Dict[str, List[str]]:
+        """Normalize and categorize a list of skills"""
+        categorized = {
+            "programming_languages": [],
+            "frameworks": [],
+            "databases": [],
+            "cloud_platforms": [],
+            "tools": [],
+            "methodologies": [],
+            "technical": []
+        }
+        
+        for skill in skills:
+            normalized = self.normalize_skill(skill)
+            if normalized:
+                category = self.categorize_skill(normalized)
+                if normalized not in categorized[category]:
+                    categorized[category].append(normalized)
+        
+        return categorized
+
+class ResumeParserV2:
+    """Enhanced resume parser with structured extraction and normalization"""
+    
+    def __init__(self):
+        self.skills_normalizer = SkillsNormalizer()
+    
+    async def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        resume_text = data.get("resume_text", "")
+        
+        if not resume_text:
+            return {**data, "resume_data_v2": {"error": "No resume content provided"}}
+        
+        try:
+            # Extract structured resume data
+            resume_data = await self._extract_resume_data_structured(resume_text)
+            
+            log_metric("resume_parse_v2_success", {
+                "skills_count": len(self._get_all_skills(resume_data.skills)),
+                "experience_count": len(resume_data.experience),
+                "projects_count": len(resume_data.projects),
+                "years_experience": resume_data.years_of_experience
+            })
+            
+            return {**data, "resume_data_v2": asdict(resume_data)}
+            
+        except Exception as e:
+            log_metric("resume_parse_v2_error", {"error": str(e)})
+            return {**data, "resume_data_v2": {"error": f"Resume parsing v2 failed: {e}"}}
+    
+    async def _extract_resume_data_structured(self, resume_text: str) -> ResumeData:
+        """Extract structured resume data using multiple approaches"""
+        
+        # First, try comprehensive LLM extraction
+        try:
+            structured_data = await self._llm_extract_structured(resume_text)
+            if structured_data:
+                return structured_data
+        except Exception as e:
+            log_metric("resume_llm_extraction_error", {"error": str(e)})
+        
+        # Fallback to section-based extraction
+        return await self._section_based_extraction(resume_text)
+    
+    async def _llm_extract_structured(self, resume_text: str) -> Optional[ResumeData]:
+        """Use LLM to extract structured resume data"""
+        
+        # Check token count and chunk if necessary
+        token_count = self._count_tokens(resume_text)
+        if token_count > 15000:
+            # For very long resumes, extract in sections
+            return await self._chunked_extraction(resume_text)
+        
+        prompt = f"""
+Extract comprehensive structured data from this resume. Return ONLY valid JSON with this exact structure:
+
+{{
+  "personal_info": {{
+    "name": "Full Name",
+    "email": "email@domain.com",
+    "phone": "+1234567890",
+    "location": "City, State",
+    "linkedin": "linkedin.com/in/username",
+    "github": "github.com/username",
+    "website": "personal-website.com"
+  }},
+  "summary": "Professional summary or objective statement",
+  "skills": {{
+    "technical": ["skill1", "skill2"],
+    "programming_languages": ["Python", "JavaScript"],
+    "frameworks": ["React", "Django"],
+    "tools": ["Git", "Docker"],
+    "databases": ["PostgreSQL", "MongoDB"],
+    "cloud_platforms": ["AWS", "Azure"],
+    "methodologies": ["Agile", "DevOps"],
+    "soft_skills": ["Leadership", "Communication"]
+  }},
+  "experience": [
+    {{
+      "title": "Job Title",
+      "company": "Company Name",
+      "duration": "Jan 2020 - Present",
+      "location": "City, State",
+      "start_date": "2020-01",
+      "end_date": "Present",
+      "is_current": true,
+      "responsibilities": ["responsibility 1", "responsibility 2"],
+      "achievements": ["achievement 1", "achievement 2"],
+      "technologies": ["tech1", "tech2"]
+    }}
+  ],
+  "education": [
+    {{
+      "degree": "Bachelor of Science",
+      "field": "Computer Science",
+      "school": "University Name",
+      "graduation_year": "2020",
+      "gpa": "3.8",
+      "relevant_courses": ["Data Structures", "Algorithms"],
+      "honors": ["Dean's List", "Magna Cum Laude"]
+    }}
+  ],
+  "projects": [
+    {{
+      "name": "Project Name",
+      "description": "Brief description of the project",
+      "technologies": ["tech1", "tech2"],
+      "github_url": "github.com/user/repo",
+      "demo_url": "live-demo-url.com",
+      "duration": "3 months",
+      "key_features": ["feature1", "feature2"]
+    }}
+  ],
+  "certifications": [
+    {{
+      "name": "Certification Name",
+      "issuer": "Organization",
+      "date": "2023",
+      "credential_id": "123456"
+    }}
+  ],
+  "languages": ["English (Native)", "Spanish (Conversational)"],
+  "years_of_experience": 5
+}}
+
+Important guidelines:
+1. Extract ALL skills mentioned, including those in job descriptions and projects
+2. Normalize technology names (e.g., "React.js" → "React", "ML" → "Machine Learning")
+3. Calculate years_of_experience from work history
+4. Parse dates in YYYY-MM format when possible
+5. Group similar skills appropriately
+6. Extract quantifiable achievements when possible
+7. If information is missing, omit the field or use empty array/string
+
+Resume text:
+{resume_text}
+"""
+        
+        try:
+            response = llm_client.call_llm(prompt, temperature=0, max_tokens=4000)
+            data = json.loads(response)
+            
+            # Convert to structured objects
+            return self._convert_to_resume_data(data)
+            
+        except json.JSONDecodeError as e:
+            log_metric("resume_json_parse_error", {"error": str(e)})
+            return None
+        except Exception as e:
+            log_metric("resume_llm_error", {"error": str(e)})
+            return None
+    
+    async def _chunked_extraction(self, resume_text: str) -> ResumeData:
+        """Extract data from long resumes by processing in chunks"""
+        
+        sections = self._split_resume_sections(resume_text)
+        
+        # Extract each section separately
+        personal_info = await self._extract_personal_info(sections.get("header", ""))
+        summary = await self._extract_summary(sections.get("summary", ""))
+        skills = await self._extract_skills(sections.get("skills", ""))
+        experience = await self._extract_experience(sections.get("experience", ""))
+        education = await self._extract_education(sections.get("education", ""))
+        projects = await self._extract_projects(sections.get("projects", ""))
+        certifications = await self._extract_certifications(sections.get("certifications", ""))
+        
+        # Calculate years of experience
+        years_exp = self._calculate_years_experience(experience)
+        
+        return ResumeData(
+            personal_info=personal_info,
+            summary=summary,
+            skills=skills,
+            experience=experience,
+            education=education,
+            projects=projects,
+            certifications=certifications,
+            languages=[],
+            years_of_experience=years_exp
+        )
+    
+    async def _section_based_extraction(self, resume_text: str) -> ResumeData:
+        """Fallback extraction using regex and basic parsing"""
+        
+        # Basic regex-based extraction
+        personal_info = self._extract_personal_info_regex(resume_text)
+        skills = self._extract_skills_regex(resume_text)
+        
+        return ResumeData(
+            personal_info=personal_info,
+            summary="",
+            skills=skills,
+            experience=[],
+            education=[],
+            projects=[],
+            certifications=[],
+            languages=[],
+            years_of_experience=0
+        )
+    
+    def _convert_to_resume_data(self, data: Dict[str, Any]) -> ResumeData:
+        """Convert parsed JSON to ResumeData objects"""
+        
+        # Parse skills with normalization
+        skills_data = data.get("skills", {})
+        all_skills = []
+        for skill_list in skills_data.values():
+            if isinstance(skill_list, list):
+                all_skills.extend(skill_list)
+        
+        normalized_skills = self.skills_normalizer.normalize_skill_list(all_skills)
+        skills = Skills(**normalized_skills)
+        
+        # Parse experience
+        experience = []
+        for exp_data in data.get("experience", []):
+            exp = Experience(**exp_data)
+            experience.append(exp)
+        
+        # Parse education
+        education = []
+        for edu_data in data.get("education", []):
+            edu = Education(**edu_data)
+            education.append(edu)
+        
+        # Parse projects
+        projects = []
+        for proj_data in data.get("projects", []):
+            proj = Project(**proj_data)
+            projects.append(proj)
+        
+        return ResumeData(
+            personal_info=data.get("personal_info", {}),
+            summary=data.get("summary", ""),
+            skills=skills,
+            experience=experience,
+            education=education,
+            projects=projects,
+            certifications=data.get("certifications", []),
+            languages=data.get("languages", []),
+            years_of_experience=data.get("years_of_experience", 0)
+        )
+    
+    def _get_all_skills(self, skills: Skills) -> List[str]:
+        """Get all skills as a flat list"""
+        all_skills = []
+        for field in ['technical', 'programming_languages', 'frameworks', 'tools', 
+                      'databases', 'cloud_platforms', 'methodologies']:
+            all_skills.extend(getattr(skills, field, []))
+        return all_skills
+    
+    def _split_resume_sections(self, resume_text: str) -> Dict[str, str]:
+        """Split resume into sections using common headers"""
+        
+        sections = {}
+        current_section = "header"
+        current_content = []
+        
+        # Common section headers
+        section_patterns = {
+            r'(experience|work experience|employment|professional experience)': 'experience',
+            r'(education|academic background)': 'education',
+            r'(skills|technical skills|core competencies)': 'skills',
+            r'(projects|personal projects|side projects)': 'projects',
+            r'(summary|objective|profile)': 'summary',
+            r'(certifications|licenses)': 'certifications'
+        }
+        
+        lines = resume_text.split('\n')
+        
+        for line in lines:
+            line_lower = line.lower().strip()
+            
+            # Check if this line is a section header
+            section_found = False
+            for pattern, section_name in section_patterns.items():
+                if re.search(pattern, line_lower):
+                    # Save previous section
+                    if current_content:
+                        sections[current_section] = '\n'.join(current_content)
+                    
+                    current_section = section_name
+                    current_content = []
+                    section_found = True
+                    break
+            
+            if not section_found:
+                current_content.append(line)
+        
+        # Save final section
+        if current_content:
+            sections[current_section] = '\n'.join(current_content)
+        
+        return sections
+    
+    def _extract_personal_info_regex(self, text: str) -> Dict[str, str]:
+        """Extract personal information using regex"""
+        
+        # Email
+        email_match = re.search(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', text)
+        email = email_match.group() if email_match else ""
+        
+        # Phone
+        phone_match = re.search(r'(\+?1[-.\s]?)?\(?([0-9]{3})\)?[-.\s]?([0-9]{3})[-.\s]?([0-9]{4})', text)
+        phone = phone_match.group() if phone_match else ""
+        
+        # LinkedIn
+        linkedin_match = re.search(r'linkedin\.com/in/[\w-]+', text, re.IGNORECASE)
+        linkedin = f"https://{linkedin_match.group()}" if linkedin_match else ""
+        
+        # GitHub
+        github_match = re.search(r'github\.com/[\w-]+', text, re.IGNORECASE)
+        github = f"https://{github_match.group()}" if github_match else ""
+        
+        return {
+            "email": email,
+            "phone": phone,
+            "linkedin": linkedin,
+            "github": github
+        }
+    
+    def _extract_skills_regex(self, text: str) -> Skills:
+        """Extract skills using regex patterns"""
+        
+        # Common technical skills to look for
+        tech_keywords = [
+            'Python', 'JavaScript', 'Java', 'C++', 'React', 'Node.js', 'SQL', 
+            'AWS', 'Docker', 'Git', 'Machine Learning', 'Data Science',
+            'TensorFlow', 'PyTorch', 'Pandas', 'NumPy', 'Django', 'Flask',
+            'PostgreSQL', 'MongoDB', 'Redis', 'Kubernetes', 'Jenkins'
+        ]
+        
+        found_skills = []
+        for skill in tech_keywords:
+            if re.search(rf'\b{re.escape(skill)}\b', text, re.IGNORECASE):
+                found_skills.append(skill)
+        
+        # Normalize skills
+        normalized = self.skills_normalizer.normalize_skill_list(found_skills)
+        
+        return Skills(**normalized)
+    
+    def _calculate_years_experience(self, experience: List[Experience]) -> int:
+        """Calculate total years of experience"""
+        if not experience:
+            return 0
+        
+        # Simple calculation based on number of roles
+        # In practice, you'd want to parse dates and calculate overlap
+        return len(experience)
+    
+    def _count_tokens(self, text: str) -> int:
+        """Count tokens in text"""
+        try:
+            encoding = tiktoken.encoding_for_model("gpt-4o-mini")
+            return len(encoding.encode(text))
+        except:
+            # Fallback: approximate as 4 chars per token
+            return len(text) // 4
+    
+    # Placeholder methods for individual section extraction
+    # These would be implemented with specific LLM calls for each section
+    
+    async def _extract_personal_info(self, text: str) -> Dict[str, str]:
+        return self._extract_personal_info_regex(text)
+    
+    async def _extract_summary(self, text: str) -> str:
+        return text.strip()
+    
+    async def _extract_skills(self, text: str) -> Skills:
+        return self._extract_skills_regex(text)
+    
+    async def _extract_experience(self, text: str) -> List[Experience]:
+        return []
+    
+    async def _extract_education(self, text: str) -> List[Education]:
+        return []
+    
+    async def _extract_projects(self, text: str) -> List[Project]:
+        return []
+    
+    async def _extract_certifications(self, text: str) -> List[Dict[str, str]]:
+        return [] 

micro/scrape.py

@@ -0,0 +1,421 @@
+import requests
+import time
+import re
+from typing import Dict, Tuple, Optional
+from datetime import datetime
+
+# Try to import Selenium, but handle gracefully if not available
+try:
+    from selenium import webdriver
+    from selenium.webdriver.chrome.options import Options
+    from selenium.webdriver.common.by import By
+    from selenium.webdriver.support.ui import WebDriverWait
+    from selenium.webdriver.support import expected_conditions as EC
+    from selenium.common.exceptions import TimeoutException, WebDriverException
+    from webdriver_manager.chrome import ChromeDriverManager
+    from selenium.webdriver.chrome.service import Service
+    SELENIUM_AVAILABLE = True
+except ImportError:
+    SELENIUM_AVAILABLE = False
+    print("Warning: Selenium not available. Web scraping will use requests-only fallback.")
+
+
+class LinkedInAuthError(Exception):
+    """Raised when LinkedIn requires authentication"""
+    pass
+
+
+def canonicalise(url: str) -> str:
+    """Convert URL to canonical form for better caching"""
+    if not url.startswith(('http://', 'https://')):
+        url = 'https://' + url
+    
+    # Handle LinkedIn URLs
+    if 'linkedin.com' in url:
+        # Extract job ID from currentJobId parameter
+        job_id_match = re.search(r'currentJobId=(\d+)', url)
+        if job_id_match:
+            job_id = job_id_match.group(1)
+            return f"https://www.linkedin.com/jobs/view/{job_id}"
+        
+        # Extract job ID from /jobs/view/ URLs
+        view_match = re.search(r'/jobs/view/(\d+)', url)
+        if view_match:
+            job_id = view_match.group(1)
+            return f"https://www.linkedin.com/jobs/view/{job_id}"
+    
+    return url
+
+
+def extract_preview_from_html(html: str, url: str) -> Dict[str, str]:
+    """Extract preview info from HTML for immediate display"""
+    preview = {
+        'company': 'Not specified',
+        'role': 'Not specified', 
+        'location': 'Not specified',
+        'posted_days': 'Recently'
+    }
+    
+    if not html:
+        return preview
+    
+    # LinkedIn job page patterns
+    if 'linkedin.com' in url:
+        # Company name patterns
+        company_patterns = [
+            r'<span[^>]*class="[^"]*job-details-jobs-unified-top-card__company-name[^"]*"[^>]*>([^<]+)</span>',
+            r'<a[^>]*class="[^"]*job-details-jobs-unified-top-card__company-name[^"]*"[^>]*>([^<]+)</a>',
+            r'"hiringCompany":\s*{\s*"name":\s*"([^"]+)"',
+            r'<h4[^>]*class="[^"]*job-details-jobs-unified-top-card__company-name[^"]*"[^>]*>([^<]+)</h4>'
+        ]
+        
+        for pattern in company_patterns:
+            match = re.search(pattern, html, re.IGNORECASE | re.DOTALL)
+            if match:
+                preview['company'] = match.group(1).strip()
+                break
+        
+        # Job title patterns
+        title_patterns = [
+            r'<h1[^>]*class="[^"]*job-details-jobs-unified-top-card__job-title[^"]*"[^>]*>([^<]+)</h1>',
+            r'"jobTitle":\s*"([^"]+)"',
+            r'<title>([^|]+)\s*\|[^<]*</title>'
+        ]
+        
+        for pattern in title_patterns:
+            match = re.search(pattern, html, re.IGNORECASE | re.DOTALL)
+            if match:
+                preview['role'] = match.group(1).strip()
+                break
+        
+        # Location patterns
+        location_patterns = [
+            r'<span[^>]*class="[^"]*job-details-jobs-unified-top-card__bullet[^"]*"[^>]*>([^<]+)</span>',
+            r'"jobLocation":\s*{\s*"displayName":\s*"([^"]+)"',
+            r'<div[^>]*class="[^"]*job-details-jobs-unified-top-card__primary-description-container[^"]*"[^>]*>.*?<span[^>]*>([^<]+)</span>'
+        ]
+        
+        for pattern in location_patterns:
+            match = re.search(pattern, html, re.IGNORECASE | re.DOTALL)
+            if match:
+                location = match.group(1).strip()
+                if location and not any(x in location.lower() for x in ['applicant', 'employee', 'easy apply']):
+                    preview['location'] = location
+                    break
+    
+    # Microsoft careers patterns
+    elif 'microsoft.com' in url:
+        company_match = re.search(r'<title>([^|]+)\s*\|\s*Microsoft\s*Careers', html, re.IGNORECASE)
+        if company_match:
+            preview['role'] = company_match.group(1).strip()
+            preview['company'] = 'Microsoft'
+        
+        location_match = re.search(r'"jobLocation":\s*"([^"]+)"', html)
+        if location_match:
+            preview['location'] = location_match.group(1).strip()
+    
+    # Google careers patterns  
+    elif 'google.com' in url:
+        preview['company'] = 'Google'
+        title_match = re.search(r'<title>([^|]+)\s*\|\s*Google\s*Careers', html, re.IGNORECASE)
+        if title_match:
+            preview['role'] = title_match.group(1).strip()
+    
+    # Amazon jobs patterns
+    elif 'amazon.jobs' in url:
+        preview['company'] = 'Amazon'
+        title_match = re.search(r'<h1[^>]*class="[^"]*job-title[^"]*"[^>]*>([^<]+)</h1>', html, re.IGNORECASE)
+        if title_match:
+            preview['role'] = title_match.group(1).strip()
+    
+    # PayPal patterns
+    elif 'paypal.eightfold.ai' in url:
+        preview['company'] = 'PayPal'
+        title_match = re.search(r'"jobTitle":\s*"([^"]+)"', html)
+        if title_match:
+            preview['role'] = title_match.group(1).strip()
+    
+    # Clean up extracted text
+    for key in preview:
+        if isinstance(preview[key], str):
+            preview[key] = re.sub(r'\s+', ' ', preview[key]).strip()
+            if len(preview[key]) > 100:
+                preview[key] = preview[key][:97] + '...'
+    
+    return preview
+
+
+class ScrapeMicroFunction:
+    """Micro-function for web scraping with enhanced preview extraction"""
+    
+    def __init__(self):
+        if SELENIUM_AVAILABLE:
+            self.chrome_options = Options()
+            self.chrome_options.add_argument('--headless')
+            self.chrome_options.add_argument('--no-sandbox')
+            self.chrome_options.add_argument('--disable-dev-shm-usage')
+            self.chrome_options.add_argument('--disable-gpu')
+            self.chrome_options.add_argument('--window-size=1920,1080')
+            self.chrome_options.add_argument('--user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36')
+        else:
+            self.chrome_options = None
+    
+    def run(self, data: dict) -> dict:
+        """Main scraping function returning preview and full content"""
+        raw_input = data.get('raw_input', '') or data.get('input', '')
+        
+        if not raw_input:
+            return {
+                'success': False,
+                'error': 'No input provided',
+                'preview': {'company': 'Error', 'role': 'No input', 'location': '', 'posted_days': ''},
+                'content': '',
+                'scraped_text': ''
+            }
+        
+        # If it's a URL, scrape it
+        if raw_input.startswith(('http://', 'https://', 'www.')):
+            canonical_url = canonicalise(raw_input)
+            result = self._scrape_url(canonical_url)
+            
+            # Add scraped_text for backward compatibility
+            result['scraped_text'] = result.get('content', '')
+            return {**data, **result, 'raw_input': raw_input}
+        else:
+            # Direct text input - use text_extractor
+            from text_extractor import extract_entities
+            from micro.patch_missing import patch_missing
+            
+            job_core = extract_entities(raw_input)
+            # Apply Google patching for missing fields
+            job_core = patch_missing(job_core)
+            
+            # Convert JobCore to preview format
+            preview = {
+                'company': job_core.company or 'Not specified',
+                'role': job_core.role or 'Not specified',
+                'location': job_core.location or 'Not specified',
+                'posted_days': str(job_core.posted_days) if job_core.posted_days else 'Recently'
+            }
+            
+            return {
+                **data,
+                'success': True,
+                'content': raw_input,
+                'preview': preview,
+                'url': None,
+                'scraped_text': raw_input,
+                'raw_input': raw_input,
+                'job_core': job_core  # Add extracted entities for downstream use
+            }
+    
+    def _scrape_url(self, url: str) -> dict:
+        """Scrape URL and extract both preview and full content"""
+        try:
+            # Try LinkedIn-specific scraping first
+            if 'linkedin.com' in url:
+                return self._scrape_linkedin(url)
+            else:
+                return self._scrape_generic(url)
+                
+        except Exception as e:
+            return {
+                'success': False,
+                'error': str(e),
+                'preview': {'company': 'Error', 'role': str(e)[:50], 'location': '', 'posted_days': ''},
+                'content': ''
+            }
+    
+    def _scrape_linkedin(self, url: str) -> dict:
+        """LinkedIn-specific scraping with auth detection"""
+        if not SELENIUM_AVAILABLE:
+            raise LinkedInAuthError("LinkedIn requires authentication - Selenium not available in this environment")
+            
+        driver = None
+        try:
+            service = Service(ChromeDriverManager().install())
+            driver = webdriver.Chrome(service=service, options=self.chrome_options)
+            driver.set_page_load_timeout(10)
+            
+            driver.get(url)
+            
+            # Wait briefly and check for auth redirect
+            time.sleep(2)
+            current_url = driver.current_url
+            
+            if 'authwall' in current_url or 'login' in current_url or 'challenge' in current_url:
+                raise LinkedInAuthError("LinkedIn requires authentication")
+            
+            # Wait for job content to load
+            try:
+                WebDriverWait(driver, 8).until(
+                    EC.presence_of_element_located((By.TAG_NAME, "main"))
+                )
+            except TimeoutException:
+                pass
+            
+            html = driver.page_source
+            preview = extract_preview_from_html(html, url)
+            
+            return {
+                'success': True,
+                'content': html,
+                'preview': preview,
+                'url': url
+            }
+            
+        except LinkedInAuthError:
+            raise
+        except Exception as e:
+            return {
+                'success': False,
+                'error': f"LinkedIn scraping failed: {str(e)}",
+                'preview': {'company': 'LinkedIn', 'role': 'Auth Required', 'location': '', 'posted_days': ''},
+                'content': ''
+            }
+        finally:
+            if driver:
+                driver.quit()
+    
+    def _scrape_generic(self, url: str) -> dict:
+        """Generic scraping for non-LinkedIn URLs"""
+        try:
+            # Try requests first (faster)
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36'
+            }
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+            
+            html = response.text
+            preview = extract_preview_from_html(html, url)
+            
+            return {
+                'success': True,
+                'content': html,
+                'preview': preview,
+                'url': url
+            }
+            
+        except Exception as e:
+            # Fallback to Selenium
+            return self._scrape_with_selenium(url)
+    
+    def _scrape_with_selenium(self, url: str) -> dict:
+        """Selenium fallback for sites that block requests"""
+        if not SELENIUM_AVAILABLE:
+            return {
+                'success': False,
+                'error': "Selenium not available - please copy and paste the job description text instead",
+                'preview': {'company': 'Error', 'role': 'Selenium not available', 'location': '', 'posted_days': ''},
+                'content': ''
+            }
+            
+        driver = None
+        try:
+            service = Service(ChromeDriverManager().install())
+            driver = webdriver.Chrome(service=service, options=self.chrome_options)
+            driver.set_page_load_timeout(15)
+            
+            driver.get(url)
+            time.sleep(3)
+            
+            html = driver.page_source
+            preview = extract_preview_from_html(html, url)
+            
+            return {
+                'success': True,
+                'content': html,
+                'preview': preview,
+                'url': url
+            }
+            
+        except Exception as e:
+            return {
+                'success': False,
+                'error': f"Selenium scraping failed: {str(e)}",
+                'preview': {'company': 'Error', 'role': 'Scraping failed', 'location': '', 'posted_days': ''},
+                'content': ''
+            }
+        finally:
+            if driver:
+                driver.quit()
+    
+    def _extract_preview_from_text(self, text: str) -> Dict[str, str]:
+        """Extract preview info from pasted text"""
+        preview = {
+            'company': 'Not specified',
+            'role': 'Not specified',
+            'location': 'Not specified', 
+            'posted_days': 'Recently'
+        }
+        
+        lines = text.split('\n')
+        
+        # Enhanced extraction patterns for better accuracy
+        for i, line in enumerate(lines[:20]):  # Check first 20 lines
+            line = line.strip()
+            if len(line) < 3 or len(line) > 150:
+                continue
+                
+            # Pattern: "Company · Role · Location"
+            if '·' in line and preview['company'] == 'Not specified':
+                parts = [p.strip() for p in line.split('·')]
+                if len(parts) >= 3:
+                    preview['company'] = parts[0]
+                    preview['role'] = parts[1]
+                    preview['location'] = parts[2]
+                    continue
+            
+            # Pattern: "Role at Company"
+            if ' at ' in line and any(word in line.lower() for word in ['engineer', 'developer', 'analyst', 'manager', 'scientist', 'designer']):
+                parts = line.split(' at ')
+                if len(parts) == 2:
+                    preview['role'] = parts[0].strip()
+                    preview['company'] = parts[1].strip()
+                    continue
+            
+            # Look for standalone role titles
+            if preview['role'] == 'Not specified' and any(word in line.lower() for word in ['engineer', 'developer', 'analyst', 'manager', 'scientist', 'designer', 'specialist']):
+                # Check if it's likely a job title (not part of description)
+                if i < 5 and not line.lower().startswith(('we', 'the', 'our', 'about', 'job', 'position')):
+                    preview['role'] = line
+            
+            # Look for company names (common patterns)
+            if preview['company'] == 'Not specified':
+                if any(word in line.lower() for word in ['group', 'search', 'inc', 'corp', 'company', 'technologies', 'systems', 'solutions']):
+                    # Avoid generic descriptions and clean up
+                    if not any(word in line.lower() for word in ['the', 'our', 'we', 'about', 'job', 'position', 'looking', 'seeking', 'logo']):
+                        # Clean up common suffixes
+                        clean_company = line.replace(' logo', '').replace(' Logo', '').strip()
+                        preview['company'] = clean_company
+            
+            # Look for location patterns
+            if preview['location'] == 'Not specified':
+                # Extract location from patterns like "New York, NY · other text"
+                location_match = re.search(r'([^·•]+(?:, [A-Z]{2}|New York|California|Remote))[·•\s]', line)
+                if location_match:
+                    preview['location'] = location_match.group(1).strip()
+                # Fallback to simple patterns
+                elif any(pattern in line for pattern in [', NY', ', CA', ', TX', ', FL', 'New York', 'California', 'Remote']):
+                    if not any(word in line.lower() for word in ['we', 'the', 'our', 'about', 'job']):
+                        # Try to extract just the location part
+                        for pattern in [', NY', ', CA', ', TX', ', FL']:
+                            if pattern in line:
+                                parts = line.split(pattern)
+                                if len(parts) >= 2:
+                                    location_part = parts[0].split()[-1] + pattern
+                                    preview['location'] = location_part
+                                    break
+                        if preview['location'] == 'Not specified' and 'New York' in line:
+                            preview['location'] = 'New York, NY'
+                        elif preview['location'] == 'Not specified':
+                            preview['location'] = line
+        
+        return preview
+    
+    @staticmethod
+    def from_text(raw: str) -> Dict[str, str]:
+        """Static method to extract company/role/location from plain text"""
+        scraper = ScrapeMicroFunction()
+        return scraper._extract_preview_from_text(raw) 

orchestrator.py

@@ -0,0 +1,35 @@
+from typing import Any, Dict, List, Protocol
+import asyncio
+from text_extractor import extract_batch, JobCore
+from micro.patch_missing import patch_missing
+
+class MicroFunction(Protocol):
+    def run(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        ...
+
+class Orchestrator:
+    def __init__(self, steps: List[MicroFunction]):
+        self.steps = steps
+
+    def run(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        data = input_data
+        for step in self.steps:
+            data = step.run(data)
+        return data
+    
+    def run_from_text(self, raw_jd: str) -> Dict[str, Any]:
+        """Process job description text through the pipeline"""
+        data = {"raw_input": raw_jd, "input": raw_jd}
+        for step in self.steps:
+            data = step.run(data)
+        return data 
+
+async def analyze(raw: str) -> JobCore:
+    """Analyze job description using fast chunked extraction then patch missing data."""
+    # Extract using concurrent chunked processing
+    job_core = await extract_batch(raw)
+    
+    # Patch missing data with Google search
+    enriched_core = patch_missing(job_core)
+    
+    return enriched_core 

prompt_loader.py

@@ -0,0 +1,15 @@
+import yaml
+from typing import Dict, Any
+
+class PromptLoader:
+    def __init__(self, prompt_file: str = "prompts/v1.yaml"):
+        with open(prompt_file, 'r') as f:
+            self.prompts = yaml.safe_load(f)
+    
+    def get_prompt(self, prompt_name: str, **kwargs) -> str:
+        """Get and format a prompt with variables"""
+        template = self.prompts.get(prompt_name, "")
+        return template.format(**kwargs)
+
+# Global instance
+prompt_loader = PromptLoader() 

prompts/v1.yaml

@@ -0,0 +1,62 @@
+# Prompt repository v1
+# Store all LLM prompts, templates, and system messages here
+
+scrape_prompt: |
+  You are a job posting extraction expert. Extract and clean the core job posting content from the following text.
+  
+  Focus on:
+  - Job title and role description
+  - Company name and information
+  - Requirements and qualifications
+  - Responsibilities and duties
+  - Compensation and benefits
+  - Location and work arrangement
+  
+  Remove irrelevant content like navigation, ads, boilerplate text, and website elements.
+  Return clean, structured job posting content.
+  
+  Raw content: {job_posting}
+
+enrich_prompt: |
+  You are a job market analyst. Extract structured information from this job posting and return only valid JSON.
+  
+  Pre-extracted hints:
+  - Company: {pre_company}
+  - Role: {pre_role}
+  
+  Job posting content:
+  {job_posting}
+  
+  Extract the following information and return as valid JSON:
+  {{
+    "role": "Job title/role (use hint if accurate)",
+    "company": "Company name (use hint if accurate)", 
+    "level": "Seniority level (Junior/Mid/Senior/Staff/Principal)",
+    "location": "Job location",
+    "requirements": ["List of key requirements"],
+    "responsibilities": ["List of key responsibilities"],
+    "salary_range": "Salary information if available or 'Not specified'",
+    "work_mode": "Remote/Hybrid/On-site or 'Not specified'",
+    "tech_stack": ["Technologies mentioned"]
+  }}
+  
+  Be precise and factual. If information is unclear, use 'Not specified' rather than guessing.
+
+draft_prompt: |
+  You are a career advisor creating a comprehensive job analysis. Based on the provided job data, create a detailed role preview and interview preparation guide.
+  
+  Job data: {job_data}
+  
+  Your analysis should be thorough, practical, and tailored to job seekers.
+
+critique_prompt: |
+  You are a senior career consultant reviewing job analysis content for accuracy and helpfulness.
+  
+  Evaluate this content critically and provide constructive feedback.
+  
+  Content to review: {draft}
+
+qa_prompt: |
+  You are a quality assurance specialist for career content. Review this job analysis for accuracy, completeness, and clarity.
+  
+  Content to review: {draft} 

read_pdf.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""
+PDF Reader Script
+Extracts text content from PDF files using multiple methods.
+"""
+
+import PyPDF2
+import pdfplumber
+from pathlib import Path
+
+
+def read_pdf_with_pypdf2(pdf_path: str) -> str:
+    """Read PDF using PyPDF2."""
+    try:
+        with open(pdf_path, 'rb') as file:
+            pdf_reader = PyPDF2.PdfReader(file)
+            text = ""
+            for page_num in range(len(pdf_reader.pages)):
+                page = pdf_reader.pages[page_num]
+                text += f"\n--- Page {page_num + 1} ---\n"
+                text += page.extract_text()
+            return text
+    except Exception as e:
+        return f"PyPDF2 Error: {e}"
+
+
+def read_pdf_with_pdfplumber(pdf_path: str) -> str:
+    """Read PDF using pdfplumber."""
+    try:
+        text = ""
+        with pdfplumber.open(pdf_path) as pdf:
+            for page_num, page in enumerate(pdf.pages):
+                text += f"\n--- Page {page_num + 1} ---\n"
+                page_text = page.extract_text()
+                if page_text:
+                    text += page_text
+                else:
+                    text += "[No text found on this page]"
+        return text
+    except Exception as e:
+        return f"pdfplumber Error: {e}"
+
+
+def main():
+    """Main function to read the PDF."""
+    pdf_path = "JRD_v1.1.pdf"
+    
+    if not Path(pdf_path).exists():
+        print(f"Error: PDF file '{pdf_path}' not found!")
+        return
+    
+    print("=" * 60)
+    print("PDF CONTENT EXTRACTION")
+    print("=" * 60)
+    print(f"File: {pdf_path}")
+    print()
+    
+    # Try PyPDF2 first
+    print("📄 Using PyPDF2:")
+    print("-" * 30)
+    pypdf2_text = read_pdf_with_pypdf2(pdf_path)
+    print(pypdf2_text[:1000])  # Show first 1000 characters
+    if len(pypdf2_text) > 1000:
+        print("... (truncated)")
+    print()
+    
+    # Try pdfplumber as backup
+    print("📄 Using pdfplumber:")
+    print("-" * 30)
+    pdfplumber_text = read_pdf_with_pdfplumber(pdf_path)
+    print(pdfplumber_text[:1000])  # Show first 1000 characters
+    if len(pdfplumber_text) > 1000:
+        print("... (truncated)")
+    print()
+    
+    # Save full content to file
+    output_file = "pdf_content.txt"
+    with open(output_file, 'w', encoding='utf-8') as f:
+        f.write("=== PyPDF2 EXTRACTION ===\n")
+        f.write(pypdf2_text)
+        f.write("\n\n=== PDFPLUMBER EXTRACTION ===\n")
+        f.write(pdfplumber_text)
+    
+    print(f"✅ Full content saved to: {output_file}")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main() 

reddit_client.py

@@ -0,0 +1,410 @@
+"""
+Reddit Client for fetching job-related posts during analysis
+"""
+import requests
+import requests.auth
+import random
+import time
+from typing import List, Dict, Any, Optional
+from config import REDDIT_CLIENT_ID, REDDIT_CLIENT_SECRET, REDDIT_USER_AGENT, JOB_SUBREDDITS
+
+class RedditClient:
+    """Client for fetching Reddit posts from job-related subreddits"""
+    
+    def __init__(self):
+        self.client_id = REDDIT_CLIENT_ID
+        self.client_secret = REDDIT_CLIENT_SECRET
+        self.user_agent = REDDIT_USER_AGENT
+        self.access_token = None
+        self.token_expires = 0
+    
+    def get_access_token(self) -> Optional[str]:
+        """Get Reddit API access token"""
+        if self.access_token and time.time() < self.token_expires:
+            return self.access_token
+            
+        auth = requests.auth.HTTPBasicAuth(self.client_id, self.client_secret)
+        data = {'grant_type': 'client_credentials'}
+        headers = {'User-Agent': self.user_agent}
+        
+        try:
+            response = requests.post('https://www.reddit.com/api/v1/access_token',
+                                   auth=auth, data=data, headers=headers, timeout=10)
+            
+            if response.status_code == 200:
+                token_data = response.json()
+                self.access_token = token_data['access_token']
+                self.token_expires = time.time() + token_data['expires_in'] - 60  # 1 min buffer
+                return self.access_token
+        except Exception as e:
+            print(f"Failed to get Reddit token: {e}")
+        
+        return None
+    
+    def get_hot_posts(self, subreddit: str, limit: int = 5) -> List[Dict[str, Any]]:
+        """Get hot posts from a subreddit"""
+        token = self.get_access_token()
+        if not token:
+            return []
+        
+        headers = {
+            'Authorization': f'Bearer {token}',
+            'User-Agent': self.user_agent
+        }
+        
+        try:
+            url = f'https://oauth.reddit.com/r/{subreddit}/hot'
+            params = {'limit': limit}
+            
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            
+            if response.status_code == 200:
+                data = response.json()
+                posts = []
+                
+                for post in data['data']['children']:
+                    post_data = post['data']
+                    posts.append({
+                        'title': post_data['title'],
+                        'score': post_data['score'],
+                        'num_comments': post_data['num_comments'],
+                        'url': f"https://reddit.com{post_data['permalink']}",
+                        'subreddit': post_data['subreddit'],
+                        'created_utc': post_data['created_utc']
+                    })
+                
+                return posts
+        except Exception as e:
+            print(f"Failed to fetch posts from r/{subreddit}: {e}")
+        
+        return []
+    
+    def get_random_job_posts(self, num_posts: int = 3) -> List[Dict[str, Any]]:
+        """Get random posts from job-related subreddits"""
+        all_posts = []
+        
+        # Try to get posts from multiple subreddits
+        for subreddit in random.sample(JOB_SUBREDDITS, min(3, len(JOB_SUBREDDITS))):
+            posts = self.get_hot_posts(subreddit, limit=2)
+            all_posts.extend(posts)
+        
+        # Return random selection
+        if all_posts:
+            return random.sample(all_posts, min(num_posts, len(all_posts)))
+        
+        # Fallback posts if Reddit API fails
+        return [
+            {
+                'title': '💡 Pro tip: Research the company culture before your interview',
+                'score': 156,
+                'num_comments': 23,
+                'url': '#',
+                'subreddit': 'careerguidance',
+                'created_utc': time.time()
+            },
+            {
+                'title': '🎯 STAR method for behavioral questions - game changer!',
+                'score': 289,
+                'num_comments': 47,
+                'url': '#',
+                'subreddit': 'jobs',
+                'created_utc': time.time()
+            },
+            {
+                'title': '🔥 Always prepare 3 questions to ask the interviewer',
+                'score': 198,
+                'num_comments': 31,
+                'url': '#',
+                'subreddit': 'careeradvice',
+                'created_utc': time.time()
+            }
+        ]
+    
+    def format_posts_for_display(self, posts: List[Dict[str, Any]]) -> str:
+        """Format posts for HTML display"""
+        if not posts:
+            return "<p>Loading career insights...</p>"
+        
+        html = '<div class="reddit-posts">'
+        
+        for post in posts:
+            # Format time ago
+            time_ago = int(time.time() - post['created_utc'])
+            if time_ago < 3600:
+                time_str = f"{time_ago // 60}m ago"
+            elif time_ago < 86400:
+                time_str = f"{time_ago // 3600}h ago"
+            else:
+                time_str = f"{time_ago // 86400}d ago"
+            
+            html += f'''
+                <div class="reddit-post">
+                    <div class="post-header">
+                        <span class="subreddit">r/{post['subreddit']}</span>
+                        <span class="post-time">{time_str}</span>
+                    </div>
+                    <h4 class="post-title">{post['title']}</h4>
+                    <div class="post-stats">
+                        <span class="upvotes">↑ {post['score']}</span>
+                        <span class="comments">💬 {post['num_comments']}</span>
+                    </div>
+                </div>
+            '''
+        
+        html += '</div>'
+        return html
+
+    def get_top_posts_of_week(self, subreddit: str, limit: int = 1) -> List[Dict[str, Any]]:
+        """Get top posts of the week from a subreddit"""
+        token = self.get_access_token()
+        if not token:
+            print(f"No token for r/{subreddit}")
+            return []
+
+        headers = {
+            'Authorization': f'Bearer {token}',
+            'User-Agent': self.user_agent
+        }
+
+        try:
+            url = f'https://oauth.reddit.com/r/{subreddit}/top'
+            params = {'limit': limit, 't': 'week'}  # t=week for top of the week
+            
+            print(f"Fetching from: {url} with params: {params}")
+            response = requests.get(url, headers=headers, params=params, timeout=10)
+            print(f"Response status for r/{subreddit}: {response.status_code}")
+            
+            if response.status_code == 200:
+                data = response.json()
+                posts = []
+                
+                if 'data' in data and 'children' in data['data'] and len(data['data']['children']) > 0:
+                    for post in data['data']['children']:
+                        post_data = post['data']
+                        
+                        # Get full post content including body text
+                        full_content = post_data.get('selftext', '').strip()
+                        if not full_content:
+                            # If no selftext, create a preview from the title
+                            full_content = "Link post - click 'View Full Post' to see the discussion and content."
+                        elif len(full_content) > 400:  # Truncate very long posts
+                            full_content = full_content[:400] + "..."
+                        
+                        posts.append({
+                            'title': post_data['title'],
+                            'content': full_content,
+                            'score': post_data['score'],
+                            'num_comments': post_data['num_comments'],
+                            'url': f"https://reddit.com{post_data['permalink']}",
+                            'subreddit': post_data['subreddit'],
+                            'created_utc': post_data['created_utc'],
+                            'author': post_data['author'],
+                            'flair': post_data.get('link_flair_text', '') or ''
+                        })
+                    
+                    print(f"Successfully fetched {len(posts)} posts from r/{subreddit}")
+                    return posts
+                else:
+                    print(f"No posts found in response for r/{subreddit}")
+            else:
+                print(f"API error for r/{subreddit}: {response.status_code} - {response.text[:200]}")
+                
+        except Exception as e:
+            print(f"Exception fetching posts from r/{subreddit}: {e}")
+        
+        return []
+
+    def get_job_posts_by_subreddit(self) -> Dict[str, Dict[str, Any]]:
+        """Get one top post of the week from each job-related subreddit"""
+        subreddit_posts = {}
+        
+        for subreddit in JOB_SUBREDDITS:
+            posts = self.get_top_posts_of_week(subreddit, limit=1)
+            if posts:
+                subreddit_posts[subreddit] = posts[0]
+                print(f"✅ Successfully got post from r/{subreddit}")
+            else:
+                print(f"❌ Failed to get posts from r/{subreddit} - API credentials invalid")
+                # Return empty dict if Reddit API fails - no fallbacks
+                subreddit_posts[subreddit] = None
+        
+        # Filter out None values
+        subreddit_posts = {k: v for k, v in subreddit_posts.items() if v is not None}
+        
+        return subreddit_posts
+
+    def get_single_subreddit_post(self, subreddit: str) -> Optional[Dict[str, Any]]:
+        """Get a single fresh post from a specific subreddit"""
+        posts = self.get_top_posts_of_week(subreddit, limit=3)  # Get 3 to have variety
+        if posts:
+            # Return a random post from the top 3 for variety
+            import random
+            return random.choice(posts)
+        else:
+            # If Reddit API fails, return None - no fallbacks
+            print(f"❌ Failed to refresh post from r/{subreddit} - API credentials invalid")
+            return None
+
+    def format_subreddit_posts_for_display(self, subreddit_posts: Dict[str, Dict[str, Any]]) -> str:
+        """Format subreddit posts for HTML display with individual refresh buttons"""
+        if not subreddit_posts:
+            return "<p>Loading career insights...</p>"
+
+        html = '<div class="reddit-posts-enhanced">'
+        
+        for subreddit, post in subreddit_posts.items():
+            # Format time ago
+            time_ago = int(time.time() - post['created_utc'])
+            if time_ago < 3600:
+                time_str = f"{time_ago // 60}m ago"
+            elif time_ago < 86400:
+                time_str = f"{time_ago // 3600}h ago"
+            else:
+                time_str = f"{time_ago // 86400}d ago"
+            
+            # Format flair
+            flair_html = f'<span class="post-flair">{post["flair"]}</span>' if post.get('flair') else ''
+            
+            html += f'''
+                <div class="reddit-post-enhanced" data-subreddit="{subreddit}">
+                    <div class="post-header-enhanced">
+                        <div class="subreddit-info">
+                            <span class="subreddit-name">r/{subreddit}</span>
+                            {flair_html}
+                        </div>
+                        <div class="post-meta">
+                            <span class="post-time">{time_str}</span>
+                            <button class="refresh-post-btn" onclick="refreshPost('{subreddit}')" title="Get new post from this subreddit">
+                                🔄
+                            </button>
+                        </div>
+                    </div>
+                    <h4 class="post-title-enhanced">
+                        <a href="{post['url']}" target="_blank" rel="noopener">{post['title']}</a>
+                    </h4>
+                    <div class="post-content-enhanced">
+                        {post['content']}
+                    </div>
+                    <div class="post-stats-enhanced">
+                        <div class="stats-left">
+                            <span class="upvotes">↑ {post['score']}</span>
+                            <span class="comments">💬 {post['num_comments']}</span>
+                            <span class="author">👤 u/{post['author']}</span>
+                        </div>
+                        <a href="{post['url']}" target="_blank" class="view-full-btn" rel="noopener">
+                            View Full Post →
+                        </a>
+                    </div>
+                </div>
+            '''
+        
+        html += '''
+            </div>
+            <script>
+                function refreshPost(subreddit) {
+                    console.log('Refreshing post for r/' + subreddit);
+                    // Map subreddit names to button IDs
+                    const buttonMap = {
+                        'jobs': 'refresh-jobs',
+                        'careerguidance': 'refresh-careerguidance', 
+                        'cscareerquestions': 'refresh-cscareerquestions',
+                        'careeradvice': 'refresh-careeradvice',
+                        'ITCareerQuestions': 'refresh-ITCareerQuestions'
+                    };
+                    
+                    const buttonId = buttonMap[subreddit];
+                    if (buttonId) {
+                        // Find and click the hidden Gradio button
+                        const refreshBtn = document.getElementById(buttonId);
+                        if (refreshBtn) {
+                            refreshBtn.click();
+                        } else {
+                            console.log('Button not found:', buttonId);
+                        }
+                    }
+                }
+            </script>
+        '''
+        
+        return html
+
+    def format_posts_as_widget_cards(self, subreddit_posts: Dict[str, Dict[str, Any]]) -> str:
+        """Format subreddit posts as compact widget cards for top display"""
+        if not subreddit_posts:
+            return "<div class='reddit-widgets-loading' style='text-align: center; padding: 2rem; color: rgba(255,255,255,0.6);'>Reddit API credentials invalid - no posts available</div>"
+
+        html = '<div class="reddit-widgets-container">'
+        
+        for subreddit, post in subreddit_posts.items():
+            # Format time ago
+            time_ago = int(time.time() - post['created_utc'])
+            if time_ago < 3600:
+                time_str = f"{time_ago // 60}m"
+            elif time_ago < 86400:
+                time_str = f"{time_ago // 3600}h"
+            else:
+                time_str = f"{time_ago // 86400}d"
+            
+            # Truncate content for widget view
+            widget_content = post['content']
+            if len(widget_content) > 120:
+                widget_content = widget_content[:120] + "..."
+            
+            # Format source display - use actual source for articles, r/subreddit for Reddit posts
+            source_display = post['subreddit'] if post['subreddit'].startswith(('jobs', 'career', 'cs', 'IT')) else post['subreddit']
+            if not source_display.startswith('r/'):
+                source_prefix = ""  # For articles from Forbes, Harvard, etc.
+            else:
+                source_prefix = "r/"
+            
+            html += f'''
+                <div class="reddit-widget-card" data-subreddit="{subreddit}">
+                    <div class="widget-header">
+                        <span class="widget-subreddit">{source_prefix}{source_display}</span>
+                        <div class="widget-actions">
+                            <span class="widget-time">{time_str}</span>
+                            <button class="widget-refresh-btn" onclick="refreshPost('{subreddit}')" title="Refresh">
+                                🔄
+                            </button>
+                        </div>
+                    </div>
+                    <h5 class="widget-title">
+                        <a href="{post['url']}" target="_blank" rel="noopener">{post['title']}</a>
+                    </h5>
+                    <p class="widget-content">{widget_content}</p>
+                    <div class="widget-stats">
+                        <span class="widget-score">↑ {post['score']}</span>
+                        <span class="widget-comments">💬 {post['num_comments']}</span>
+                        <a href="{post['url']}" target="_blank" class="widget-link" rel="noopener">Read →</a>
+                    </div>
+                </div>
+            '''
+        
+        html += '''
+            </div>
+            <script>
+                function refreshPost(subreddit) {
+                    console.log('Refreshing widget for r/' + subreddit);
+                    const buttonMap = {
+                        'jobs': 'refresh-jobs',
+                        'careerguidance': 'refresh-careerguidance', 
+                        'cscareerquestions': 'refresh-cscareerquestions',
+                        'careeradvice': 'refresh-careeradvice',
+                        'ITCareerQuestions': 'refresh-ITCareerQuestions'
+                    };
+                    
+                    const buttonId = buttonMap[subreddit];
+                    if (buttonId) {
+                        const refreshBtn = document.getElementById(buttonId);
+                        if (refreshBtn) {
+                            refreshBtn.click();
+                        }
+                    }
+                }
+            </script>
+        '''
+        
+        return html
+
+# Global Reddit client instance
+reddit_client = RedditClient() 

render_buckets.py

@@ -0,0 +1,100 @@
+from typing import Dict, List
+import re
+
+def render_buckets(bucket_facts: Dict[str, str], buckets: Dict[str, List[str]]) -> str:
+    """Render markdown for intelligence buckets, hiding empty ones"""
+    
+    # Predefined bucket order and emojis
+    bucket_order = [
+        ("Team & Manager", "👥"),
+        ("Tech Stack Snapshot", "⚡"),
+        ("Business Context", "🏢"),
+        ("Comp & Leveling", "💰"),
+        ("Career Trajectory", "📈"),
+        ("Culture/WLB", "🌟"),
+        ("Interview Runway", "🎯"),
+        ("Onboarding & Tooling", "🛠️"),
+        ("Location/Remote", "🌍"),
+        ("Strategic Risks", "⚠️")
+    ]
+    
+    rendered_sections = []
+    empty_bucket_count = 0
+    
+    for bucket_name, emoji in bucket_order:
+        facts = buckets.get(bucket_name, [])
+        
+        # Skip empty buckets
+        if not facts or all(not fact.strip() for fact in facts):
+            empty_bucket_count += 1
+            continue
+        
+        # Render bucket with limited bullets
+        section = f"## {emoji} {bucket_name}\n\n"
+        
+        # Limit to 6 bullets per bucket
+        limited_facts = facts[:6]
+        
+        for fact in limited_facts:
+            if fact.strip():
+                # Ensure fact ends with source link
+                fact = fact.strip()
+                if not fact.endswith('🔗'):
+                    # Add generic source link if missing
+                    if 'http' not in fact:
+                        fact += " 🔗"
+                
+                section += f"- {fact}\n"
+        
+        section += "\n"
+        rendered_sections.append(section)
+    
+    # Log empty buckets for metrics
+    if empty_bucket_count > 0:
+        from metrics import log_metric
+        log_metric("bucket_missing", {"empty_buckets": empty_bucket_count})
+    
+    # Only return content if we have non-empty buckets
+    if rendered_sections:
+        header = "# 🧠 Deep Intelligence Analysis\n\n"
+        return header + "".join(rendered_sections)
+    else:
+        return ""
+
+def format_bullet_with_source(text: str, source_url: str = "") -> str:
+    """Format a bullet point with proper source link"""
+    text = text.strip()
+    
+    # If already has source link, return as-is
+    if '🔗' in text:
+        return text
+    
+    # Add source link
+    if source_url:
+        return f"{text} 🔗 {source_url}"
+    else:
+        return f"{text} 🔗"
+
+def _format_bullet(item: str) -> str:
+    """Format individual bullet with emoji and source links"""
+    
+    # Extract URLs and add link emoji
+    if "🔗" in item:
+        return item
+    elif "http" in item:
+        # Add link emoji for URLs
+        item = re.sub(r'(https?://[^\s]+)', r'🔗 \1', item)
+    
+    # Add context emoji based on content
+    if any(keyword in item.lower() for keyword in ["manager", "team", "hiring"]):
+        return f"👥 {item}"
+    elif any(keyword in item.lower() for keyword in ["salary", "comp", "pay"]):
+        return f"💰 {item}"
+    elif any(keyword in item.lower() for keyword in ["culture", "rating"]):
+        return f"🏢 {item}"
+    elif any(keyword in item.lower() for keyword in ["stack", "tech", "tools"]):
+        return f"⚙️ {item}"
+    elif any(keyword in item.lower() for keyword in ["news", "business"]):
+        return f"📈 {item}"
+    else:
+        return f"📋 {item}" 

render_cards.py

@@ -0,0 +1,310 @@
+"""
+Clean card-based rendering for IQKiller job analysis.
+Replaces markdown blob with focused HTML cards.
+"""
+from typing import Dict, List, Optional, Any
+import re
+
+
+def badge(value: str, field: str, source_map: Dict[str, str]) -> str:
+    """Add '(from Google)' badge if field was patched via Google search."""
+    if source_map.get(field) == "google":
+        return f"{value} <em style='color:#666; font-size:0.9em'>(from Google)</em>"
+    return value
+
+
+def bullets(items: List[str], css_class: str = "text-gray-700") -> str:
+    """Convert list to HTML bullet points."""
+    if not items:
+        return ""
+    
+    bullet_items = "".join([f"<li class='{css_class}'>{item}</li>" for item in items])
+    return f"<ul class='list-disc list-inside space-y-1'>{bullet_items}</ul>"
+
+
+def at_a_glance_card(job_data: Dict[str, Any], source_map: Dict[str, str]) -> str:
+    """Build the main at-a-glance job info card."""
+    company = job_data.get("company", "Unknown Company")
+    role = job_data.get("role", "Unknown Role")
+    level = job_data.get("seniority", job_data.get("level", ""))
+    location = job_data.get("location", "")
+    posted = job_data.get("posted_days", job_data.get("posted_age", ""))
+    
+    # Format salary range
+    salary_low = job_data.get("salary_low")
+    salary_high = job_data.get("salary_high")
+    salary_text = ""
+    if salary_low or salary_high:
+        if salary_low and salary_high:
+            salary_text = f"${salary_low:,} - ${salary_high:,}"
+        elif salary_low:
+            salary_text = f"${salary_low:,}+"
+        elif salary_high:
+            salary_text = f"Up to ${salary_high:,}"
+        salary_text = badge(salary_text, "salary_low", source_map)
+    
+    # Format posted time
+    posted_text = ""
+    if posted:
+        if isinstance(posted, int):
+            if posted == 1:
+                posted_text = "1 day ago"
+            else:
+                posted_text = f"{posted} days ago"
+        else:
+            posted_text = str(posted)
+    
+    return f"""
+    <div class='bg-white border border-gray-200 rounded-lg p-6 shadow-sm mb-4'>
+        <div class='flex items-start justify-between'>
+            <div class='flex-1'>
+                <h2 class='text-2xl font-bold text-gray-900'>{role}</h2>
+                <p class='text-lg text-blue-600 font-semibold mt-1'>{company}</p>
+                <div class='flex flex-wrap gap-4 mt-3 text-sm text-gray-600'>
+                    {f"<span>📍 {location}</span>" if location else ""}
+                    {f"<span>⚡ {level}</span>" if level else ""}
+                    {f"<span>🕒 {posted_text}</span>" if posted_text else ""}
+                </div>
+                {f"<div class='mt-3 text-lg font-semibold text-green-600'>{salary_text}</div>" if salary_text else ""}
+            </div>
+        </div>
+    </div>
+    """
+
+
+def quick_context_card(job_data: Dict[str, Any], source_map: Dict[str, str]) -> str:
+    """Build mission and funding context banner."""
+    mission = job_data.get("mission", "")
+    funding = job_data.get("funding", "")
+    
+    if not mission and not funding:
+        return ""
+    
+    content = ""
+    if mission:
+        content += f"<p class='text-gray-800'>{mission}</p>"
+    
+    if funding:
+        funding_text = badge(funding, "funding", source_map)
+        content += f"<p class='text-blue-700 font-medium mt-2'>💰 {funding_text}</p>"
+    
+    return f"""
+    <div class='bg-green-50 border border-green-200 rounded-lg p-4 mb-4'>
+        <h3 class='text-lg font-semibold text-green-800 mb-2'>Quick Context</h3>
+        {content}
+    </div>
+    """
+
+
+def skills_section(must_have: List[str], nice_to_have: List[str]) -> str:
+    """Build must-have and nice-to-have skills sections."""
+    if not must_have and not nice_to_have:
+        return ""
+    
+    content = ""
+    
+    if must_have:
+        content += f"""
+        <div class='mb-4'>
+            <h4 class='font-semibold text-gray-900 mb-2'>Must-Have Skills</h4>
+            {bullets(must_have, "text-gray-700")}
+        </div>
+        """
+    
+    if nice_to_have:
+        content += f"""
+        <div>
+            <h4 class='font-semibold text-gray-600 mb-2'>Nice-to-Have Skills</h4>
+            {bullets(nice_to_have, "text-gray-500")}
+        </div>
+        """
+    
+    return f"""
+    <div class='bg-white border border-gray-200 rounded-lg p-6 mb-4'>
+        <h3 class='text-lg font-semibold text-gray-900 mb-4'>Skills & Requirements</h3>
+        {content}
+    </div>
+    """
+
+
+def interview_cheat_sheet(tech_q: List[str], behav_q: List[str]) -> str:
+    """Build collapsible interview prep section."""
+    if not tech_q and not behav_q:
+        return ""
+    
+    tech_content = bullets(tech_q[:3], "text-gray-700") if tech_q else ""
+    behav_content = bullets(behav_q[:3], "text-gray-700") if behav_q else ""
+    
+    return f"""
+    <div class='bg-white border border-gray-200 rounded-lg p-6 mb-4'>
+        <details>
+            <summary class='text-lg font-semibold text-gray-900 cursor-pointer hover:text-blue-600'>
+                Interview Cheat Sheet
+            </summary>
+            <div class='mt-4 space-y-4'>
+                {f"<div><h4 class='font-semibold text-gray-900 mb-2'>Technical Questions</h4>{tech_content}</div>" if tech_content else ""}
+                {f"<div><h4 class='font-semibold text-gray-900 mb-2'>Behavioral Questions</h4>{behav_content}</div>" if behav_content else ""}
+            </div>
+        </details>
+    </div>
+    """
+
+
+def comp_perks_section(job_data: Dict[str, Any], perks: List[str]) -> str:
+    """Build compensation and perks section."""
+    salary_low = job_data.get("salary_low")
+    salary_high = job_data.get("salary_high")
+    
+    if not salary_low and not salary_high and not perks:
+        return ""
+    
+    content = ""
+    
+    if perks:
+        content += f"""
+        <div>
+            <h4 class='font-semibold text-gray-900 mb-2'>Perks & Benefits</h4>
+            {bullets(perks, "text-gray-700")}
+        </div>
+        """
+    
+    return f"""
+    <div class='bg-white border border-gray-200 rounded-lg p-6 mb-4'>
+        <h3 class='text-lg font-semibold text-gray-900 mb-4'>Compensation & Perks</h3>
+        {content}
+    </div>
+    """
+
+
+def red_flags_section(red_flags: List[str]) -> str:
+    """Build red flags warning section."""
+    if not red_flags:
+        return ""
+    
+    return f"""
+    <div class='bg-red-50 border border-red-200 rounded-lg p-4 mb-4'>
+        <h3 class='text-lg font-semibold text-red-800 mb-2'>🚩 Red Flag Watchlist</h3>
+        {bullets(red_flags, "text-red-700")}
+    </div>
+    """
+
+
+def next_actions_section(apply_link: str = "") -> str:
+    """Build action buttons section."""
+    apply_button = ""
+    if apply_link:
+        apply_button = f"""
+        <a href="{apply_link}" target="_blank" 
+           class='inline-block bg-blue-600 text-white px-6 py-2 rounded-lg hover:bg-blue-700 transition-colors'>
+            Apply Now
+        </a>
+        """
+    
+    return f"""
+    <div class='bg-gray-50 border border-gray-200 rounded-lg p-6'>
+        <h3 class='text-lg font-semibold text-gray-900 mb-4'>Next Actions</h3>
+        <div class='flex gap-3 flex-wrap'>
+            <button onclick='copyToClipboard()' 
+                    class='bg-green-600 text-white px-6 py-2 rounded-lg hover:bg-green-700 transition-colors'>
+                📋 Copy Summary
+            </button>
+            <button onclick='downloadPDF()' 
+                    class='bg-gray-600 text-white px-6 py-2 rounded-lg hover:bg-gray-700 transition-colors'>
+                📥 Download PDF
+            </button>
+            {apply_button}
+        </div>
+    </div>
+    """
+
+
+def extract_qa_data(qa_content: str) -> Dict[str, List[str]]:
+    """Extract structured data from QA content."""
+    data = {
+        "must_have": [],
+        "nice_to_have": [],
+        "tech_q": [],
+        "behav_q": [],
+        "perks": [],
+        "red_flags": []
+    }
+    
+    # Simple regex patterns to extract lists from QA content
+    patterns = {
+        "must_have": r"(?:must.?have|required|essential).*?(?:\n|$)((?:\s*[-•]\s*.+(?:\n|$))*)",
+        "nice_to_have": r"(?:nice.?to.?have|preferred|bonus).*?(?:\n|$)((?:\s*[-•]\s*.+(?:\n|$))*)",
+        "tech_q": r"(?:technical|tech).*?question.*?(?:\n|$)((?:\s*[-•]\s*.+(?:\n|$))*)",
+        "behav_q": r"(?:behavioral|behaviour).*?question.*?(?:\n|$)((?:\s*[-•]\s*.+(?:\n|$))*)",
+        "perks": r"(?:perks|benefits).*?(?:\n|$)((?:\s*[-•]\s*.+(?:\n|$))*)",
+        "red_flags": r"(?:red.?flag|warning|concern).*?(?:\n|$)((?:\s*[-•]\s*.+(?:\n|$))*)"
+    }
+    
+    for key, pattern in patterns.items():
+        matches = re.findall(pattern, qa_content, re.IGNORECASE | re.MULTILINE)
+        for match in matches:
+            items = re.findall(r"[-•]\s*(.+)", match)
+            data[key].extend([item.strip() for item in items if item.strip()])
+    
+    return data
+
+
+def to_html(result_data: Dict[str, Any]) -> str:
+    """Convert job analysis result to clean HTML cards."""
+    # Extract job core data
+    enriched = result_data.get("enriched", {})
+    source_map = enriched.get("source_map", {})
+    
+    # Extract QA-derived data (using correct orchestrator keys)
+    qa_content = result_data.get("qa_result", "")
+    critique_content = result_data.get("critique", "")
+    draft_content = result_data.get("draft", "")
+    
+    qa_data = extract_qa_data(qa_content + "\n" + critique_content + "\n" + draft_content)
+    
+    # Apply link from enriched data
+    apply_link = enriched.get("apply_link", "")
+    
+    # Build HTML sections
+    html_parts = [
+        at_a_glance_card(enriched, source_map),
+        quick_context_card(enriched, source_map),
+        skills_section(qa_data["must_have"], qa_data["nice_to_have"]),
+        interview_cheat_sheet(qa_data["tech_q"], qa_data["behav_q"]),
+        comp_perks_section(enriched, qa_data["perks"]),
+        red_flags_section(qa_data["red_flags"]),
+        next_actions_section(apply_link)
+    ]
+    
+    # JavaScript for copy functionality
+    role = enriched.get('role', 'Unknown')
+    company = enriched.get('company', 'Unknown')
+    location = enriched.get('location', 'N/A')
+    seniority = enriched.get('seniority', 'N/A')
+    mission = enriched.get('mission', '')
+    
+    js_script = f"""
+    <script>
+    window.__IQ_SUMMARY__ = `Job: {role} at {company}
+Location: {location}
+Level: {seniority}
+{mission}`;
+    
+    function copyToClipboard() {{
+        navigator.clipboard.writeText(window.__IQ_SUMMARY__).then(() => {{
+            alert('Summary copied to clipboard!');
+        }});
+    }}
+    
+    function downloadPDF() {{
+        alert('PDF download coming soon!');
+    }}
+    </script>
+    """
+    
+    # Combine all sections
+    return "\n".join([part for part in html_parts if part.strip()]) + js_script 
+
+
+def skeleton() -> str:
+    """Return loading skeleton placeholder."""
+    return "<div class='animate-pulse p-6 text-gray-400'>Analyzing JD…</div>" 

render_cards_test.py

@@ -0,0 +1,84 @@
+"""
+Tests for render_cards module.
+"""
+import pytest
+from render_cards import at_a_glance_card, badge, bullets, to_html
+
+
+def test_badge_adds_google_source():
+    """Test that badge adds '(from Google)' when field is in source_map."""
+    source_map = {"salary_low": "google"}
+    result = badge("$120,000", "salary_low", source_map)
+    assert "(from Google)" in result
+    assert "120,000" in result
+
+
+def test_badge_no_source():
+    """Test that badge doesn't add annotation when field not in source_map."""
+    source_map = {}
+    result = badge("$120,000", "salary_low", source_map)
+    assert "(from Google)" not in result
+    assert result == "$120,000"
+
+
+def test_bullets_creates_list():
+    """Test that bullets creates proper HTML list."""
+    items = ["Python", "Machine Learning", "SQL"]
+    result = bullets(items)
+    assert "<ul" in result
+    assert "<li" in result
+    assert "Python" in result
+    assert "SQL" in result
+
+
+def test_at_a_glance_card_basic():
+    """Test at-a-glance card contains key job info."""
+    job_data = {
+        "company": "TechCorp",
+        "role": "Senior Engineer",
+        "location": "San Francisco",
+        "seniority": "Senior"
+    }
+    source_map = {}
+    
+    result = at_a_glance_card(job_data, source_map)
+    
+    assert "TechCorp" in result
+    assert "Senior Engineer" in result
+    assert "San Francisco" in result
+    assert "Senior" in result
+    assert "bg-white" in result  # Tailwind class
+
+
+def test_to_html_complete():
+    """Test full HTML generation with sample data."""
+    result_data = {
+        "enriched": {
+            "company": "TestCorp",
+            "role": "Software Engineer",
+            "location": "Remote",
+            "mission": "Building the future",
+            "source_map": {}
+        },
+        "qa_content": "Must-have skills:\n- Python\n- SQL",
+        "critique_content": "Red flags:\n- Long hours mentioned"
+    }
+    
+    html = to_html(result_data)
+    
+    assert "TestCorp" in html
+    assert "Software Engineer" in html
+    assert "Building the future" in html
+    assert "<script>" in html  # JavaScript included
+    assert "copyToClipboard" in html
+
+
+def test_empty_data_handling():
+    """Test handling of missing or empty data."""
+    result_data = {"enriched": {}, "qa_content": "", "critique_content": ""}
+    
+    html = to_html(result_data)
+    
+    # Should still generate basic structure without errors
+    assert "Unknown" in html  # Fallback values
+    assert "<script>" in html 

renderer_nobs.py

@@ -0,0 +1,470 @@
+"""
+No-BS Job Brief renderer for IQKiller.
+Creates compact, single-card job briefs with essential info only.
+"""
+from typing import Dict, List, Optional, Any
+
+def skeleton() -> str:
+    """Return loading skeleton placeholder."""
+    return "<div class='animate-pulse p-4 text-gray-400'>Analyzing…</div>"
+
+def bullets(items: List[str], css_class: str = "text-gray-700") -> str:
+    """Convert list to HTML bullet points."""
+    if not items:
+        return ""
+    
+    bullet_items = "".join([f"<li class='{css_class} text-sm'>{item}</li>" for item in items])
+    return f"<ul class='list-disc list-inside space-y-1 ml-4'>{bullet_items}</ul>"
+
+def hide_if_empty(content: str, wrapper: str = "") -> str:
+    """Hide section if content is empty."""
+    if not content.strip():
+        return ""
+    return wrapper.format(content=content) if wrapper else content
+
+def format_title_line(data: Dict[str, Any]) -> str:
+    """Format the compact title line."""
+    title = data.get("title", "Unknown Role")
+    company = data.get("company", "Unknown Company")
+    location = data.get("location", "")
+    work_type = data.get("work_type", "")
+    salary_band = data.get("salary_band", "")
+    
+    # Build title components
+    parts = [f"{title} · {company}"]
+    
+    if work_type or location:
+        location_work = " ".join(filter(None, [work_type, location]))
+        parts.append(location_work)
+    
+    if salary_band:
+        parts.append(f"• {salary_band}")
+    
+    return " — ".join(parts)
+
+def format_mission(mission: str) -> str:
+    """Format mission one-liner (≤25 words)."""
+    if not mission:
+        return ""
+    
+    # Truncate if too long
+    words = mission.split()
+    if len(words) > 25:
+        mission = " ".join(words[:25]) + "..."
+    
+    return f"""
+    <div class='mb-4'>
+        <p class='text-gray-800 text-sm italic'>{mission}</p>
+    </div>
+    """
+
+def format_must_have(must_have: List[str]) -> str:
+    """Format must-have stack (≤6 bullets, <7 words each)."""
+    if not must_have:
+        return ""
+    
+    # Limit to 6 items and truncate long items
+    limited_items = must_have[:6]
+    truncated_items = []
+    
+    for item in limited_items:
+        words = item.split()
+        if len(words) > 7:
+            item = " ".join(words[:7]) + "..."
+        truncated_items.append(item)
+    
+    bullet_html = bullets(truncated_items, "text-gray-900 font-medium")
+    
+    return f"""
+    <div class='mb-4'>
+        <h3 class='text-sm font-semibold text-gray-900 mb-2'>Must-Have Stack</h3>
+        {bullet_html}
+    </div>
+    """
+
+def format_nice_to_have(nice_to_have: List[str]) -> str:
+    """Format nice-to-have skills (grey bullets)."""
+    if not nice_to_have:
+        return ""
+    
+    # Limit to 6 items
+    limited_items = nice_to_have[:6]
+    bullet_html = bullets(limited_items, "text-gray-500")
+    
+    return f"""
+    <div class='mb-4'>
+        <h3 class='text-sm font-semibold text-gray-600 mb-2'>Nice-to-Haves</h3>
+        {bullet_html}
+    </div>
+    """
+
+def format_why_it_matters(why_it_matters: str) -> str:
+    """Format why-it-matters (≤30 words)."""
+    if not why_it_matters:
+        return ""
+    
+    # Truncate if too long
+    words = why_it_matters.split()
+    if len(words) > 30:
+        why_it_matters = " ".join(words[:30]) + "..."
+    
+    return f"""
+    <div class='mb-4'>
+        <h3 class='text-sm font-semibold text-blue-700 mb-2'>Why It Matters</h3>
+        <p class='text-gray-700 text-sm'>{why_it_matters}</p>
+    </div>
+    """
+
+def format_perks(perks: List[str]) -> str:
+    """Format perks as inline list."""
+    if not perks:
+        return ""
+    
+    perks_text = " • ".join(perks[:8])  # Limit to avoid overflow
+    
+    return f"""
+    <div class='mb-4'>
+        <h3 class='text-sm font-semibold text-green-700 mb-2'>Perks</h3>
+        <p class='text-gray-700 text-sm'>{perks_text}</p>
+    </div>
+    """
+
+def format_red_flags(red_flags: List[str]) -> str:
+    """Format red flags (red, only if any)."""
+    if not red_flags:
+        return ""
+    
+    bullet_html = bullets(red_flags, "text-red-700")
+    
+    return f"""
+    <div class='mb-4 bg-red-50 border border-red-200 rounded-lg p-3'>
+        <h3 class='text-sm font-semibold text-red-800 mb-2'>🚩 Red Flags</h3>
+        {bullet_html}
+    </div>
+    """
+
+def format_technical_questions(technical_questions: List[str]) -> str:
+    """Format likely technical interview questions."""
+    if not technical_questions:
+        return ""
+    
+    bullet_html = bullets(technical_questions[:6], "text-red-700")
+    
+    return f"""
+    <div class='mb-4 bg-red-50 border border-red-200 rounded-lg p-3'>
+        <h3 class='text-sm font-semibold text-red-800 mb-2'>🔧 Technical Questions</h3>
+        <p class='text-xs text-red-600 mb-2'>Likely technical questions they'll ask:</p>
+        {bullet_html}
+    </div>
+    """
+
+def format_behavioral_questions(behavioral_questions: List[str]) -> str:
+    """Format likely behavioral interview questions."""
+    if not behavioral_questions:
+        return ""
+    
+    bullet_html = bullets(behavioral_questions[:6], "text-purple-700")
+    
+    return f"""
+    <div class='mb-4 bg-purple-50 border border-purple-200 rounded-lg p-3'>
+        <h3 class='text-sm font-semibold text-purple-800 mb-2'>💬 Behavioral Questions</h3>
+        <p class='text-xs text-purple-600 mb-2'>Behavioral questions to prepare for:</p>
+        {bullet_html}
+    </div>
+    """
+
+def format_talking_points(talking_points: List[str]) -> str:
+    """Format key talking points to emphasize."""
+    if not talking_points:
+        return ""
+    
+    bullet_html = bullets(talking_points[:6], "text-indigo-700")
+    
+    return f"""
+    <div class='mb-4 bg-indigo-50 border border-indigo-200 rounded-lg p-3'>
+        <h3 class='text-sm font-semibold text-indigo-800 mb-2'>🎯 Talking Points</h3>
+        <p class='text-xs text-indigo-600 mb-2'>Highlight these experiences/achievements:</p>
+        {bullet_html}
+    </div>
+    """
+
+def format_company_intel(company_intel: List[str]) -> str:
+    """Format key company intelligence for interview research."""
+    if not company_intel:
+        return ""
+    
+    bullet_html = bullets(company_intel[:3], "text-blue-700")
+    
+    return f"""
+    <div class='mb-4 bg-blue-50 border border-blue-200 rounded-lg p-3'>
+        <h3 class='text-sm font-semibold text-blue-800 mb-2'>🏢 Company Intel</h3>
+        <p class='text-xs text-blue-600 mb-2'>Key facts to mention:</p>
+        {bullet_html}
+    </div>
+    """
+
+def format_smart_questions(smart_questions: List[str]) -> str:
+    """Format smart questions for the applicant to ask."""
+    if not smart_questions:
+        return ""
+    
+    bullet_html = bullets(smart_questions[:5], "text-green-700")
+    
+    return f"""
+    <div class='mb-4 bg-green-50 border border-green-200 rounded-lg p-3'>
+        <h3 class='text-sm font-semibold text-green-800 mb-2'>❓ Smart Questions</h3>
+        <p class='text-xs text-green-600 mb-2'>Ask these to show strategic thinking:</p>
+        {bullet_html}
+    </div>
+    """
+
+def format_role_challenges(role_challenges: List[str]) -> str:
+    """Format main challenges this role will solve."""
+    if not role_challenges:
+        return ""
+    
+    bullet_html = bullets(role_challenges[:5], "text-orange-700")
+    
+    return f"""
+    <div class='mb-4 bg-orange-50 border border-orange-200 rounded-lg p-3'>
+        <h3 class='text-sm font-semibold text-orange-800 mb-2'>⚡ Role Challenges</h3>
+        <p class='text-xs text-orange-600 mb-2'>Key problems you'll solve:</p>
+        {bullet_html}
+    </div>
+    """
+
+def format_success_metrics(success_metrics: List[str]) -> str:
+    """Format how success is measured in this role."""
+    if not success_metrics:
+        return ""
+    
+    bullet_html = bullets(success_metrics[:5], "text-teal-700")
+    
+    return f"""
+    <div class='mb-4 bg-teal-50 border border-teal-200 rounded-lg p-3'>
+        <h3 class='text-sm font-semibold text-teal-800 mb-2'>📊 Success Metrics</h3>
+        <p class='text-xs text-teal-600 mb-2'>How success is measured:</p>
+        {bullet_html}
+    </div>
+    """
+
+def format_salary_context(salary_context: str) -> str:
+    """Format salary negotiation context."""
+    if not salary_context:
+        return ""
+    
+    return f"""
+    <div class='mb-4 bg-yellow-50 border border-yellow-200 rounded-lg p-3'>
+        <h3 class='text-sm font-semibold text-yellow-800 mb-2'>💰 Salary Context</h3>
+        <p class='text-yellow-700 text-sm'>{salary_context}</p>
+    </div>
+    """
+
+def format_next_actions(apply_link: str = "") -> str:
+    """Format next actions with apply and copy buttons."""
+    apply_button = ""
+    if apply_link:
+        apply_button = f"""
+        <a href="{apply_link}" target="_blank" 
+           class='inline-flex items-center px-3 py-1.5 text-sm bg-blue-600 text-white rounded hover:bg-blue-700 transition-colors mr-2'>
+            ▶ Apply
+        </a>
+        """
+    
+    return f"""
+    <div class='pt-4 border-t border-gray-200'>
+        <div class='flex items-center gap-2'>
+            {apply_button}
+            <button onclick="copySummary()" 
+                    class='inline-flex items-center px-3 py-1.5 text-sm bg-gray-100 text-gray-700 rounded hover:bg-gray-200 transition-colors'>
+                📋 Copy summary
+            </button>
+        </div>
+    </div>
+    """
+
+def create_copy_script() -> str:
+    """Create JavaScript for copy functionality."""
+    return """
+    <script>
+    function copySummary(){
+        navigator.clipboard.writeText(document.getElementById("iq-summary").innerText);
+    }
+    </script>
+    """
+
+def create_summary_text(data: Dict[str, Any]) -> str:
+    """Create plain text summary for copying."""
+    lines = []
+    
+    # Title line
+    lines.append(format_title_line(data))
+    
+    # Mission
+    mission = data.get("mission", "")
+    if mission:
+        lines.append(f"Mission: {mission}")
+    
+    # Must-have
+    must_have = data.get("must_have", [])
+    if must_have:
+        lines.append("Must-Have Stack:")
+        for item in must_have[:6]:
+            lines.append(f"  • {item}")
+    
+    # Nice-to-have
+    nice_to_have = data.get("nice_to_have", [])
+    if nice_to_have:
+        lines.append("Nice-to-Haves:")
+        for item in nice_to_have[:6]:
+            lines.append(f"  • {item}")
+    
+    # Why it matters
+    why_it_matters = data.get("why_it_matters", "")
+    if why_it_matters:
+        lines.append(f"Why It Matters: {why_it_matters}")
+    
+    # Technical questions
+    technical_questions = data.get("technical_questions", [])
+    if technical_questions:
+        lines.append("Technical Questions:")
+        for item in technical_questions[:6]:
+            lines.append(f"  • {item}")
+    
+    # Behavioral questions
+    behavioral_questions = data.get("behavioral_questions", [])
+    if behavioral_questions:
+        lines.append("Behavioral Questions:")
+        for item in behavioral_questions[:6]:
+            lines.append(f"  • {item}")
+    
+    # Talking points
+    talking_points = data.get("talking_points", [])
+    if talking_points:
+        lines.append("Talking Points:")
+        for item in talking_points[:6]:
+            lines.append(f"  • {item}")
+    
+    # Company intel
+    company_intel = data.get("company_intel", [])
+    if company_intel:
+        lines.append("Company Intel:")
+        for item in company_intel[:3]:
+            lines.append(f"  • {item}")
+    
+    # Smart questions
+    smart_questions = data.get("smart_questions", [])
+    if smart_questions:
+        lines.append("Smart Questions:")
+        for item in smart_questions[:5]:
+            lines.append(f"  • {item}")
+    
+    # Role challenges
+    role_challenges = data.get("role_challenges", [])
+    if role_challenges:
+        lines.append("Role Challenges:")
+        for item in role_challenges[:5]:
+            lines.append(f"  • {item}")
+    
+    # Success metrics
+    success_metrics = data.get("success_metrics", [])
+    if success_metrics:
+        lines.append("Success Metrics:")
+        for item in success_metrics[:5]:
+            lines.append(f"  • {item}")
+    
+    # Salary context
+    salary_context = data.get("salary_context", "")
+    if salary_context:
+        lines.append(f"Salary Context: {salary_context}")
+    
+    # Perks
+    perks = data.get("perks", [])
+    if perks:
+        lines.append(f"Perks: {' • '.join(perks)}")
+    
+    return "\n\n".join(lines)
+
+def to_html(data: Dict[str, Any]) -> str:
+    """Build the complete No-BS job brief card."""
+    
+    # Handle data normalization
+    if isinstance(data.get("must_have"), str):
+        data["must_have"] = [data["must_have"]]
+    if isinstance(data.get("nice_to_have"), str):
+        data["nice_to_have"] = [data["nice_to_have"]]
+    if isinstance(data.get("perks"), str):
+        data["perks"] = [data["perks"]]
+    if isinstance(data.get("red_flags"), str):
+        data["red_flags"] = [data["red_flags"]]
+    if isinstance(data.get("technical_questions"), str):
+        data["technical_questions"] = [data["technical_questions"]]
+    if isinstance(data.get("behavioral_questions"), str):
+        data["behavioral_questions"] = [data["behavioral_questions"]]
+    if isinstance(data.get("talking_points"), str):
+        data["talking_points"] = [data["talking_points"]]
+    if isinstance(data.get("company_intel"), str):
+        data["company_intel"] = [data["company_intel"]]
+    if isinstance(data.get("smart_questions"), str):
+        data["smart_questions"] = [data["smart_questions"]]
+    if isinstance(data.get("role_challenges"), str):
+        data["role_challenges"] = [data["role_challenges"]]
+    if isinstance(data.get("success_metrics"), str):
+        data["success_metrics"] = [data["success_metrics"]]
+    
+    # Build sections
+    title_line = format_title_line(data)
+    mission_section = format_mission(data.get("mission", ""))
+    must_have_section = format_must_have(data.get("must_have", []))
+    nice_to_have_section = format_nice_to_have(data.get("nice_to_have", []))
+    why_it_matters_section = format_why_it_matters(data.get("why_it_matters", ""))
+    perks_section = format_perks(data.get("perks", []))
+    red_flags_section = format_red_flags(data.get("red_flags", []))
+    
+    # Interview Query-style sections
+    technical_questions_section = format_technical_questions(data.get("technical_questions", []))
+    behavioral_questions_section = format_behavioral_questions(data.get("behavioral_questions", []))
+    talking_points_section = format_talking_points(data.get("talking_points", []))
+    company_intel_section = format_company_intel(data.get("company_intel", []))
+    smart_questions_section = format_smart_questions(data.get("smart_questions", []))
+    role_challenges_section = format_role_challenges(data.get("role_challenges", []))
+    success_metrics_section = format_success_metrics(data.get("success_metrics", []))
+    salary_context_section = format_salary_context(data.get("salary_context", ""))
+    
+    next_actions_section = format_next_actions(data.get("apply_link", ""))
+    
+    # Create plain text summary for copying
+    summary_text = create_summary_text(data)
+    
+    # Build complete HTML
+    html = f"""
+    <div class='max-w-2xl mx-auto'>
+        <div class='bg-white border border-gray-200 rounded-lg p-6 shadow-sm'>
+            <h1 class='text-lg font-bold text-gray-900 mb-4'>{title_line}</h1>
+            
+            {hide_if_empty(mission_section)}
+            {hide_if_empty(must_have_section)}
+            {hide_if_empty(nice_to_have_section)}
+            {hide_if_empty(why_it_matters_section)}
+            {hide_if_empty(perks_section)}
+            {hide_if_empty(red_flags_section)}
+            
+            {hide_if_empty(technical_questions_section)}
+            {hide_if_empty(behavioral_questions_section)}
+            {hide_if_empty(talking_points_section)}
+            {hide_if_empty(company_intel_section)}
+            {hide_if_empty(smart_questions_section)}
+            {hide_if_empty(role_challenges_section)}
+            {hide_if_empty(success_metrics_section)}
+            {hide_if_empty(salary_context_section)}
+            
+            {next_actions_section}
+        </div>
+        
+        <pre id="iq-summary" style="display: none;">{summary_text}</pre>
+    </div>
+    
+    {create_copy_script()}
+    """
+    
+    return html 

requirements.txt

@@ -0,0 +1,24 @@
+gradio==4.43.0
+flask>=2.0.0
+requests
+beautifulsoup4
+typer
+pyyaml
+pdfplumber
+pydantic
+openai>=1.0.0
+anthropic>=0.8.0
+python-dotenv==1.0.0
+google-search-results
+tiktoken>=0.7.0
+PyJWT>=2.8.0
+python-multipart>=0.0.6
+diskcache>=5.6.0
+PyPDF2>=3.0.0
+python-docx>=1.1.0
+google-auth>=2.0.0
+google-auth-oauthlib>=0.5.0
+google-auth-httplib2>=0.1.0
+authlib>=1.2.0
+selenium>=4.0.0
+webdriver-manager>=3.8.0

salary_negotiation_simulator.py

@@ -0,0 +1,25 @@
+"""
+Salary Negotiation Simulator for IQKiller
+"""
+import random
+import time
+from typing import Dict, List, Any
+
+class SalaryNegotiationSimulator:
+    def __init__(self, user_role="Software Engineer", base_salary=75000):
+        self.user_role = user_role
+        self.base_salary = base_salary
+        self.total_score = 0
+        
+    def get_scenarios(self):
+        return [
+            {
+                "title": "🎯 First Offer Challenge",
+                "context": f"Hiring manager offers ${self.base_salary - 10000:,}",
+                "choices": [
+                    {"id": "accept", "text": "I accept!", "points": -10},
+                    {"id": "counter", "text": "Market rate is higher", "points": 20},
+                    {"id": "aggressive", "text": "Too low!", "points": -5}
+                ]
+            }
+        ] 

simple_app.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""
+Simple Flask-based Job Posting Analysis App
+"""
+
+import hashlib
+import os
+from typing import Dict, Optional, Tuple
+from urllib.parse import urlparse
+import time
+import requests
+from bs4 import BeautifulSoup
+from flask import Flask, render_template_string, request, jsonify
+import pdfplumber
+import re
+import gradio as gr
+import asyncio
+
+app = Flask(__name__)
+
+
+class JobPostingAnalyzer:
+    """Simplified analyzer without caching."""
+    
+    def __init__(self):
+        """Initialize the analyzer."""
+        pass
+    
+    def _is_valid_url(self, url: str) -> bool:
+        """Validate if URL is properly formatted."""
+        try:
+            result = urlparse(url)
+            return all([result.scheme, result.netloc])
+        except Exception:
+            return False
+    
+    def _is_pdf_file(self, path: str) -> bool:
+        """Check if the path is a PDF file."""
+        return path.lower().endswith('.pdf') or os.path.exists(path)
+    
+    def scrape_pdf_content(self, pdf_path: str) -> Optional[str]:
+        """Scrape content from PDF file."""
+        try:
+            with pdfplumber.open(pdf_path) as pdf:
+                text = ""
+                for page in pdf.pages:
+                    page_text = page.extract_text()
+                    if page_text:
+                        text += page_text + "\n"
+                return text
+        except Exception as e:
+            print(f"Error reading PDF: {e}")
+            return None
+    
+    def scrape_job_posting(self, url: str) -> Optional[str]:
+        """Scrape job posting content from URL or PDF file."""
+        # Check if it's a PDF file
+        if self._is_pdf_file(url):
+            return self.scrape_pdf_content(url)
+        
+        # Otherwise treat as URL
+        try:
+            headers = {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+            }
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.content, "html.parser")
+            
+            # Remove script and style elements
+            for script in soup(["script", "style"]):
+                script.decompose()
+            
+            # Extract text content
+            text = soup.get_text()
+            lines = (line.strip() for line in text.splitlines())
+            chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+            text = " ".join(chunk for chunk in chunks if chunk)
+            
+            return text
+        except Exception as e:
+            print(f"Error scraping URL: {e}")
+            return None
+    
+    def enrich_job_data(self, scraped_text: str) -> Dict[str, str]:
+        """Extract and enrich job posting data."""
+        lines = scraped_text.split('\n')
+        job_data = {
+            "title": "",
+            "company": "",
+            "location": "",
+            "level": "",
+            "requirements": "",
+            "responsibilities": ""
+        }
+        
+        # Enhanced extraction logic for JRD content
+        for i, line in enumerate(lines):
+            line_lower = line.lower()
+            
+            # Look for project title
+            if "project:" in line_lower and not job_data["title"]:
+                job_data["title"] = line.strip()
+            elif "joint requirements document" in line_lower and not job_data["title"]:
+                job_data["title"] = "Joint Requirements Document (JRD)"
+            
+            # Look for company info
+            if "microsoft" in line_lower and not job_data["company"]:
+                job_data["company"] = "Microsoft"
+            
+            # Look for level/position info
+            if any(level in line_lower for level in ["senior", "lead", "principal", "staff"]):
+                job_data["level"] = line.strip()
+            
+            # Look for requirements
+            if "requirements" in line_lower or "functional" in line_lower:
+                # Get next few lines as requirements
+                req_lines = []
+                for j in range(i, min(i + 10, len(lines))):
+                    if lines[j].strip():
+                        req_lines.append(lines[j].strip())
+                job_data["requirements"] = " ".join(req_lines)
+                break
+        
+        return job_data
+    
+    def generate_preview(self, job_data: Dict[str, str]) -> str:
+        """Generate markdown preview from job data."""
+        preview = "### Role Snapshot\n"
+        
+        if job_data["title"]:
+            preview += f"- **Title:** {job_data['title']}\n"
+        if job_data["level"]:
+            preview += f"- **Level:** {job_data['level']}\n"
+        if job_data["company"]:
+            preview += f"- **Company:** {job_data['company']}\n"
+        if job_data["location"]:
+            preview += f"- **Location:** {job_data['location']}\n"
+        if job_data["requirements"]:
+            preview += f"- **Requirements:** {job_data['requirements'][:200]}...\n"
+        
+        preview += "\n---\n"
+        return preview
+    
+    def analyze_job_posting(self, url: str) -> Tuple[bool, str]:
+        """Main analysis function with caching."""
+        # Check if it's a PDF file first
+        if self._is_pdf_file(url):
+            # For PDFs, don't validate URL format
+            pass
+        elif not self._is_valid_url(url):
+            return False, "Invalid URL format. Please provide a valid job posting URL or PDF file path."
+        
+        # Scrape the content (URL or PDF)
+        scraped_text = self.scrape_job_posting(url)
+        if not scraped_text:
+            return False, "Failed to scrape content. Please check the file path or URL."
+        
+        # Enrich the data
+        job_data = self.enrich_job_data(scraped_text)
+        
+        # Generate preview
+        preview = self.generate_preview(job_data)
+        
+        return True, preview
+
+
+# Initialize analyzer
+analyzer = JobPostingAnalyzer()
+
+# HTML template
+HTML_TEMPLATE = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Job Posting Analyzer</title>
+    <style>
+        body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
+        .container { background: #f5f5f5; padding: 20px; border-radius: 8px; }
+        input[type="text"] { width: 100%; padding: 10px; margin: 10px 0; border: 1px solid #ddd; border-radius: 4px; }
+        button { background: #007bff; color: white; padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer; }
+        button:hover { background: #0056b3; }
+        .result { margin-top: 20px; padding: 15px; border-radius: 4px; }
+        .success { background: #d4edda; border: 1px solid #c3e6cb; }
+        .error { background: #f8d7da; border: 1px solid #f5c6cb; }
+        .preview { background: white; padding: 15px; border-radius: 4px; margin-top: 10px; }
+        .info { background: #d1ecf1; border: 1px solid #bee5eb; padding: 10px; border-radius: 4px; margin-bottom: 15px; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🎯 Job Posting Analyzer</h1>
+        <p>Paste a job posting URL or PDF file path to analyze and generate interview preparation materials.</p>
+        
+        <div class="info">
+            <strong>Supported inputs:</strong><br>
+            • URLs: https://example.com/job-posting<br>
+            • PDF files: JRD_v1.1.pdf (local files)
+        </div>
+        
+        <form method="POST">
+            <input type="text" name="url" placeholder="https://example.com/job-posting or JRD_v1.1.pdf" value="{{ url or '' }}" required>
+            <button type="submit">🔍 Analyze Job Posting</button>
+        </form>
+        
+        {% if result %}
+        <div class="result {% if success %}success{% else %}error{% endif %}">
+            <strong>{{ status }}</strong>
+            {% if success and preview %}
+            <div class="preview">
+                <h3>Preview:</h3>
+                <pre>{{ preview }}</pre>
+            </div>
+            {% endif %}
+        </div>
+        {% endif %}
+    </div>
+</body>
+</html>
+"""
+
+
+@app.route('/', methods=['GET', 'POST'])
+def index():
+    """Main page with form and results."""
+    url = ""
+    result = ""
+    success = False
+    status = ""
+    preview = ""
+    
+    if request.method == 'POST':
+        url = request.form.get('url', '').strip()
+        if url:
+            success, result = analyzer.analyze_job_posting(url)
+            if success:
+                status = "✅ Analysis complete! Preview generated."
+                preview = result
+            else:
+                status = f"❌ Error: {result}"
+    
+    return render_template_string(HTML_TEMPLATE, 
+                                url=url, 
+                                result=result, 
+                                success=success, 
+                                status=status, 
+                                preview=preview)
+
+
+@app.route('/api/analyze', methods=['POST'])
+def api_analyze():
+    """API endpoint for job posting analysis."""
+    data = request.get_json()
+    url = data.get('url', '').strip()
+    
+    if not url:
+        return jsonify({'success': False, 'error': 'URL is required'})
+    
+    success, result = analyzer.analyze_job_posting(url)
+    
+    return jsonify({
+        'success': success,
+        'result': result if success else None,
+        'error': result if not success else None
+    })
+
+
+if __name__ == '__main__':
+    print("🚀 Starting Job Posting Analyzer...")
+    print("📱 Web interface available at: http://localhost:5000")
+    print("🔌 API endpoint available at: http://localhost:5000/api/analyze")
+    app.run(debug=True, host='0.0.0.0', port=5000) 

test_app.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""
+Simple test script for job posting analysis functionality.
+"""
+
+import time
+from typing import Dict, Any, Optional, Tuple
+import requests
+from bs4 import BeautifulSoup
+import re
+from urllib.parse import urlparse, urljoin
+import gradio as gr
+import asyncio
+import pytest
+
+
+class JobPostingAnalyzer:
+    """Simplified analyzer for testing without caching."""
+    
+    def __init__(self):
+        """Initialize the analyzer."""
+        pass
+    
+    def _is_valid_url(self, url: str) -> bool:
+        """Validate if URL is properly formatted."""
+        try:
+            result = urlparse(url)
+            return all([result.scheme, result.netloc])
+        except Exception:
+            return False
+    
+    def scrape_job_posting(self, url: str) -> Optional[str]:
+        """Scrape job posting content from URL."""
+        try:
+            headers = {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+            }
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.content, "html.parser")
+            
+            # Remove script and style elements
+            for script in soup(["script", "style"]):
+                script.decompose()
+            
+            # Extract text content
+            text = soup.get_text()
+            lines = (line.strip() for line in text.splitlines())
+            chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+            text = " ".join(chunk for chunk in chunks if chunk)
+            
+            return text
+        except Exception as e:
+            print(f"Error scraping URL: {e}")
+            return None
+    
+    def enrich_job_data(self, scraped_text: str) -> Dict[str, str]:
+        """Extract and enrich job posting data."""
+        lines = scraped_text.split('\n')
+        job_data = {
+            "title": "",
+            "company": "",
+            "location": "",
+            "level": "",
+            "requirements": "",
+            "responsibilities": ""
+        }
+        
+        # Simple extraction logic
+        for i, line in enumerate(lines):
+            line_lower = line.lower()
+            if "senior" in line_lower or "lead" in line_lower:
+                job_data["level"] = line.strip()
+            elif "engineer" in line_lower or "developer" in line_lower:
+                if not job_data["title"]:
+                    job_data["title"] = line.strip()
+        
+        return job_data
+    
+    def generate_preview(self, job_data: Dict[str, str]) -> str:
+        """Generate markdown preview from job data."""
+        preview = "### Role Snapshot\n"
+        
+        if job_data["title"]:
+            preview += f"- **Title:** {job_data['title']}\n"
+        if job_data["level"]:
+            preview += f"- **Level:** {job_data['level']}\n"
+        if job_data["company"]:
+            preview += f"- **Company:** {job_data['company']}\n"
+        if job_data["location"]:
+            preview += f"- **Location:** {job_data['location']}\n"
+        
+        preview += "\n---\n"
+        return preview
+    
+    def analyze_job_posting(self, url: str) -> Tuple[bool, str]:
+        """Main analysis function with caching."""
+        if not self._is_valid_url(url):
+            return False, "Invalid URL format. Please provide a valid job posting URL."
+        
+        # Scrape the job posting
+        scraped_text = self.scrape_job_posting(url)
+        if not scraped_text:
+            return False, "Failed to scrape job posting. Please check the URL and try again."
+        
+        # Enrich the data
+        job_data = self.enrich_job_data(scraped_text)
+        
+        # Generate preview
+        preview = self.generate_preview(job_data)
+        
+        return True, preview
+
+
+def main():
+    """Test the job posting analyzer."""
+    analyzer = JobPostingAnalyzer()
+    
+    # Test with a sample job posting URL
+    test_url = "https://jobs.lever.co/example/senior-data-engineer"
+    
+    print("Testing Job Posting Analyzer...")
+    print(f"URL: {test_url}")
+    
+    success, result = analyzer.analyze_job_posting(test_url)
+    
+    if success:
+        print("✅ Analysis successful!")
+        print("\nPreview:")
+        print(result)
+    else:
+        print(f"❌ Analysis failed: {result}")
+    
+    print("\nTest completed!")
+
+
+if __name__ == "__main__":
+    main() 

test_interview_guide.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""
+Test script for the personalized interview guide functionality.
+Demonstrates the complete pipeline: Resume + Job → Gap Analysis → Personalized Guide
+"""
+
+import asyncio
+import json
+from interview_orchestrator import create_personalized_interview_guide
+
+# Sample resume data
+SAMPLE_RESUME = """
+John Smith
+Software Engineer
+john.smith@email.com | (555) 123-4567 | LinkedIn: linkedin.com/in/johnsmith | GitHub: github.com/johnsmith
+
+PROFESSIONAL SUMMARY
+Experienced full-stack software engineer with 3+ years developing web applications using Python, JavaScript, and cloud technologies. Strong background in API development, database design, and agile methodologies.
+
+TECHNICAL SKILLS
+Programming Languages: Python, JavaScript, SQL, HTML/CSS
+Frameworks: Django, React, Node.js, Express
+Databases: PostgreSQL, MongoDB, Redis
+Cloud/DevOps: AWS (EC2, S3, RDS), Docker, Git, CI/CD
+Tools: VS Code, Postman, Jira, Slack
+
+PROFESSIONAL EXPERIENCE
+
+Software Engineer | TechCorp | Jan 2021 - Present
+• Developed and maintained 5+ web applications serving 10,000+ users daily
+• Built RESTful APIs using Python/Django with 99.9% uptime
+• Implemented responsive front-end components using React and modern JavaScript
+• Collaborated with cross-functional teams in Agile/Scrum environment
+• Reduced database query time by 40% through optimization and indexing
+
+Junior Developer | StartupXYZ | Jun 2020 - Dec 2020
+• Created feature-rich web application using MERN stack
+• Integrated third-party APIs and payment processing systems
+• Participated in code reviews and maintained coding standards
+• Deployed applications to AWS cloud infrastructure
+
+PROJECTS
+
+E-commerce Platform (2023)
+• Built full-stack e-commerce solution with Django backend and React frontend
+• Implemented user authentication, shopping cart, and payment integration
+• Technologies: Python, Django, React, PostgreSQL, Stripe API
+
+Task Management App (2022)
+• Developed collaborative task management application
+• Features include real-time updates, file uploads, and team collaboration
+• Technologies: Node.js, Express, MongoDB, Socket.io
+
+EDUCATION
+Bachelor of Science in Computer Science
+State University | 2020
+GPA: 3.7/4.0
+Relevant Coursework: Data Structures, Algorithms, Database Systems, Software Engineering
+"""
+
+# Sample job posting
+SAMPLE_JOB = """
+Senior Full Stack Engineer
+DataFlow Inc.
+San Francisco, CA | Remote
+
+About DataFlow Inc.
+We're a fast-growing fintech startup building next-generation data analytics tools for financial institutions. Our platform processes billions of transactions daily and helps banks make better decisions through AI-powered insights.
+
+Role Overview
+We're seeking a Senior Full Stack Engineer to join our engineering team and help scale our platform to handle growing demand. You'll work on both frontend and backend systems, collaborate with data scientists, and contribute to architectural decisions.
+
+Key Responsibilities
+• Design and implement scalable web applications using modern technologies
+• Build robust APIs and microservices to support our data platform
+• Collaborate with product and design teams to deliver exceptional user experiences
+• Optimize application performance and ensure high availability
+• Mentor junior developers and contribute to engineering best practices
+• Work with data engineering team to build data visualization tools
+
+Required Qualifications
+• 4+ years of experience in full-stack web development
+• Strong proficiency in Python and modern JavaScript frameworks
+• Experience with cloud platforms (AWS, GCP, or Azure)
+• Knowledge of relational databases and SQL optimization
+• Familiarity with containerization (Docker) and CI/CD pipelines
+• Experience with agile development methodologies
+• Bachelor's degree in Computer Science or related field
+
+Preferred Qualifications
+• Experience with financial/fintech applications
+• Knowledge of data visualization libraries (D3.js, Chart.js)
+• Familiarity with machine learning concepts
+• Experience with Kubernetes and microservices architecture
+• Previous experience at a startup or high-growth company
+
+Technical Stack
+• Backend: Python, Django/Flask, PostgreSQL, Redis
+• Frontend: React, TypeScript, Next.js
+• Infrastructure: AWS, Docker, Kubernetes
+• Data: Apache Airflow, Spark, Snowflake
+
+Compensation & Benefits
+• Competitive salary: $140,000 - $180,000
+• Equity package
+• Comprehensive health, dental, and vision insurance
+• Flexible PTO policy
+• $2,000 annual learning and development budget
+• Remote-first culture with optional office access
+
+Why Join DataFlow?
+• Work on cutting-edge fintech technology
+• High-impact role in a fast-growing company
+• Collaborative and learning-focused culture
+• Opportunity to shape product direction
+• Competitive compensation and equity upside
+"""
+
+async def test_interview_guide_generation():
+    """Test the complete interview guide generation pipeline"""
+    
+    print("🚀 Testing Personalized Interview Guide Generation")
+    print("=" * 60)
+    
+    print("\n📝 Resume Summary:")
+    print(f"- Length: {len(SAMPLE_RESUME)} characters")
+    print("- Skills: Python, JavaScript, React, Django, AWS")
+    print("- Experience: 3+ years full-stack development")
+    
+    print("\n🎯 Job Summary:")
+    print("- Role: Senior Full Stack Engineer at DataFlow Inc.")
+    print("- Requirements: 4+ years, Python, JavaScript, Cloud, Fintech")
+    print("- Salary: $140k-$180k")
+    
+    print("\n⚡ Generating Interview Guide...")
+    print("-" * 40)
+    
+    # Generate the guide
+    result = create_personalized_interview_guide(SAMPLE_RESUME, SAMPLE_JOB)
+    
+    if result.get("success"):
+        print("✅ Guide generation successful!")
+        
+        # Display metrics
+        gap_analysis = result.get("gap_analysis", {})
+        match_score = gap_analysis.get("match_score", 0)
+        processing_time = result.get("processing_time", 0)
+        guide_length = len(result.get("rendered_guide", ""))
+        
+        print(f"\n📊 Results:")
+        print(f"- Match Score: {match_score}%")
+        print(f"- Processing Time: {processing_time:.2f} seconds")
+        print(f"- Guide Length: {guide_length} characters")
+        
+        # Display gap analysis summary
+        summary = gap_analysis.get("summary", "")
+        if summary:
+            print(f"\n🎯 Gap Analysis: {summary}")
+        
+        # Display skills breakdown
+        skills_map = gap_analysis.get("skills_map", {})
+        if skills_map:
+            print(f"\n💪 Strengths: {skills_map.get('strong', [])[:3]}")
+            print(f"📚 Areas to Study: {skills_map.get('gaps', [])[:3]}")
+        
+        # Show first part of rendered guide
+        rendered_guide = result.get("rendered_guide", "")
+        if rendered_guide:
+            print(f"\n📄 Generated Guide Preview:")
+            print("-" * 40)
+            preview = rendered_guide[:500] + "..." if len(rendered_guide) > 500 else rendered_guide
+            print(preview)
+            print("-" * 40)
+        
+        # Save full guide to file
+        with open("sample_interview_guide.md", "w") as f:
+            f.write(rendered_guide)
+        print(f"\n💾 Full guide saved to: sample_interview_guide.md")
+        
+    else:
+        print("❌ Guide generation failed!")
+        error_msg = result.get("error", "Unknown error")
+        print(f"Error: {error_msg}")
+        
+        # Show debug info if available
+        if "data" in result:
+            print("\n🔍 Debug Information:")
+            print(json.dumps(result["data"], indent=2))
+
+def test_validation():
+    """Test input validation"""
+    
+    print("\n🧪 Testing Input Validation")
+    print("-" * 30)
+    
+    # Test empty inputs
+    result1 = create_personalized_interview_guide("", SAMPLE_JOB)
+    print(f"Empty resume: {'✅ Caught' if not result1.get('success') else '❌ Missed'}")
+    
+    result2 = create_personalized_interview_guide(SAMPLE_RESUME, "")
+    print(f"Empty job: {'✅ Caught' if not result2.get('success') else '❌ Missed'}")
+    
+    # Test short inputs
+    result3 = create_personalized_interview_guide("Short resume", SAMPLE_JOB)
+    print(f"Short resume: {'✅ Caught' if not result3.get('success') else '❌ Missed'}")
+    
+    result4 = create_personalized_interview_guide(SAMPLE_RESUME, "Short job")
+    print(f"Short job: {'✅ Caught' if not result4.get('success') else '❌ Missed'}")
+
+async def main():
+    """Main test function"""
+    
+    print("🎯 IQKiller Personalized Interview Guide Test Suite")
+    print("=" * 60)
+    
+    # Run main test
+    await test_interview_guide_generation()
+    
+    # Run validation tests
+    test_validation()
+    
+    print("\n🎉 Test suite completed!")
+    print("\nTo view the full generated guide, open: sample_interview_guide.md")
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

test_jrd_pdf.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+Test script to analyze the JRD PDF file using our job posting analyzer.
+"""
+
+import hashlib
+from typing import Dict, Optional, Tuple
+from urllib.parse import urlparse
+import time
+import requests
+from bs4 import BeautifulSoup
+import PyPDF2
+import pdfplumber
+import re
+from urllib.parse import urljoin
+import gradio as gr
+import asyncio
+
+
+class JobPostingAnalyzer:
+    """Test analyzer without caching."""
+    
+    def __init__(self):
+        """Initialize the analyzer."""
+        pass
+    
+
+    
+    def _is_valid_url(self, url: str) -> bool:
+        """Validate if URL is properly formatted."""
+        try:
+            result = urlparse(url)
+            return all([result.scheme, result.netloc])
+        except Exception:
+            return False
+    
+    def scrape_pdf_content(self, pdf_path: str) -> Optional[str]:
+        """Scrape content from PDF file."""
+        try:
+            # Try pdfplumber first for better text extraction
+            with pdfplumber.open(pdf_path) as pdf:
+                text = ""
+                for page in pdf.pages:
+                    page_text = page.extract_text()
+                    if page_text:
+                        text += page_text + "\n"
+                return text
+        except Exception as e:
+            print(f"Error reading PDF: {e}")
+            return None
+    
+    def scrape_job_posting(self, url: str) -> Optional[str]:
+        """Scrape job posting content from URL or PDF file."""
+        # Check if it's a local file path
+        if url.startswith('/') or url.startswith('./') or url.endswith('.pdf'):
+            return self.scrape_pdf_content(url)
+        
+        # Otherwise treat as URL
+        try:
+            headers = {
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+            }
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.content, "html.parser")
+            
+            # Remove script and style elements
+            for script in soup(["script", "style"]):
+                script.decompose()
+            
+            # Extract text content
+            text = soup.get_text()
+            lines = (line.strip() for line in text.splitlines())
+            chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+            text = " ".join(chunk for chunk in chunks if chunk)
+            
+            return text
+        except Exception as e:
+            print(f"Error scraping URL: {e}")
+            return None
+    
+    def enrich_job_data(self, scraped_text: str) -> Dict[str, str]:
+        """Extract and enrich job posting data."""
+        lines = scraped_text.split('\n')
+        job_data = {
+            "title": "",
+            "company": "",
+            "location": "",
+            "level": "",
+            "requirements": "",
+            "responsibilities": ""
+        }
+        
+        # Enhanced extraction logic for JRD content
+        for i, line in enumerate(lines):
+            line_lower = line.lower()
+            
+            # Look for project title
+            if "project:" in line_lower and not job_data["title"]:
+                job_data["title"] = line.strip()
+            elif "joint requirements document" in line_lower and not job_data["title"]:
+                job_data["title"] = "Joint Requirements Document (JRD)"
+            
+            # Look for company info
+            if "microsoft" in line_lower and not job_data["company"]:
+                job_data["company"] = "Microsoft"
+            
+            # Look for level/position info
+            if any(level in line_lower for level in ["senior", "lead", "principal", "staff"]):
+                job_data["level"] = line.strip()
+            
+            # Look for requirements
+            if "requirements" in line_lower or "functional" in line_lower:
+                # Get next few lines as requirements
+                req_lines = []
+                for j in range(i, min(i + 10, len(lines))):
+                    if lines[j].strip():
+                        req_lines.append(lines[j].strip())
+                job_data["requirements"] = " ".join(req_lines)
+                break
+        
+        return job_data
+    
+    def generate_preview(self, job_data: Dict[str, str]) -> str:
+        """Generate markdown preview from job data."""
+        preview = "### Role Snapshot\n"
+        
+        if job_data["title"]:
+            preview += f"- **Title:** {job_data['title']}\n"
+        if job_data["level"]:
+            preview += f"- **Level:** {job_data['level']}\n"
+        if job_data["company"]:
+            preview += f"- **Company:** {job_data['company']}\n"
+        if job_data["location"]:
+            preview += f"- **Location:** {job_data['location']}\n"
+        if job_data["requirements"]:
+            preview += f"- **Requirements:** {job_data['requirements'][:200]}...\n"
+        
+        preview += "\n---\n"
+        return preview
+    
+    def analyze_job_posting(self, url: str) -> Tuple[bool, str]:
+        """Main analysis function with caching."""
+        cache_key = self._get_cache_key(url)
+        cached_result = self.cache.get(cache_key)
+        
+        if cached_result:
+            return True, cached_result
+        
+        # Scrape the content (URL or PDF)
+        scraped_text = self.scrape_job_posting(url)
+        if not scraped_text:
+            return False, "Failed to scrape content. Please check the file path or URL."
+        
+        # Enrich the data
+        job_data = self.enrich_job_data(scraped_text)
+        
+        # Generate preview
+        preview = self.generate_preview(job_data)
+        
+        # Cache the result
+        self.cache.set(cache_key, preview, expire=self.cache_timeout)
+        
+        return True, preview
+
+
+def main():
+    """Test the job posting analyzer with the JRD PDF."""
+    analyzer = JobPostingAnalyzer()
+    
+    # Test with the JRD PDF file
+    pdf_path = "JRD_v1.1.pdf"
+    
+    print("Testing Job Posting Analyzer with JRD PDF...")
+    print(f"File: {pdf_path}")
+    print("=" * 60)
+    
+    success, result = analyzer.analyze_job_posting(pdf_path)
+    
+    if success:
+        print("✅ Analysis successful!")
+        print("\nPreview:")
+        print(result)
+    else:
+        print(f"❌ Analysis failed: {result}")
+    
+    print("\n" + "=" * 60)
+    print("Test completed!")
+
+
+if __name__ == "__main__":
+    main() 

tests/__init__.py

@@ -0,0 +1 @@
+# Tests package 

tests/test_async_latency.py

@@ -0,0 +1,167 @@
+import pytest
+import asyncio
+import time
+from unittest.mock import patch, MagicMock
+from micro.bucket_enrich import BucketEnrichMicroFunction
+
+
+class TestAsyncLatency:
+    """Test suite for verifying async parallel execution performance."""
+    
+    def test_parallel_vs_serial_latency(self):
+        """Test that parallel execution is faster than serial execution."""
+        
+        # Mock the individual enrichment functions to simulate network delays
+        with patch.object(BucketEnrichMicroFunction, 'stack_enrich') as mock_stack, \
+             patch.object(BucketEnrichMicroFunction, 'biz_enrich') as mock_biz, \
+             patch.object(BucketEnrichMicroFunction, 'comp_enrich') as mock_comp, \
+             patch.object(BucketEnrichMicroFunction, 'culture_enrich') as mock_culture, \
+             patch.object(BucketEnrichMicroFunction, 'manager_enrich') as mock_manager:
+            
+            # Mock each function to sleep for 0.5 seconds (simulating network delay)
+            def mock_sleep_and_return(sleep_time: float, return_value: dict):
+                def side_effect(*args, **kwargs):
+                    time.sleep(sleep_time)
+                    return return_value
+                return side_effect
+            
+            mock_stack.side_effect = mock_sleep_and_return(0.5, {"stack": "Python"})
+            mock_biz.side_effect = mock_sleep_and_return(0.5, {"news": "Growing"})
+            mock_comp.side_effect = mock_sleep_and_return(0.5, {"salary": "$120k"})
+            mock_culture.side_effect = mock_sleep_and_return(0.5, {"culture": "Remote"})
+            mock_manager.side_effect = mock_sleep_and_return(0.5, {"manager": "John"})
+            
+            # Test data
+            test_data = {
+                "enriched": {
+                    "company": "TestCorp",
+                    "location": "San Francisco, CA"
+                },
+                "raw_input": "https://linkedin.com/jobs/test-job"
+            }
+            
+            enrich_func = BucketEnrichMicroFunction()
+            
+            # Measure parallel execution time
+            start_time = time.time()
+            result = enrich_func.run(test_data)
+            parallel_time = time.time() - start_time
+            
+            # Verify result structure
+            assert "bucket_facts" in result
+            assert len(result["bucket_facts"]) > 0
+            
+            # Expected serial time would be ~2.5 seconds (5 * 0.5)
+            # Parallel time should be ~0.5 seconds (max of parallel tasks)
+            expected_serial_time = 2.5
+            max_acceptable_parallel_time = 1.0  # Give some buffer for overhead
+            
+            assert parallel_time < max_acceptable_parallel_time, \
+                f"Parallel execution took {parallel_time:.2f}s, expected < {max_acceptable_parallel_time}s"
+            
+            # Verify it's significantly faster than serial would be
+            speedup = expected_serial_time / parallel_time
+            assert speedup > 2.0, \
+                f"Speedup of {speedup:.2f}x is less than expected minimum of 2.0x"
+    
+    def test_async_gather_functionality(self):
+        """Test that asyncio.gather works correctly with our async wrapper functions."""
+        
+        enrich_func = BucketEnrichMicroFunction()
+        
+        # Mock the sync functions to return known values
+        with patch.object(enrich_func, 'stack_enrich', return_value={"stack": "Python"}), \
+             patch.object(enrich_func, 'biz_enrich', return_value={"news": "Growing"}), \
+             patch.object(enrich_func, 'comp_enrich', return_value={"salary": "$120k"}), \
+             patch.object(enrich_func, 'culture_enrich', return_value={"culture": "Remote"}):
+            
+            # Test the async wrapper directly
+            result = asyncio.run(enrich_func._async_enrich_all(
+                company="TestCorp",
+                location="San Francisco, CA",
+                raw_input="normal job posting"
+            ))
+            
+            # Verify all results are merged correctly
+            expected_facts = {
+                "stack": "Python",
+                "news": "Growing", 
+                "salary": "$120k",
+                "culture": "Remote"
+            }
+            
+            for key, value in expected_facts.items():
+                assert key in result
+                assert result[key] == value
+    
+    def test_async_exception_handling(self):
+        """Test that exceptions in async tasks are handled gracefully."""
+        
+        enrich_func = BucketEnrichMicroFunction()
+        
+        # Mock some functions to raise exceptions
+        with patch.object(enrich_func, 'stack_enrich', side_effect=Exception("Network error")), \
+             patch.object(enrich_func, 'biz_enrich', return_value={"news": "Growing"}), \
+             patch.object(enrich_func, 'comp_enrich', return_value={"salary": "$120k"}), \
+             patch.object(enrich_func, 'culture_enrich', return_value={"culture": "Remote"}):
+            
+            # Should not raise exception, but should handle it gracefully
+            result = asyncio.run(enrich_func._async_enrich_all(
+                company="TestCorp",
+                location="San Francisco, CA", 
+                raw_input="normal job posting"
+            ))
+            
+            # Should still get results from non-failing functions
+            assert "news" in result
+            assert "salary" in result
+            assert "culture" in result
+            
+            # The failing function should not contribute to results
+            assert "stack" not in result
+    
+    def test_parallel_execution_with_timeouts(self):
+        """Test that parallel execution respects timeout constraints."""
+        
+        # Mock functions with different execution times
+        def create_timeout_mock(delay: float, return_value: dict):
+            def side_effect(*args, **kwargs):
+                time.sleep(delay)
+                return return_value
+            return side_effect
+        
+        with patch.object(BucketEnrichMicroFunction, 'stack_enrich') as mock_stack, \
+             patch.object(BucketEnrichMicroFunction, 'biz_enrich') as mock_biz, \
+             patch.object(BucketEnrichMicroFunction, 'comp_enrich') as mock_comp, \
+             patch.object(BucketEnrichMicroFunction, 'culture_enrich') as mock_culture:
+            
+            # Set up different delays
+            mock_stack.side_effect = create_timeout_mock(0.2, {"stack": "Python"})
+            mock_biz.side_effect = create_timeout_mock(0.3, {"news": "Growing"})
+            mock_comp.side_effect = create_timeout_mock(0.4, {"salary": "$120k"})
+            mock_culture.side_effect = create_timeout_mock(0.1, {"culture": "Remote"})
+            
+            test_data = {
+                "enriched": {
+                    "company": "TestCorp",
+                    "location": "San Francisco, CA"
+                },
+                "raw_input": "normal job posting"
+            }
+            
+            enrich_func = BucketEnrichMicroFunction()
+            
+            start_time = time.time()
+            result = enrich_func.run(test_data)
+            total_time = time.time() - start_time
+            
+            # Total time should be close to the longest task (0.4s) rather than sum (1.0s)
+            assert total_time < 0.7, f"Execution took {total_time:.2f}s, expected < 0.7s"
+            assert total_time > 0.3, f"Execution took {total_time:.2f}s, expected > 0.3s"
+            
+            # Verify all results are present
+            facts = result["bucket_facts"]
+            assert "stack" in facts
+            assert "news" in facts
+            assert "salary" in facts
+            assert "culture" in facts