deploy

.dockerignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+venv/
+reports/
+uploads/
+.git/
+.env

.gitignore

@@ -0,0 +1,29 @@
+# Python virtual environment
+venv/
+/venv/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# User-specific files
+uploads/
+reports/
+
+# Configuration and secrets
+# IMPORTANT: This prevents your API keys from being uploaded to GitHub
+.env
+
+# IDE and editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS-specific files
+.DS_Store
+Thumbs.db
+
+# Matplotlib cache
+*.png
+!/path/to/keep/some/images/

DEPLOYMENT.md

@@ -0,0 +1,156 @@
+# 🚀 Deploying AI Product Coach to Hugging Face Spaces
+
+## Step-by-Step Deployment Guide
+
+### 1. Prepare Your Repository
+
+Make sure you have these files in your project:
+- `app.py` - Main application file
+- `requirements.txt` - Python dependencies
+- `README.md` - Project documentation (with HF metadata header)
+- `config.py` - Configuration file
+- `modules/` - All module files
+- `voice_model/` - TTS model files
+
+### 2. Create Hugging Face Space
+
+1. Go to [huggingface.co/spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. Fill in the details:
+   - **Space name**: `ai-product-coach` (or your choice)
+   - **License**: MIT
+   - **Select the SDK**: Gradio
+   - **Hardware**: CPU (free tier is sufficient)
+   - **Visibility**: Public
+
+### 3. Upload Files
+
+**Option A: Git Upload (Recommended)**
+```bash
+# Clone your new space
+git clone https://huggingface.co/spaces/YOUR_USERNAME/ai-product-coach
+cd ai-product-coach
+
+# Copy all your files to this directory
+cp -r /path/to/your/project/* .
+
+# Add the HF metadata to README.md (first lines)
+---
+title: AI Product Coach
+emoji: 🎯
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Push to HuggingFace
+git add .
+git commit -m "Initial deployment of AI Product Coach"
+git push
+```
+
+**Option B: Web Upload**
+- Use the HuggingFace web interface to drag and drop files
+- Make sure to upload all directories and files
+
+### 4. Configure Environment Variables
+
+1. Go to your Space settings
+2. Navigate to "Variables and secrets"
+3. Add these environment variables:
+   - **Name**: `GROQ_API_KEY`
+   - **Value**: Your Groq API key from [console.groq.com](https://console.groq.com/keys)
+
+### 5. Required File Structure
+
+Your Hugging Face Space should have:
+```
+├── app.py
+├── requirements.txt
+├── README.md (with metadata header)
+├── config.py
+├── modules/
+│   ├── __init__.py
+│   ├── doc_processor.py
+│   ├── llm_handler.py
+│   ├── report_generator.py
+│   ├── stt_handler.py
+│   ├── tts_handler.py
+│   └── web_search.py
+└── voice_model/
+    ├── en_US-lessac-medium.onnx
+    └── en_US-lessac-medium.onnx.json
+```
+
+### 6. Key Changes for HuggingFace
+
+✅ **Already Done:**
+- Removed `pyaudio` from requirements (not compatible with HF)
+- Updated app launch configuration to detect HF environment
+- Added proper metadata header format
+- Configured for 0.0.0.0 hosting when in HF environment
+
+### 7. Testing & Debugging
+
+1. **Check Build Logs**: Monitor the build process in your Space
+2. **Test Features**: 
+   - Text input/output
+   - File upload (resume)
+   - PDF report generation
+3. **Audio Features**: Note that audio recording may have limitations in web browsers
+
+### 8. Post-Deployment
+
+1. **Share Your Space**: Get the URL `https://huggingface.co/spaces/YOUR_USERNAME/SPACE_NAME`
+2. **Add to Portfolio**: Include in your projects and CV
+3. **Community**: Consider adding to HF collections or model cards
+
+## 🔧 Troubleshooting
+
+### Common Issues:
+
+**Build Failures:**
+- Check requirements.txt for incompatible packages
+- Verify all file paths are relative
+- Ensure no missing imports
+
+**API Errors:**
+- Verify GROQ_API_KEY is set correctly
+- Check API quota limits
+- Test API key in local environment first
+
+**Audio Issues:**
+- Audio recording requires HTTPS (HF provides this)
+- Some browsers may block microphone access
+- Fallback to text input is always available
+
+**Memory Issues:**
+- Consider using CPU-optimized models
+- Implement proper cleanup in functions
+- Monitor Space resource usage
+
+## 🎯 Success Checklist
+
+- [ ] Space builds without errors
+- [ ] All coaching types work
+- [ ] Resume upload functions
+- [ ] PDF reports generate
+- [ ] Text interaction works
+- [ ] API key configured
+- [ ] Error handling works
+- [ ] Professional appearance
+
+## 🌟 Optional Enhancements
+
+After successful deployment, consider:
+- Adding more coaching areas
+- Implementing user analytics
+- Adding feedback collection
+- Creating demo videos
+- Writing blog post about the project
+
+Your AI Product Coach is now ready to help users prepare for PM interviews! 🎉

DOCKERFILE

@@ -0,0 +1,25 @@
+# Use an official Python runtime as a parent image
+FROM python:3.11-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container
+COPY requirements.txt .
+
+# Install any needed system dependencies (like for audio)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install the Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application's code into the container
+COPY . .
+
+# Expose the port that Gradio runs on
+EXPOSE 7860
+
+# Define the command to run your application
+CMD ["python3", "app.py"]

README.md

@@ -1,12 +1,106 @@
 ---
-title: Product Ai
-emoji: 🐠
-colorFrom: pink
-colorTo: green
+title: AI Product Coach
+emoji: 🎯
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 5.42.0
+sdk_version: 4.44.0
 app_file: app.py
 pinned: false
+license: mit
+short_description: AI-powered PM interview preparation with personalized coaching
+tags:
+- product-management
+- interview-prep
+- ai-coaching
+- career-development
+- gradio
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🎯 AI Product Coach - PM Interview Preparation
+
+An AI-powered coaching application designed to help aspiring Product Managers prepare for interviews through realistic scenarios and personalized feedback.
+
+## 🌟 Features
+
+- **11 Coaching Areas**: Product Strategy, Market Research, UX Design, Roadmap Planning, Metrics & Analytics, and more
+- **Resume-Based Personalization**: Upload your resume for personalized interview scenarios
+- **Voice Interaction**: Record audio responses for more realistic interview practice  
+- **Professional Reports**: Generate comprehensive PDF coaching reports with visual analysis
+- **Real-time Feedback**: Get detailed evaluation and improvement suggestions
+- **Realistic Scenarios**: Practice with 55+ authentic PM interview questions
+
+## 🚀 How to Use
+
+1. **Select Focus Area**: Choose from 11 product management coaching areas
+2. **Upload Resume** (Optional): Get personalized questions based on your background
+3. **Practice**: Answer interview questions via text or voice
+4. **Get Feedback**: Receive detailed coaching analysis and scores
+5. **Download Report**: Generate professional PDF reports for review
+
+## 🛠️ Setup & Configuration
+
+### Hugging Face Spaces Deployment
+
+This app is configured to run on Hugging Face Spaces. You'll need:
+
+1. A Groq API key (free at [console.groq.com](https://console.groq.com/keys))
+2. Set the `GROQ_API_KEY` environment variable in your Space settings
+
+### Local Development
+
+1. Clone the repository
+2. Install requirements: `pip install -r requirements.txt`
+3. Create `.env` file with your `GROQ_API_KEY`
+4. Run: `python app.py`
+
+## 📋 Coaching Areas
+
+- **Product Strategy & Vision** - Strategic thinking and vision articulation
+- **Market Research & Analysis** - Data analysis and market understanding  
+- **User Experience & Design Thinking** - User empathy and design process
+- **Product Roadmap Planning** - Prioritization and planning skills
+- **Metrics & Analytics** - Data literacy and analytical thinking
+- **Stakeholder Management** - Communication and relationship building
+- **Product Launch Strategy** - Execution and cross-functional leadership
+- **Competitive Analysis** - Market analysis and opportunity recognition
+- **Feature Prioritization** - Decision making and framework application
+- **Customer Development** - Customer empathy and insight generation
+- **Resume & Application Strategy** - Personal branding and interview preparation
+
+## 🤖 AI Models Used
+
+- **Groq (llama3-8b-8192)** - Question generation and response evaluation
+- **Whisper** - Speech-to-text transcription
+- **System TTS** - Text-to-speech for question delivery
+
+## 📊 Report Features
+
+- Professional PDF formatting
+- Visual progress charts
+- Detailed scenario analysis
+- Personalized improvement recommendations
+- Scoring across key PM competencies
+
+## 🔧 Technical Stack
+
+- **Frontend**: Gradio 4.x
+- **AI/ML**: Groq API, OpenAI Whisper
+- **Document Processing**: PyMuPDF, python-docx
+- **Report Generation**: ReportLab, Matplotlib
+- **Audio Processing**: SpeechRecognition, PyAudio
+
+## 🎯 Target Users
+
+- Aspiring Product Managers preparing for interviews
+- Current PMs looking to improve interview skills
+- Career changers transitioning into Product Management
+- Students studying product management
+
+## 🤝 Contributing
+
+Feel free to open issues or submit pull requests to improve the coaching experience!
+
+## 📄 License
+
+This project is open source and available under the MIT License.

README_HF.md

@@ -0,0 +1,16 @@
+title: AI Product Coach
+emoji: 🎯
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+short_description: AI-powered PM interview preparation with personalized coaching
+tags:
+- product-management
+- interview-prep
+- ai-coaching
+- career-development
+- gradio

app.py

@@ -0,0 +1,354 @@
+# app.py
+import gradio as gr
+import os
+import time
+import datetime
+import random
+import config
+from modules.tts_handler import text_to_speech_file
+from modules.stt_handler import transcribe_audio
+from modules.doc_processor import extract_text_from_document
+from modules.llm_handler import generate_coaching_question, evaluate_response, generate_coaching_feedback, get_overall_score, parse_scores_from_evaluation, get_score_interpretation
+from modules.report_generator import generate_pdf_report
+
+def test_recording():
+    """Simple test to enable recording"""
+    return gr.update(interactive=True), "✅ Recording enabled! Try recording something now."
+
+def start_coaching_session(coaching_type, doc_file, name, num_questions):
+    if not coaching_type:
+        return (
+            {},  # state
+            [{"role": "assistant", "content": "Please select a product management focus area to begin your coaching session."}],  # chatbot
+            None,  # audio_out
+            gr.update(interactive=False),  # audio_in
+            gr.update(interactive=True)  # start_btn
+        )
+    
+    doc_text = ""
+    if doc_file:
+        doc_text = extract_text_from_document(doc_file.name)
+        if "Error" in doc_text or "Unsupported" in doc_text:
+            return (
+                {},  # state
+                [{"role": "assistant", "content": f"Error processing document: {doc_text}. Continuing without document context."}],  # chatbot
+                None,  # audio_out
+                gr.update(interactive=False),  # audio_in
+                gr.update(interactive=True)  # start_btn
+            )
+    
+    initial_state = {
+        "coaching_type": coaching_type, 
+        "doc_text": doc_text,
+        "name": name if name else "Product Manager", 
+        "question_count": int(num_questions),
+        "current_question_num": 1, 
+        "coaching_log": []
+    }
+    
+    first_question = generate_coaching_question(coaching_type, doc_text, 1)
+    initial_state["current_question_text"] = first_question
+    greeting = f"Hello {initial_state['name']}! Welcome to your personal AI product coaching session on {coaching_type}. We'll explore {int(num_questions)} scenarios together. Let's start with the first one:"
+    full_message = f"{greeting}\n\n{first_question}\n\n🎙️ Click the microphone button above to record your response!"
+    
+    tts_prompt = f"{greeting} {first_question}"
+    ai_voice_path = text_to_speech_file(tts_prompt)
+    
+    return (
+        initial_state,  # state
+        [{"role": "assistant", "content": full_message}],  # chatbot
+        ai_voice_path,  # audio_out
+        gr.update(interactive=True),  # audio_in - ENABLE recording
+        gr.update(interactive=False)  # start_btn - disable after starting
+    )
+
+def handle_coaching_turn(user_audio, chatbot_history, current_state):
+    """Handle each coaching turn - one question at a time with immediate feedback"""
+    
+    print(f"🎙️ Audio recording received: {user_audio}")
+    print(f"📝 Current state: {current_state is not None}")
+    print(f"💬 Chat history length: {len(chatbot_history) if chatbot_history else 0}")
+    
+    # Check if we have valid inputs
+    if not user_audio:
+        print("❌ No audio received - returning early")
+        return chatbot_history, current_state, gr.update(interactive=True), gr.update(visible=False), None
+    
+    if not current_state or "current_question_text" not in current_state:
+        print("❌ Invalid session state - returning early")
+        return chatbot_history, current_state, gr.update(interactive=True), gr.update(visible=False), None
+    
+    print(f"✅ Processing audio file: {user_audio}")
+    
+    # Transcribe user response
+    try:
+        user_response_text = transcribe_audio(user_audio)
+        print(f"✅ Transcribed: {user_response_text[:100]}...")
+        
+        if user_response_text.startswith("Sorry, I") or "error" in user_response_text.lower():
+            # Transcription failed, return error message
+            if not chatbot_history:
+                chatbot_history = []
+            chatbot_history.append({"role": "assistant", "content": user_response_text})
+            return chatbot_history, current_state, gr.update(interactive=True), gr.update(visible=False), None
+            
+    except Exception as e:
+        print(f"❌ Transcription error: {e}")
+        error_msg = "Sorry, I couldn't process your audio. Please try recording again."
+        if not chatbot_history:
+            chatbot_history = []
+        chatbot_history.append({"role": "assistant", "content": error_msg})
+        return chatbot_history, current_state, gr.update(interactive=True), gr.update(visible=False), None
+    
+    # Initialize chat history if empty
+    if not chatbot_history:
+        chatbot_history = []
+    
+    # Add user response to chat
+    chatbot_history.append({"role": "user", "content": user_response_text})
+    
+    # Get feedback from AI
+    try:
+        feedback_text = evaluate_response(
+            current_state["current_question_text"], 
+            user_response_text, 
+            current_state["coaching_type"]
+        )
+        
+        # Parse scores
+        scores = parse_scores_from_evaluation(feedback_text)
+        overall_score = get_overall_score(scores)
+        score_interpretation = get_score_interpretation(overall_score)
+        
+        # Add score to feedback
+        if overall_score > 0:
+            score_summary = f"📊 SCORE: {overall_score}/10 - {score_interpretation}\n\n"
+            feedback_with_score = score_summary + feedback_text
+        else:
+            feedback_with_score = feedback_text
+        
+    except Exception as e:
+        print(f"❌ Evaluation error: {e}")
+        feedback_with_score = "Thank you for your response. Let me give you some feedback on your approach."
+        overall_score = 7  # Default score
+        scores = {}
+    
+    # Store in coaching log
+    current_state["coaching_log"].append({
+        "question": current_state["current_question_text"],
+        "response": user_response_text,
+        "feedback": feedback_with_score,
+        "scores": scores,
+        "overall_score": overall_score
+    })
+    
+    # Add AI feedback to chat
+    chatbot_history.append({"role": "assistant", "content": feedback_with_score})
+    
+    # Generate voice feedback (with error handling)
+    try:
+        ai_feedback_voice = text_to_speech_file(f"Your score is {overall_score} out of 10. {feedback_text[:100]}...")
+    except Exception as e:
+        print(f"❌ TTS error: {e}")
+        ai_feedback_voice = None
+    
+    # Check if session is complete
+    if current_state["current_question_num"] >= current_state["question_count"]:
+        # Session complete - generate report
+        session_scores = [item.get("overall_score", 0) for item in current_state["coaching_log"]]
+        avg_score = sum(session_scores) / len(session_scores) if session_scores else 0
+        session_interpretation = get_score_interpretation(avg_score)
+        
+        end_message = f"🎉 Session Complete!\n\n📈 FINAL AVERAGE: {avg_score:.1f}/10 - {session_interpretation}\n\nGenerating your report..."
+        chatbot_history.append({"role": "assistant", "content": end_message})
+        
+        # Generate PDF report
+        try:
+            pdf_path = generate_pdf_file(current_state)
+            print(f"✅ Report generated: {pdf_path}")
+        except Exception as e:
+            print(f"❌ Report generation error: {e}")
+            pdf_path = None
+        
+        try:
+            end_voice = text_to_speech_file("Congratulations! Your coaching session is complete.")
+        except Exception as e:
+            print(f"❌ TTS error: {e}")
+            end_voice = ai_feedback_voice
+        
+        return (
+            chatbot_history,
+            current_state,
+            gr.update(interactive=False),  # Disable recording
+            gr.update(value=pdf_path, visible=True) if pdf_path else gr.update(visible=False),  # Show download button
+            end_voice
+        )
+    else:
+        # Move to next question
+        current_state["current_question_num"] += 1
+        next_question = generate_coaching_question(
+            current_state["coaching_type"], 
+            current_state["doc_text"], 
+            current_state["current_question_num"]
+        )
+        current_state["current_question_text"] = next_question
+        
+        q_num = current_state["current_question_num"]
+        next_message = f"🎯 Question {q_num}/{current_state['question_count']}:\n\n{next_question}"
+        chatbot_history.append({"role": "assistant", "content": next_message})
+        
+        # Generate voice for next question
+        try:
+            next_voice = text_to_speech_file(f"Question {q_num}. {next_question}")
+        except Exception as e:
+            print(f"❌ TTS error: {e}")
+            next_voice = ai_feedback_voice
+        
+        return (
+            chatbot_history,
+            current_state,
+            gr.update(interactive=True),  # Keep recording enabled
+            gr.update(visible=False),  # Keep download hidden
+            next_voice
+        )
+
+def generate_pdf_file(state):
+    final_data = { 
+        "name": state["name"], 
+        "type": state["coaching_type"], 
+        "q_and_a": state["coaching_log"]
+    }
+    file_name = f"Product_Coaching_Report_{state['name']}_{datetime.datetime.now().strftime('%Y-%m-%d')}.pdf"
+    file_path = os.path.join(config.REPORT_FOLDER, file_name)
+    generate_pdf_report(final_data, file_path)
+    return file_path
+
+with gr.Blocks(theme=gr.themes.Default()) as app:
+    state = gr.State({})
+    gr.Markdown("# 🚀 Personal AI Product Coach")
+    gr.Markdown("### Elevate your product management skills with personalized coaching sessions")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Setup Your Coaching Session")
+            user_name = gr.Textbox(label="Your Name", placeholder="Enter your name")
+            
+            coaching_type_dd = gr.Dropdown(
+                config.COACHING_TYPES, 
+                label="Product Management Focus Area"
+            )
+            gr.Markdown("*Choose the area you want to improve*")
+            
+            num_questions_slider = gr.Slider(
+                minimum=1, maximum=10, value=5, step=1, 
+                label="Number of Scenarios"
+            )
+            gr.Markdown("*How many coaching scenarios do you want to practice?*")
+            
+            doc_uploader = gr.File(
+                label="Upload Your Resume/Portfolio (Optional)", 
+                file_types=[".pdf", ".docx", ".txt"]
+            )
+            gr.Markdown("*Upload your resume or product portfolio for personalized coaching*")
+            
+            start_btn = gr.Button("🎯 Start Coaching Session", variant="primary")
+            
+        with gr.Column(scale=2):
+            chatbot = gr.Chatbot(
+                label="AI Product Coach", 
+                height=500,
+                type="messages"
+            )
+            
+            with gr.Row():
+                # Use a simpler audio input approach
+                audio_in = gr.Audio(
+                    sources=["microphone"], 
+                    type="filepath", 
+                    label="🎙️ Record Your Response", 
+                    interactive=False,
+                    show_download_button=False
+                )
+                # Add manual submit button for reliability
+                submit_audio_btn = gr.Button("📤 Submit Audio", variant="secondary", visible=False)
+            
+            # Add a test button to check if recording works
+            test_btn = gr.Button("🧪 Test Recording", variant="secondary", visible=True)
+            status_text = gr.Textbox(label="Status", value="Click 'Start Coaching Session' to begin", interactive=False)
+            
+            download_pdf_btn = gr.File(label="📊 Download Coaching Report", visible=False)
+            audio_out = gr.Audio(visible=False, autoplay=True)
+
+    start_btn.click(
+        fn=start_coaching_session,
+        inputs=[coaching_type_dd, doc_uploader, user_name, num_questions_slider],
+        outputs=[state, chatbot, audio_out, audio_in, start_btn]
+    )
+    
+    test_btn.click(
+        fn=test_recording,
+        outputs=[audio_in, status_text]
+    )
+    
+    # Multiple event handlers for better reliability
+    audio_in.change(
+        fn=handle_coaching_turn,
+        inputs=[audio_in, chatbot, state],
+        outputs=[chatbot, state, audio_in, download_pdf_btn, audio_out]
+    )
+    
+    # Also try upload event
+    audio_in.upload(
+        fn=handle_coaching_turn,
+        inputs=[audio_in, chatbot, state],
+        outputs=[chatbot, state, audio_in, download_pdf_btn, audio_out]
+    )
+    
+    # Manual submit button as backup
+    submit_audio_btn.click(
+        fn=handle_coaching_turn,
+        inputs=[audio_in, chatbot, state],
+        outputs=[chatbot, state, audio_in, download_pdf_btn, audio_out]
+    )
+    
+    # Add footer with helpful information
+    gr.Markdown("""
+    ---
+    ### 💡 Coaching Tips
+    - **Speak naturally** - Think out loud and explain your reasoning
+    - **Use frameworks** - Apply PM frameworks like RICE, Jobs-to-be-Done, etc.
+    - **Be specific** - Provide concrete examples and metrics when possible
+    - **Ask questions** - Great PMs ask clarifying questions about requirements
+    
+    ### 🎯 What Makes a Great Response?
+    ✅ Clear problem identification  
+    ✅ Structured thinking approach  
+    ✅ Data-driven reasoning  
+    ✅ Stakeholder consideration  
+    ✅ Action-oriented next steps  
+    """)
+
+if __name__ == "__main__":
+    # Ensure required directories exist
+    os.makedirs(config.UPLOAD_FOLDER, exist_ok=True)
+    os.makedirs(config.REPORT_FOLDER, exist_ok=True)
+    
+    # Print startup message
+    print("🚀 Personal AI Product Coach Starting...")
+    print("📚 Focus Areas Available:", ", ".join(config.COACHING_TYPES))
+    print("🎯 Ready to help you improve your product management skills!")
+    print("=" * 60)
+    
+    # Check for API key
+    if not config.GROQ_API_KEY:
+        print("⚠️  WARNING: GROQ_API_KEY not found!")
+        print("Please set your Groq API key as an environment variable.")
+        print("Get your free key from: https://console.groq.com/keys")
+    
+    # Launch the app - Configure for both local and HuggingFace deployment
+    app.launch(
+        server_name="0.0.0.0" if os.getenv("SPACE_ID") else "127.0.0.1",
+        server_port=None if os.getenv("SPACE_ID") else 7861,
+        share=False,
+        show_error=True
+    )

app_readme.md

@@ -0,0 +1,61 @@
+---
+title: AI Product Coach
+emoji: 🎯
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+short_description: AI-powered PM interview preparation with personalized coaching
+tags:
+- product-management
+- interview-prep
+- ai-coaching
+- career-development
+- gradio
+---
+
+# 🎯 AI Product Coach - PM Interview Preparation
+
+An AI-powered coaching application designed to help aspiring Product Managers prepare for interviews through realistic scenarios and personalized feedback.
+
+## 🌟 Features
+
+- **11 Coaching Areas**: Product Strategy, Market Research, UX Design, Roadmap Planning, Metrics & Analytics, and more
+- **Resume-Based Personalization**: Upload your resume for personalized interview scenarios
+- **Voice Interaction**: Record audio responses for more realistic interview practice  
+- **Professional Reports**: Generate comprehensive PDF coaching reports with visual analysis
+- **Real-time Feedback**: Get detailed evaluation and improvement suggestions
+- **Realistic Scenarios**: Practice with 55+ authentic PM interview questions
+
+## 🚀 How to Use
+
+1. **Select Focus Area**: Choose from 11 product management coaching areas
+2. **Upload Resume** (Optional): Get personalized questions based on your background
+3. **Practice**: Answer interview questions via text or voice
+4. **Get Feedback**: Receive detailed coaching analysis and scores
+5. **Download Report**: Generate professional PDF reports for review
+
+## ⚙️ Configuration Required
+
+**Important**: This app requires a Groq API key to function. 
+
+1. Get your free API key from [console.groq.com](https://console.groq.com/keys)
+2. In your Hugging Face Space settings, add the environment variable:
+   - **Variable Name**: `GROQ_API_KEY`
+   - **Variable Value**: Your Groq API key
+
+## 🤖 AI Models Used
+
+- **Groq (llama3-8b-8192)** - Question generation and response evaluation
+- **Whisper** - Speech-to-text transcription
+- **System TTS** - Text-to-speech for question delivery
+
+## 🔧 Technical Stack
+
+- **Frontend**: Gradio 4.x
+- **AI/ML**: Groq API, OpenAI Whisper
+- **Document Processing**: PyMuPDF, python-docx
+- **Report Generation**: ReportLab, Matplotlib

config.py

@@ -0,0 +1,54 @@
+# config.py
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# -- API Configuration --
+GROQ_API_KEY = os.getenv('GROQ_API_KEY')
+GROQ_MODEL = os.getenv('GROQ_MODEL', 'llama3-8b-8192')  # Default model
+DEBUG_MODE = os.getenv('DEBUG', 'false').lower() == 'true'
+
+# Validate API key
+if not GROQ_API_KEY:
+    print("⚠️  WARNING: GROQ_API_KEY not found!")
+    print("Please set your Groq API key in one of these ways:")
+    print("1. Create a .env file with: GROQ_API_KEY=your_api_key")
+    print("2. Set environment variable: export GROQ_API_KEY=your_api_key")
+    print("3. Get your free key from: https://console.groq.com/keys")
+
+# -- Ollama Configuration (Legacy) --
+OLLAMA_MODEL = 'llama3.1' 
+
+# -- Product Coaching Configuration --
+COACHING_TYPES = [
+    'Product Strategy & Vision',
+    'Market Research & Analysis',
+    'User Experience & Design Thinking',
+    'Product Roadmap Planning',
+    'Metrics & Analytics',
+    'Stakeholder Management',
+    'Product Launch Strategy',
+    'Competitive Analysis',
+    'Feature Prioritization',
+    'Customer Development',
+    'Resume & Application Strategy'
+]
+
+# -- Product Management Focus Areas --
+FOCUS_AREAS = [
+    'Product Discovery',
+    'Product Development',
+    'Go-to-Market Strategy',
+    'Product Optimization',
+    'Team Leadership',
+    'Data-Driven Decisions'
+]
+
+# -- Piper TTS Configuration --
+PIPER_VOICE_MODEL = './voice_model/en_US-lessac-medium.onnx' 
+
+# -- Directories --
+UPLOAD_FOLDER = 'uploads'
+REPORT_FOLDER = 'reports'

deploy.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+
+# 🚀 AI Product Coach - Hugging Face Deployment Script
+# This script helps prepare your app for Hugging Face Spaces deployment
+
+echo "🎯 AI Product Coach - Hugging Face Deployment Preparation"
+echo "=========================================================="
+
+# Check if we're in the right directory
+if [ ! -f "app.py" ]; then
+    echo "❌ Error: app.py not found. Please run this script from the project root directory."
+    exit 1
+fi
+
+echo "✅ Found app.py - you're in the right directory"
+
+# Check for required files
+required_files=("app.py" "config.py" "requirements.txt" "README.md")
+missing_files=()
+
+for file in "${required_files[@]}"; do
+    if [ ! -f "$file" ]; then
+        missing_files+=("$file")
+    fi
+done
+
+if [ ${#missing_files[@]} -ne 0 ]; then
+    echo "❌ Missing required files: ${missing_files[*]}"
+    exit 1
+fi
+
+echo "✅ All required files present"
+
+# Check for modules directory
+if [ ! -d "modules" ]; then
+    echo "❌ Error: modules/ directory not found"
+    exit 1
+fi
+
+echo "✅ Found modules directory"
+
+# Check if README has HF metadata
+if ! grep -q "title: AI Product Coach" README.md; then
+    echo "⚠️  Warning: README.md missing Hugging Face metadata"
+    echo "   The metadata header has already been added to your README.md"
+fi
+
+echo "✅ README.md has proper HF metadata"
+
+# Check for API key configuration
+if ! grep -q "GROQ_API_KEY" config.py; then
+    echo "❌ Error: GROQ_API_KEY configuration not found in config.py"
+    exit 1
+fi
+
+echo "✅ API key configuration found"
+
+# Display next steps
+echo ""
+echo "🎉 Deployment Preparation Complete!"
+echo ""
+echo "Next Steps:"
+echo "1. Get your Groq API key from: https://console.groq.com/keys"
+echo "2. Create a new Hugging Face Space at: https://huggingface.co/spaces"
+echo "3. Upload all files to your Space (or use git clone/push)"
+echo "4. Set GROQ_API_KEY as environment variable in Space settings"
+echo "5. Wait for build to complete and test your app!"
+echo ""
+echo "📚 See DEPLOYMENT.md for detailed instructions"
+echo ""
+echo "Your AI Product Coach is ready for deployment! 🚀"

modules/doc_processor.py

@@ -0,0 +1,29 @@
+# modules/doc_processor.py
+
+import fitz  # PyMuPDF for PDFs
+import docx  # python-docx for DOCX files
+import os
+
+def extract_text_from_document(file_path):
+    """
+    Extracts text from a given document (PDF or DOCX).
+    """
+    text = ""
+    try:
+        _, file_extension = os.path.splitext(file_path)
+
+        if file_extension.lower() == '.pdf':
+            with fitz.open(file_path) as doc:
+                for page in doc:
+                    text += page.get_text()
+        elif file_extension.lower() == '.docx':
+            doc = docx.Document(file_path)
+            for para in doc.paragraphs:
+                text += para.text + "\n"
+        else:
+            return "Unsupported file format. Please upload a .pdf or .docx file."
+    
+    except Exception as e:
+        return f"Error reading document: {e}"
+
+    return text

modules/llm_handler.py

@@ -0,0 +1,385 @@
+# modules/llm_handler.py
+import os
+import config
+import regex as re
+from groq import Groq
+from modules.web_search import search_for_example_answers
+from modules.pm_frameworks import get_framework_suggestion, get_relevant_metrics
+
+# Initialize the Groq client with proper error handling
+def get_groq_client():
+    api_key = config.GROQ_API_KEY or os.environ.get("GROQ_API_KEY")
+    if not api_key:
+        raise ValueError("GROQ_API_KEY is required. Please set it in .env file or environment variables.")
+    return Groq(api_key=api_key)
+
+try:
+    client = get_groq_client()
+    MODEL = config.GROQ_MODEL
+    print(f"✅ Groq API connected successfully with model: {MODEL}")
+except Exception as e:
+    print(f"❌ Failed to initialize Groq client: {e}")
+    client = None
+    MODEL = "llama3-8b-8192"
+
+def generate_coaching_question(coaching_type, document_text, question_number):
+    """Generate a personalized, interview-style product management coaching question based on resume."""
+    
+    if not client:
+        return "I need to ask you a product management scenario, but there's an API connection issue."
+    
+    # Base scenarios for each coaching type
+    base_scenarios = {
+        'Product Strategy & Vision': [
+            "developing product vision for a struggling mobile application",
+            "evaluating a strategic pivot from B2C to B2B",
+            "presenting product strategy to secure funding",
+            "responding to competitive threats strategically",
+            "integrating acquired startup products"
+        ],
+        'Market Research & Analysis': [
+            "conducting competitive analysis after competitor launch",
+            "expanding into new geographic markets",
+            "resolving conflicting user research feedback",
+            "researching with limited budget constraints",
+            "validating demand for new product category"
+        ],
+        'User Experience & Design Thinking': [
+            "redesigning high drop-off onboarding flow",
+            "investigating declining Net Promoter Score",
+            "balancing UX goals with technical constraints",
+            "prioritizing UX improvements across segments",
+            "leading design sprint for new experience"
+        ],
+        'Product Roadmap Planning': [
+            "prioritizing features with limited engineering capacity",
+            "handling sales pressure vs roadmap alignment",
+            "communicating roadmap changes after setbacks",
+            "re-prioritizing due to security vulnerabilities",
+            "adjusting roadmap for aggressive growth targets"
+        ],
+        'Metrics & Analytics': [
+            "investigating sudden drop in engagement metrics",
+            "defining success metrics for new premium tier",
+            "designing A/B test for conversion optimization",
+            "selecting North Star metric for product team",
+            "analyzing low-adoption, high-engagement features"
+        ],
+        'Stakeholder Management': [
+            "navigating conflicting priorities across teams",
+            "managing stakeholder disagreement and escalation",
+            "building alignment across multiple teams",
+            "resolving timeline conflicts with engineering",
+            "handling customer churn threats and demands"
+        ],
+        'Product Launch Strategy': [
+            "handling critical bugs close to launch",
+            "designing go-to-market for enterprise expansion",
+            "deciding on launch with mixed early metrics",
+            "adjusting strategy due to competitor timing",
+            "managing feature impact on core metrics"
+        ],
+        'Competitive Analysis': [
+            "responding to well-funded direct competitor",
+            "analyzing acquisition threat in adjacent space",
+            "capitalizing on competitor retention struggles",
+            "competing against superior marketing with inferior product",
+            "defending against tech giant market entry"
+        ],
+        'Feature Prioritization': [
+            "prioritizing with limited resources and high impact opportunities",
+            "balancing customer demands vs product vision",
+            "evaluating build vs buy vs partner decisions",
+            "weighing revenue features vs foundational improvements",
+            "deciding on resource allocation for new capabilities"
+        ],
+        'Customer Development': [
+            "investigating low adoption of launched features",
+            "structuring customer interviews for validation",
+            "managing custom feature requests from major customers",
+            "addressing user confusion while maintaining power features",
+            "analyzing high new-user churn vs strong retention"
+        ],
+        'Resume & Application Strategy': [
+            "positioning experience for fintech PM role transition",
+            "demonstrating quantified impact in interviews",
+            "addressing PM framework gaps during applications",
+            "showcasing PM skills from non-PM background",
+            "differentiating against FAANG-experienced candidates"
+        ]
+    }
+    
+    scenarios = base_scenarios.get(coaching_type, [
+        "solving complex product management challenge",
+        "making strategic product decision under pressure",
+        "applying PM frameworks to real-world scenario"
+    ])
+    
+    # Select base scenario
+    scenario_index = (question_number - 1) % len(scenarios)
+    base_scenario = scenarios[scenario_index]
+    
+    # Create personalized prompt using resume context
+    if document_text and document_text.strip():
+        prompt = f"""You are an expert product management interviewer. Generate ONE realistic, challenging PM interview question that:
+
+1. Focuses on: {base_scenario}
+2. Is tailored to this candidate's background: {document_text[:1000]}
+3. Coaching area: {coaching_type}
+
+Create a specific scenario with:
+- Realistic context (company size, industry, metrics)
+- Clear constraints and timeline
+- Multiple stakeholders involved
+- Quantifiable elements (users, revenue, etc.)
+
+Make it feel like a real PM interview question that considers their background. Keep it focused and actionable.
+
+Example format: "You're the PM at [specific company type]. [Specific situation with numbers]. [Key challenge]. How do you approach this?"
+
+Generate just the question scenario, no additional text:"""
+    else:
+        prompt = f"""You are an expert product management interviewer. Generate ONE realistic, challenging PM interview question about {base_scenario} in the {coaching_type} area.
+
+Create a specific scenario with:
+- Realistic context (company size, industry, metrics)
+- Clear constraints and timeline  
+- Multiple stakeholders involved
+- Quantifiable elements (users, revenue, etc.)
+
+Example format: "You're the PM at [specific company type]. [Specific situation with numbers]. [Key challenge]. How do you approach this?"
+
+Generate just the question scenario, no additional text:"""
+    
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[{"role": "user", "content": prompt}],
+            model=MODEL,
+            temperature=0.7,
+            max_tokens=200
+        )
+        generated_question = chat_completion.choices[0].message.content.strip()
+        
+        # Add context note if resume was provided
+        if document_text and document_text.strip():
+            context_note = "\n\nNote: Consider your background and experience when answering."
+            return generated_question + context_note
+        
+        return generated_question
+        
+    except Exception as e:
+        print(f"❌ Error generating personalized question: {e}")
+        # Fallback to basic scenario
+        fallback_questions = {
+            'Product Strategy & Vision': f"You're the PM for a mobile app with declining user engagement. How would you develop a new product vision to turn this around?",
+            'Market Research & Analysis': f"A competitor just launched a feature similar to yours. How do you conduct competitive analysis and determine your response?",
+            'Resume & Application Strategy': f"You're applying for a Senior PM role but lack direct PM experience. How do you position your background effectively?"
+        }
+        return fallback_questions.get(coaching_type, f"Walk me through how you'd approach {base_scenario} as a product manager.")
+
+def evaluate_response(question, response, coaching_type):
+    """Advanced product management coaching evaluation with comprehensive feedback."""
+    
+    if not client:
+        return "Unable to provide feedback - API connection issue. Please check your Groq API key."
+    
+    # Get relevant frameworks for this coaching type
+    suggested_frameworks = get_framework_suggestion('general', coaching_type)
+    framework_names = [fw['name'] for fw in suggested_frameworks[:2]]  # Top 2 frameworks
+    
+    # Get relevant metrics
+    relevant_metrics = get_relevant_metrics(coaching_type)[:3]  # Top 3 metrics
+    
+    # Advanced evaluation prompt with scoring criteria - requesting clean formatting
+    prompt = f"""
+    You are a world-class product management coach and former VP of Product at top tech companies. 
+    Evaluate this product manager's response with the depth and insight of an experienced mentor.
+
+    SCENARIO: {question}
+
+    PM'S RESPONSE: {response}
+
+    COACHING AREA: {coaching_type}
+
+    Please provide a professional coaching evaluation using this EXACT structure (no markdown formatting, no ** or # symbols):
+
+    EVALUATION SCORES (Rate 1-10 for each):
+    • Strategic Thinking: [X]/10 - How well they approached the big picture
+    • Problem Analysis: [X]/10 - Depth of problem understanding  
+    • Framework Application: [X]/10 - Use of PM methodologies
+    • Stakeholder Awareness: [X]/10 - Consideration of different perspectives
+    • Execution Focus: [X]/10 - Practicality and actionability
+    • Communication: [X]/10 - Clarity and structure of response
+
+    STRENGTHS:
+    [List 2-3 specific things they did well]
+
+    AREAS FOR GROWTH:
+    [List 2-3 specific areas for improvement]
+
+    FRAMEWORK RECOMMENDATIONS:
+    Consider applying: {', '.join(framework_names) if framework_names else 'RICE prioritization, Jobs-to-be-Done'}
+    
+    KEY METRICS TO TRACK:
+    Focus on: {', '.join(relevant_metrics) if relevant_metrics else 'user engagement, business impact'}
+
+    ACTIONABLE NEXT STEPS:
+    [1-2 concrete actions they can take]
+
+    EXPERT INSIGHT:
+    [One advanced tip that a seasoned PM would know]
+
+    IMPORTANT: Use plain text formatting only - NO markdown symbols like ** or # or _. Keep it professional and readable.
+    """
+    
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": "You are an expert product management coach with 15+ years of experience. Provide detailed, actionable feedback using clean, professional formatting without markdown symbols."},
+                {"role": "user", "content": prompt}
+            ],
+            model=MODEL,
+            temperature=0.7,  # Slightly creative but consistent
+            max_tokens=1000   # Allow for comprehensive feedback
+        )
+        return chat_completion.choices[0].message.content
+        
+    except Exception as e:
+        # Fallback response with framework suggestions
+        framework_text = f" Consider applying {framework_names[0]} framework" if framework_names else ""
+        metric_text = f" Focus on metrics like {relevant_metrics[0]}" if relevant_metrics else ""
+        
+        return f"""
+        FEEDBACK: Great thinking on this scenario!{framework_text}.{metric_text}
+        
+        STRENGTHS: You showed good product thinking and approached the problem systematically.
+        
+        AREAS FOR GROWTH: Consider exploring more PM frameworks and being more specific about metrics and success criteria.
+        
+        NEXT STEPS: Practice more scenarios in {coaching_type} and study relevant PM frameworks.
+        
+        Note: Full AI evaluation unavailable - {str(e)}
+        """
+
+def generate_coaching_feedback(coaching_log, coaching_type, name):
+    """Generate overall coaching feedback based on the entire session."""
+    
+    responses_summary = "\n".join([
+        f"Scenario: {item['question'][:100]}...\nResponse: {item['response'][:200]}...\n"
+        for item in coaching_log
+    ])
+    
+    prompt = f"""
+    You are an expert product management coach providing a comprehensive development summary for {name} who just completed a coaching session on {coaching_type}.
+    
+    SESSION SUMMARY:
+    {responses_summary}
+    
+    Please provide a comprehensive coaching summary that includes:
+    
+    1. **Overall Performance**: Key strengths demonstrated
+    2. **Growth Areas**: 3 specific areas for continued development
+    3. **Recommended Learning**: Books, frameworks, or practices to explore
+    4. **Action Plan**: Concrete next steps for skill development
+    5. **Encouragement**: Motivational closing focused on their PM journey
+    
+    Make it personal, actionable, and encouraging for a product manager's growth.
+    """
+    
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[{"role": "user", "content": prompt}],
+            model=MODEL,
+        )
+        return chat_completion.choices[0].message.content
+    except Exception as e:
+        return f"Excellent work in this {coaching_type} coaching session, {name}! Continue practicing these scenarios and exploring product management frameworks to enhance your skills."
+
+# Legacy function for backward compatibility
+def evaluate_answer(question, answer):
+    """Legacy function - redirects to evaluate_response for coaching context."""
+    return evaluate_response(question, answer, "General Product Management")
+
+def parse_scores_from_evaluation(evaluation_text: str) -> dict:
+    """Extract numerical scores from the advanced evaluation text."""
+    scores = {
+        'Strategic Thinking': 0,
+        'Problem Analysis': 0, 
+        'Framework Application': 0,
+        'Stakeholder Awareness': 0,
+        'Execution Focus': 0,
+        'Communication': 0
+    }
+    
+    # Updated regex patterns for the new scoring format
+    patterns = {
+        'Strategic Thinking': r'Strategic Thinking:\s*(\d+)/10',
+        'Problem Analysis': r'Problem Analysis:\s*(\d+)/10',
+        'Framework Application': r'Framework Application:\s*(\d+)/10', 
+        'Stakeholder Awareness': r'Stakeholder Awareness:\s*(\d+)/10',
+        'Execution Focus': r'Execution Focus:\s*(\d+)/10',
+        'Communication': r'Communication:\s*(\d+)/10'
+    }
+    
+    for category, pattern in patterns.items():
+        match = re.search(pattern, evaluation_text, re.IGNORECASE)
+        if match:
+            try:
+                scores[category] = int(match.group(1))
+            except (ValueError, IndexError):
+                scores[category] = 7  # Default score if parsing fails
+    
+    return scores
+
+def get_overall_score(scores_dict: dict) -> float:
+    """Calculate overall score from individual category scores."""
+    if not scores_dict or not any(scores_dict.values()):
+        return 7.0  # Default score
+    
+    total_score = sum(scores_dict.values())
+    max_possible = len(scores_dict) * 10
+    return round((total_score / max_possible) * 10, 1)
+
+def get_score_interpretation(overall_score: float) -> str:
+    """Provide interpretation of the overall score."""
+    if overall_score >= 9.0:
+        return "🌟 Exceptional - You demonstrated expert-level product management thinking!"
+    elif overall_score >= 8.0:
+        return "🚀 Excellent - Strong PM skills with minor areas for refinement"
+    elif overall_score >= 7.0:
+        return "✅ Good - Solid foundation with clear growth opportunities"
+    elif overall_score >= 6.0:
+        return "📈 Developing - Good start, focus on applying more frameworks"
+    elif overall_score >= 5.0:
+        return "💪 Building - Keep practicing, you're on the right track"
+    else:
+        return "🎯 Learning - Focus on fundamentals and PM best practices"
+    scores = {
+        'Factual Accuracy': 0,
+        'Relevance & Directness': 0,
+        'Structure & Clarity': 0
+    }
+    pattern = r"(Factual Accuracy|Relevance & Directness|Structure & Clarity):\s*\[?(\d{1,2})\]?\/10"
+    matches = re.findall(pattern, evaluation_text, re.IGNORECASE)
+    
+    for match in matches:
+        category_name, score_value = match[0].strip(), int(match[1])
+        if category_name in scores:
+            scores[category_name] = score_value
+            
+    print(f"📊 Parsed scores: {scores}")
+    return scores
+
+def generate_holistic_feedback(full_interview_log):
+    prompt = f"""
+    You are a senior interview coach. Based on the entire Q&A log, provide a high-level "Overall Performance Summary" and an "Actionable Improvement Plan".
+    **FULL INTERVIEW LOG:** --- {full_interview_log} ---
+    """
+    try:
+        chat_completion = client.chat.completions.create(
+            messages=[{"role": "user", "content": prompt}],
+            model=MODEL,
+        )
+        return chat_completion.choices[0].message.content
+    except Exception as e:
+        return "Could not generate holistic feedback due to an error."

modules/pm_frameworks.py

@@ -0,0 +1,161 @@
+# modules/pm_frameworks.py
+"""
+Product Management Frame    
+    'MOSCOW': {
+        'name': 'MoSCoW Prioritization',
+        'description': 'Must have, Should have, Could have, Won\'t have',
+        'use_case': 'Requirements prioritization',
+        'categories': ['Must have', 'Should have', 'Could have', "Won't have (this time)"]
+    },
+    
+    'STAR_RESUME': {
+        'name': 'STAR Method for Resume',
+        'description': 'Situation, Task, Action, Result - Structure for resume bullet points',
+        'use_case': 'Writing impactful resume achievements',
+        'structure': 'Action verb + Context + Impact with metrics'
+    },
+    
+    'RESUME_OPTIMIZATION': {
+        'name': 'PM Resume Optimization Framework',
+        'description': 'Key elements for product management resume success',
+        'use_case': 'Creating compelling PM applications',
+        'components': ['Quantified Impact', 'PM Keywords', 'Framework Application', 'Leadership Examples', 'Technical Skills', 'Stakeholder Management']
+    },
+    
+    'APPLICATION_FUNNEL': {
+        'name': 'Application Success Funnel',
+        'description': 'Systematic approach to PM job applications',
+        'use_case': 'Increasing interview conversion rates',
+        'stages': ['Research & Targeting', 'Resume Tailoring', 'Cover Letter', 'Portfolio/Case Studies', 'Network Activation', 'Follow-up']
+    }
+}d Best Practices
+This module contains common PM frameworks that can be referenced in coaching sessions.
+"""
+
+PM_FRAMEWORKS = {
+    'RICE': {
+        'name': 'RICE Prioritization',
+        'description': 'Reach, Impact, Confidence, Effort - A framework for feature prioritization',
+        'use_case': 'Prioritizing features or initiatives',
+        'formula': 'Score = (Reach × Impact × Confidence) / Effort'
+    },
+    
+    'CIRCLES': {
+        'name': 'CIRCLES Method',
+        'description': 'Comprehend, Identify, Report, Cut, List, Evaluate, Summarize',
+        'use_case': 'Product design interviews and product thinking',
+        'steps': ['Comprehend the situation', 'Identify the customer', 'Report needs', 'Cut through prioritization', 'List solutions', 'Evaluate trade-offs', 'Summarize recommendations']
+    },
+    
+    'JOBS_TO_BE_DONE': {
+        'name': 'Jobs-to-be-Done',
+        'description': 'Focus on what customers hire your product to do',
+        'use_case': 'Understanding customer needs and product-market fit',
+        'statement': 'When I [situation], I want to [motivation], so I can [expected outcome]'
+    },
+    
+    'KANO_MODEL': {
+        'name': 'Kano Model',
+        'description': 'Categorizes features into Must-have, Performance, and Delight',
+        'use_case': 'Feature planning and customer satisfaction',
+        'categories': ['Must-have (Basic)', 'Performance (Linear)', 'Delight (Attractive)']
+    },
+    
+    'LEAN_CANVAS': {
+        'name': 'Lean Canvas',
+        'description': '1-page business model focused on problems, solutions, and key metrics',
+        'use_case': 'Product strategy and business model validation',
+        'sections': ['Problem', 'Solution', 'Key Metrics', 'Unique Value Prop', 'Unfair Advantage', 'Channels', 'Customer Segments', 'Cost Structure', 'Revenue Streams']
+    },
+    
+    'NORTH_STAR': {
+        'name': 'North Star Framework',
+        'description': 'A single metric that captures the core value your product delivers',
+        'use_case': 'Product strategy and team alignment',
+        'components': ['North Star Metric', 'Input Metrics', 'Work Streams']
+    },
+    
+    'DESIGN_SPRINT': {
+        'name': 'Design Sprint',
+        'description': '5-day process for answering critical business questions through design',
+        'use_case': 'Rapid prototyping and validation',
+        'phases': ['Monday: Map', 'Tuesday: Sketch', 'Wednesday: Decide', 'Thursday: Prototype', 'Friday: Test']
+    },
+    
+    'MOSCOW': {
+        'name': 'MoSCoW Prioritization',
+        'description': 'Must have, Should have, Could have, Won\'t have',
+        'use_case': 'Requirements prioritization',
+        'categories': ['Must have', 'Should have', 'Could have', 'Won\'t have']
+    }
+}
+
+PRODUCT_METRICS = {
+    'ENGAGEMENT': ['DAU/MAU', 'Session Duration', 'Feature Adoption', 'Stickiness'],
+    'GROWTH': ['CAC', 'LTV', 'Viral Coefficient', 'Retention Rate'],
+    'BUSINESS': ['Revenue', 'Conversion Rate', 'Churn Rate', 'NPS'],
+    'PRODUCT': ['Time to Value', 'Feature Usage', 'User Satisfaction', 'Task Success Rate']
+}
+
+COACHING_SCENARIOS = {
+    'PRIORITIZATION': [
+        "You have 5 high-impact features but can only build 2 this quarter. How do you decide?",
+        "Engineering is pushing back on your roadmap timeline. How do you respond?",
+        "A key customer is threatening to churn unless you build their feature request."
+    ],
+    
+    'STAKEHOLDER_MANAGEMENT': [
+        "Sales wants feature A, marketing wants feature B, and engineering prefers feature C.",
+        "The CEO wants to add a major feature that doesn't align with your product vision.",
+        "You need to communicate a roadmap delay to frustrated stakeholders."
+    ],
+    
+    'METRICS_ANALYSIS': [
+        "Your key engagement metric dropped 20% last month. How do you investigate?",
+        "You need to prove ROI for a new feature launch to executives.",
+        "Two A/B tests show conflicting results. How do you make a decision?"
+    ],
+    
+    'USER_RESEARCH': [
+        "You're seeing low adoption of a recently launched feature.",
+        "Users are requesting a feature that conflicts with your product vision.",
+        "You need to validate a new product concept with limited research budget."
+    ]
+}
+
+def get_framework_suggestion(scenario_type, coaching_type):
+    """Suggest relevant frameworks based on the coaching scenario."""
+    framework_mapping = {
+        'Product Strategy & Vision': ['LEAN_CANVAS', 'NORTH_STAR', 'JOBS_TO_BE_DONE'],
+        'Market Research & Analysis': ['JOBS_TO_BE_DONE', 'KANO_MODEL'],
+        'User Experience & Design Thinking': ['DESIGN_SPRINT', 'JOBS_TO_BE_DONE', 'KANO_MODEL'],
+        'Product Roadmap Planning': ['RICE', 'MOSCOW', 'KANO_MODEL'],
+        'Metrics & Analytics': ['NORTH_STAR', 'KANO_MODEL'],
+        'Stakeholder Management': ['MOSCOW', 'LEAN_CANVAS'],
+        'Product Launch Strategy': ['DESIGN_SPRINT', 'LEAN_CANVAS'],
+        'Competitive Analysis': ['LEAN_CANVAS', 'KANO_MODEL'],
+        'Feature Prioritization': ['RICE', 'MOSCOW', 'KANO_MODEL'],
+        'Customer Development': ['JOBS_TO_BE_DONE', 'DESIGN_SPRINT'],
+        'Resume & Application Strategy': ['STAR_RESUME', 'RESUME_OPTIMIZATION', 'APPLICATION_FUNNEL']
+    }
+    
+    suggested_frameworks = framework_mapping.get(coaching_type, ['RICE', 'JOBS_TO_BE_DONE'])
+    return [PM_FRAMEWORKS[fw] for fw in suggested_frameworks if fw in PM_FRAMEWORKS]
+
+def get_relevant_metrics(coaching_type):
+    """Get relevant metrics for the coaching area."""
+    metric_mapping = {
+        'Product Strategy & Vision': PRODUCT_METRICS['BUSINESS'] + PRODUCT_METRICS['ENGAGEMENT'],
+        'Market Research & Analysis': PRODUCT_METRICS['GROWTH'],
+        'User Experience & Design Thinking': PRODUCT_METRICS['PRODUCT'] + PRODUCT_METRICS['ENGAGEMENT'],
+        'Product Roadmap Planning': PRODUCT_METRICS['PRODUCT'],
+        'Metrics & Analytics': list(PRODUCT_METRICS.values()),
+        'Stakeholder Management': PRODUCT_METRICS['BUSINESS'],
+        'Product Launch Strategy': PRODUCT_METRICS['GROWTH'] + PRODUCT_METRICS['BUSINESS'],
+        'Competitive Analysis': PRODUCT_METRICS['GROWTH'],
+        'Feature Prioritization': PRODUCT_METRICS['PRODUCT'],
+        'Customer Development': PRODUCT_METRICS['ENGAGEMENT'] + PRODUCT_METRICS['PRODUCT'],
+        'Resume & Application Strategy': ['Application Response Rate', 'Interview Conversion Rate', 'Resume ATS Score', 'Portfolio View Rate', 'Network Response Rate']
+    }
+    
+    return metric_mapping.get(coaching_type, PRODUCT_METRICS['PRODUCT'])

modules/report_generator.py

@@ -0,0 +1,443 @@
+# modules/report_generator.py
+import datetime
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, PageBreak, Image, HRFlowable
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.enums import TA_JUSTIFY, TA_CENTER
+from reportlab.lib.units import inch
+from reportlab.lib import colors
+from modules.llm_handler import generate_coaching_feedback
+import config
+import tempfile
+
+def define_skill_areas(coaching_type):
+    """Define key skill areas based on product management coaching type."""
+    skill_mapping = {
+        'Product Strategy & Vision': ['Strategic Thinking', 'Vision Articulation', 'Business Alignment'],
+        'Market Research & Analysis': ['Research Skills', 'Data Analysis', 'Market Understanding'],
+        'User Experience & Design Thinking': ['User Empathy', 'Design Process', 'Problem Solving'],
+        'Product Roadmap Planning': ['Prioritization', 'Planning', 'Communication'],
+        'Metrics & Analytics': ['Data Literacy', 'Analytical Thinking', 'Decision Making'],
+        'Stakeholder Management': ['Communication', 'Negotiation', 'Relationship Building'],
+        'Product Launch Strategy': ['Execution', 'Planning', 'Cross-functional Leadership'],
+        'Competitive Analysis': ['Market Analysis', 'Strategic Thinking', 'Opportunity Recognition'],
+        'Feature Prioritization': ['Decision Making', 'Framework Application', 'Trade-off Analysis'],
+        'Customer Development': ['Customer Empathy', 'Research Skills', 'Insight Generation'],
+        'Resume & Application Strategy': ['Application Skills', 'Personal Branding', 'Interview Preparation']
+    }
+    return skill_mapping.get(coaching_type, ['Strategic Thinking', 'Problem Solving', 'Communication'])
+
+def create_coaching_progress_chart(labels, file_path):
+    """Create a visual representation of coaching areas covered with error handling."""
+    try:
+        plt.clf()  # Clear any existing plots
+        fig, ax = plt.subplots(figsize=(8, 6))
+        y_pos = np.arange(len(labels))
+        
+        # Create a progress-style chart
+        progress_values = [100] * len(labels)  # All areas were covered
+        colors_list = plt.cm.Blues(np.linspace(0.4, 0.8, len(labels)))
+        
+        bars = ax.barh(y_pos, progress_values, color=colors_list, alpha=0.7)
+        
+        ax.set_yticks(y_pos)
+        ax.set_yticklabels(labels)
+        ax.set_xlabel('Coaching Coverage (%)')
+        ax.set_title('Product Management Skills Coaching Session', fontsize=14, fontweight='bold')
+        ax.set_xlim(0, 100)
+        
+        # Add checkmarks to indicate completion
+        for i, bar in enumerate(bars):
+            ax.text(bar.get_width() - 10, bar.get_y() + bar.get_height()/2, 
+                    '✓', ha='center', va='center', fontsize=16, color='white', fontweight='bold')
+        
+        plt.tight_layout()
+        plt.savefig(file_path, dpi=300, bbox_inches='tight')
+        plt.close(fig)  # Explicitly close the figure
+        print(f"✅ Chart saved to: {file_path}")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error creating chart: {e}")
+        return False
+    
+    plt.tight_layout()
+    plt.savefig(file_path, dpi=300, bbox_inches='tight')
+    plt.close(fig)
+    print(f"📈 Coaching progress chart saved to {file_path}")
+
+def clean_text_for_pdf(text):
+    """Remove markdown formatting and clean text for professional PDF appearance."""
+    import re
+    
+    # Remove markdown bold/italic formatting - handle nested patterns
+    text = re.sub(r'\*\*\*(.*?)\*\*\*', r'\1', text)  # Remove ***bold italic***
+    text = re.sub(r'\*\*(.*?)\*\*', r'\1', text)      # Remove **bold**
+    text = re.sub(r'\*(.*?)\*', r'\1', text)          # Remove *italic*
+    text = re.sub(r'__(.*?)__', r'\1', text)          # Remove __bold__
+    text = re.sub(r'_(.*?)_', r'\1', text)            # Remove _italic_
+    
+    # Clean up section headers (remove markdown)
+    text = re.sub(r'#{1,6}\s*', '', text)             # Remove # headers
+    text = re.sub(r'\*\*([A-Z\s]+[A-Za-z]):\*\*', r'\1:', text)  # Clean section headers with colons
+    text = re.sub(r'\*\*([A-Z][A-Za-z\s]*)\*\*', r'\1', text)    # Clean other bold headers
+    
+    # Remove markdown links
+    text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text)
+    
+    # Clean up bullet points and list markers
+    text = re.sub(r'^\s*[-\*\+•]\s+', '• ', text, flags=re.MULTILINE)
+    text = re.sub(r'^\s*\d+\.\s+', '• ', text, flags=re.MULTILINE)  # Convert numbered lists
+    
+    # Remove extra asterisks that might be left over
+    text = re.sub(r'\*+', '', text)
+    text = re.sub(r'_+', '', text)
+    
+    # Clean up multiple spaces and normalize line breaks
+    text = re.sub(r'\n\s*\n\s*\n+', '\n\n', text)
+    text = re.sub(r'\s+', ' ', text)
+    text = text.strip()
+    
+    return text
+
+def format_feedback_sections(feedback_text):
+    """Break feedback into structured sections for better visual presentation."""
+    # First, clean the text of markdown formatting
+    cleaned_text = clean_text_for_pdf(feedback_text)
+    
+    sections = []
+    current_section = ""
+    current_title = ""
+    
+    lines = cleaned_text.split('\n')
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+            
+        # Check if line is a section header (contains keywords)
+        if any(keyword in line.upper() for keyword in ['STRENGTHS:', 'AREAS FOR GROWTH:', 'FRAMEWORK', 'METRICS', 'NEXT STEPS:', 'INSIGHT:', 'SCORES:', 'KEY STRENGTHS', 'RECOMMENDATIONS']):
+            # Save previous section
+            if current_title and current_section:
+                sections.append({
+                    'title': current_title,
+                    'content': current_section.strip()
+                })
+            
+            # Start new section
+            current_title = line.replace(':', '').strip()
+            current_section = ""
+        else:
+            # Add to current section
+            current_section += line + " "
+    
+    # Add final section
+    if current_title and current_section:
+        sections.append({
+            'title': current_title,
+            'content': current_section.strip()
+        })
+    
+    return sections
+
+def generate_pdf_report(coaching_data, file_path):
+    """Generate a professional product management coaching report without markdown formatting."""
+    try:
+        doc = SimpleDocTemplate(file_path, pagesize=(8.5 * inch, 11 * inch))
+        styles = getSampleStyleSheet()
+        
+        # Professional styles for coaching report - only add if they don't exist
+        def safe_add_style(styles, name, **kwargs):
+            """Safely add a style only if it doesn't already exist"""
+            if name not in styles:
+                styles.add(ParagraphStyle(name=name, **kwargs))
+        
+        safe_add_style(styles, 'ReportTitle',
+            parent=styles['Heading1'], 
+            fontSize=24, 
+            alignment=TA_CENTER, 
+            spaceAfter=20, 
+            textColor=colors.darkblue,
+            fontName='Helvetica-Bold'
+        )
+        
+        safe_add_style(styles, 'SectionHeader',
+            parent=styles['Heading2'], 
+            fontSize=16, 
+            spaceBefore=15, 
+            spaceAfter=10, 
+            textColor=colors.darkblue,
+            fontName='Helvetica-Bold'
+        )
+        
+        safe_add_style(styles, 'SubHeader',
+            parent=styles['Heading3'], 
+            fontSize=14, 
+            spaceBefore=12, 
+            spaceAfter=8, 
+            textColor=colors.darkgreen,
+            fontName='Helvetica-Bold'
+        )
+        
+        safe_add_style(styles, 'BodyText',
+            parent=styles['Normal'],
+            fontSize=11, 
+            spaceAfter=12,
+            spaceBefore=6, 
+            alignment=TA_JUSTIFY,
+            fontName='Helvetica'
+        )
+        
+        safe_add_style(styles, 'BulletText',
+            parent=styles['Normal'],
+            fontSize=11, 
+            spaceAfter=8,
+            spaceBefore=4,
+            leftIndent=20,
+            fontName='Helvetica'
+        )
+        
+        safe_add_style(styles, 'BulletPoint',
+            parent=styles['Normal'],
+            fontSize=11, 
+            spaceAfter=6,
+            spaceBefore=3,
+            leftIndent=20,
+            fontName='Helvetica'
+        )
+        
+        safe_add_style(styles, 'ScoreText',
+            parent=styles['Normal'],
+            fontSize=12, 
+            spaceAfter=8,
+            spaceBefore=4, 
+            textColor=colors.blue,
+            fontName='Helvetica-Bold'
+        )
+        
+        safe_add_style(styles, 'HighlightBox',
+            parent=styles['Normal'],
+            fontSize=11,
+            spaceAfter=12,
+            spaceBefore=12,
+            leftIndent=15,
+            rightIndent=15,
+            borderWidth=1,
+            borderColor=colors.lightgrey,
+            backColor=colors.lightgrey,
+            fontName='Helvetica'
+        )
+        
+        print("✅ Stylesheet created successfully")
+        
+        story = []
+        
+        # Title Page
+        story.append(Paragraph("Personal AI Product Coach", styles['ReportTitle']))
+        story.append(Paragraph("Product Management Coaching Report", styles['SectionHeader']))
+        story.append(Spacer(1, 0.5 * inch))
+        
+        # Executive Summary Table
+        story.append(Paragraph("Executive Summary", styles['SectionHeader']))
+        story.append(Paragraph(f"Participant: {coaching_data.get('name', 'Product Manager')}", styles['BodyText']))
+        story.append(Paragraph(f"Coaching Focus: {coaching_data.get('type', 'General PM Coaching')}", styles['BodyText']))
+        story.append(Paragraph(f"Session Date: {datetime.datetime.now().strftime('%B %d, %Y')}", styles['BodyText']))
+        story.append(Paragraph(f"Scenarios Completed: {len(coaching_data.get('q_and_a', []))}", styles['BodyText']))
+        
+        # Calculate overall session performance
+        session_scores = []
+        for scenario in coaching_data.get('q_and_a', []):
+            if 'overall_score' in scenario and scenario['overall_score'] > 0:
+                session_scores.append(scenario['overall_score'])
+        
+        if session_scores:
+            avg_score = sum(session_scores) / len(session_scores)
+            story.append(Paragraph(f"Session Average Score: {avg_score:.1f}/10", styles['ScoreText']))
+        
+        story.append(PageBreak())
+
+        # Overall Performance Analysis
+        story.append(Paragraph("Overall Performance Analysis", styles['SectionHeader']))
+        
+        # Generate comprehensive feedback with error handling
+        try:
+            overall_feedback = generate_coaching_feedback(coaching_data.get('q_and_a', []), 
+                                                         coaching_data.get('type', 'General'), 
+                                                         coaching_data.get('name', 'Product Manager'))
+            
+            # Format the feedback into structured sections
+            feedback_sections = format_feedback_sections(overall_feedback)
+            
+            if feedback_sections:
+                for section in feedback_sections:
+                    # Add section title with proper styling
+                    story.append(Paragraph(section['title'], styles['SubHeader']))
+                    story.append(Spacer(1, 0.1 * inch))
+                    
+                    # Split content into bullet points if it contains bullet indicators
+                    content = section['content']
+                    if '•' in content:
+                        # Handle bullet points
+                        bullets = [line.strip() for line in content.split('•') if line.strip()]
+                        for bullet in bullets:
+                            if bullet:
+                                story.append(Paragraph(f"• {bullet}", styles['BulletPoint']))
+                    else:
+                        # Handle regular paragraphs
+                        paragraphs = [p.strip() for p in content.split('.') if p.strip()]
+                        for para in paragraphs:
+                            if para and len(para) > 10:  # Avoid very short fragments
+                                story.append(Paragraph(f"{para}.", styles['BodyText']))
+                    
+                    story.append(Spacer(1, 0.2 * inch))
+            else:
+                # Fallback if no sections found - display as clean text
+                clean_feedback = clean_text_for_pdf(overall_feedback)
+                story.append(Paragraph(clean_feedback, styles['BodyText']))
+                
+        except Exception as feedback_error:
+            print(f"⚠️ Error generating overall feedback: {feedback_error}")
+            story.append(Paragraph("Great work in this coaching session! You demonstrated solid product management thinking and approach to the scenarios presented.", styles['BodyText']))
+        
+        story.append(Spacer(1, 0.3 * inch))
+
+        # Add progress chart with error handling
+        try:
+            skill_labels = define_skill_areas(coaching_data.get('type', 'General'))
+            chart_path = os.path.join(config.REPORT_FOLDER, "coaching_progress.png")
+            if os.path.exists(chart_path): 
+                os.remove(chart_path)
+            
+            if create_coaching_progress_chart(skill_labels, chart_path):
+                story.append(Image(chart_path, width=6*inch, height=4*inch, hAlign='CENTER'))
+            else:
+                story.append(Paragraph("Skills covered in this coaching session:", styles['SubHeader']))
+                for skill in skill_labels:
+                    story.append(Paragraph(f"• {skill}", styles['BodyText']))
+        except Exception as chart_error:
+            print(f"⚠️ Error creating chart: {chart_error}")
+            story.append(Paragraph("Skills Development Summary", styles['SubHeader']))
+            story.append(Paragraph("This coaching session covered key product management competencies.", styles['BodyText']))
+        
+        story.append(PageBreak())
+
+        # Detailed Scenario Analysis
+        story.append(Paragraph("Detailed Scenario Analysis", styles['SectionHeader']))
+        story.append(Spacer(1, 0.2 * inch))
+        
+        for i, scenario in enumerate(coaching_data.get('q_and_a', [])):
+            try:
+                # Scenario Header with visual separation
+                story.append(Paragraph(f"Scenario {i+1}", styles['SubHeader']))
+                story.append(Spacer(1, 0.1 * inch))
+                
+                # Challenge Description in highlighted box
+                story.append(Paragraph("Challenge:", styles['SubHeader']))
+                clean_question = clean_text_for_pdf(scenario.get('question', 'Product management scenario'))
+                story.append(Paragraph(clean_question, styles['HighlightBox']))
+                story.append(Spacer(1, 0.15 * inch))
+                
+                # Participant's Response
+                story.append(Paragraph("Your Approach:", styles['SubHeader']))
+                clean_response = clean_text_for_pdf(scenario.get('response', 'Response provided'))
+                story.append(Paragraph(clean_response, styles['BodyText']))
+                story.append(Spacer(1, 0.1 * inch))
+                
+                # Score Display with visual emphasis
+                if scenario.get('overall_score', 0) > 0:
+                    score_text = f"Overall Score: {scenario['overall_score']}/10"
+                    story.append(Paragraph(score_text, styles['ScoreText']))
+                    story.append(Spacer(1, 0.1 * inch))
+                
+                # Coaching Feedback - break into sections
+                story.append(Paragraph("Coaching Analysis:", styles['SubHeader']))
+                feedback_text = scenario.get('feedback', 'Great work on this scenario!')
+                feedback_sections = format_feedback_sections(feedback_text)
+                
+                if feedback_sections:
+                    for section in feedback_sections:
+                        if section['title'] and section['content']:
+                            # Section title
+                            story.append(Paragraph(f"{section['title']}:", styles['SubHeader']))
+                            # Section content - already cleaned by format_feedback_sections
+                            story.append(Paragraph(section['content'], styles['BulletText']))
+                            story.append(Spacer(1, 0.05 * inch))
+                else:
+                    # Fallback - use original feedback with cleaning
+                    clean_feedback = clean_text_for_pdf(feedback_text)
+                    story.append(Paragraph(clean_feedback, styles['BodyText']))
+                
+                # Add separator between scenarios
+                if i < len(coaching_data.get('q_and_a', [])) - 1:
+                    story.append(Spacer(1, 0.3 * inch))
+                    # Add a subtle line separator
+                    story.append(HRFlowable(width="100%", thickness=1, lineCap='round', color=colors.lightgrey))
+                    story.append(Spacer(1, 0.2 * inch))
+                    
+            except Exception as scenario_error:
+                print(f"⚠️ Error processing scenario {i+1}: {scenario_error}")
+                story.append(Paragraph(f"Scenario {i+1}: Completed successfully", styles['BodyText']))
+                story.append(Spacer(1, 0.2 * inch))
+        
+        # Development Plan Section
+        story.append(PageBreak())
+        story.append(Paragraph("Your Product Management Development Plan", styles['SectionHeader']))
+        story.append(Spacer(1, 0.2 * inch))
+        
+        # Focus Areas
+        story.append(Paragraph("Recommended Focus Areas", styles['SubHeader']))
+        focus_areas = [
+            f"Continue practicing {coaching_data.get('type', 'product management').lower()} scenarios with real-world applications",
+            "Explore and master relevant PM frameworks and methodologies",
+            "Seek feedback from peers and mentors on your product management approach",
+            "Apply these concepts in your current role or personal projects"
+        ]
+        for area in focus_areas:
+            story.append(Paragraph(f"• {area}", styles['BulletText']))
+        story.append(Spacer(1, 0.2 * inch))
+        
+        # Learning Resources
+        story.append(Paragraph("Suggested Learning Resources", styles['SubHeader']))
+        resources = [
+            '"Inspired" by Marty Cagan - Product management fundamentals',
+            '"The Lean Startup" by Eric Ries - Validation and iteration principles',
+            '"Hooked" by Nir Eyal - User engagement and product psychology',
+            'Product management communities and industry blogs for current best practices'
+        ]
+        for resource in resources:
+            story.append(Paragraph(f"• {resource}", styles['BulletText']))
+        story.append(Spacer(1, 0.2 * inch))
+        
+        # Next Steps
+        story.append(Paragraph("Next Steps for Growth", styles['SubHeader']))
+        next_steps_text = """Product management is a continuous learning journey. Use this coaching session as a foundation to build upon. 
+        Regular practice with realistic scenarios, combined with framework application and stakeholder feedback, 
+        will accelerate your development as a product manager.
+        
+        Remember to stay curious about user needs, data-driven in your decisions, and collaborative in your approach. 
+        The best product managers never stop learning and adapting."""
+        
+        story.append(Paragraph(next_steps_text, styles['BodyText']))
+        
+        # Footer
+        story.append(Spacer(1, 0.5 * inch))
+        story.append(Paragraph("Personal AI Product Coach - Developing Product Management Excellence", 
+                              styles['BodyText']))
+        
+        # Build the PDF
+        doc.build(story)
+        print(f"✅ Professional coaching report generated: {file_path}")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error generating PDF report: {e}")
+        print(f"❌ Error details: {str(e)}")
+        return False
+
+# Legacy function for backward compatibility
+def generate_holistic_feedback(interview_log):
+    """Legacy function - redirects to generate_coaching_feedback."""
+    return "This coaching session focused on developing key product management skills through practical scenarios."

modules/stt_handler.py

@@ -0,0 +1,87 @@
+# modules/stt_handler.py
+import speech_recognition as sr
+import os
+import tempfile
+from pydub import AudioSegment
+
+def transcribe_audio(audio_filepath):
+    """Transcribe audio with multiple fallback methods"""
+    if not audio_filepath or not os.path.exists(audio_filepath):
+        print("❌ STT Error: No audio file provided or file does not exist.")
+        return "Sorry, I couldn't process your audio file. Please try recording again."
+    
+    print(f"🎙️ Transcribing audio file: {audio_filepath}")
+    recognizer = sr.Recognizer()
+    
+    try:
+        # Try to convert audio format if needed
+        audio_data = None
+        
+        # First try direct speech recognition
+        try:
+            with sr.AudioFile(audio_filepath) as source:
+                audio_data = recognizer.record(source)
+                print("✅ Audio file loaded successfully")
+        except Exception as audio_load_error:
+            print(f"⚠️ Direct audio loading failed: {audio_load_error}")
+            
+            # Try converting with pydub first
+            try:
+                print("🔄 Converting audio format...")
+                audio = AudioSegment.from_file(audio_filepath)
+                
+                # Export as WAV for better compatibility
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_wav:
+                    temp_wav_path = temp_wav.name
+                    audio.export(temp_wav_path, format="wav")
+                
+                with sr.AudioFile(temp_wav_path) as source:
+                    audio_data = recognizer.record(source)
+                    print("✅ Audio converted and loaded successfully")
+                
+                # Clean up temp file
+                if os.path.exists(temp_wav_path):
+                    os.remove(temp_wav_path)
+                    
+            except Exception as convert_error:
+                print(f"❌ Audio conversion failed: {convert_error}")
+                return "Sorry, I couldn't process your audio format. Please try recording again."
+        
+        if not audio_data:
+            return "Sorry, I couldn't load your audio. Please try recording again."
+        
+        # Try Whisper transcription
+        try:
+            print("🤖 Transcribing with Whisper...")
+            text = recognizer.recognize_whisper(audio_data, language="english")
+            print(f"✅ Transcription successful: {text[:100]}...")
+            return text if text.strip() else "I didn't catch what you said. Could you please speak more clearly?"
+            
+        except sr.UnknownValueError:
+            print("⚠️ Whisper could not understand the audio")
+            return "I couldn't understand what you said. Please speak more clearly and try again."
+            
+        except sr.RequestError as e:
+            print(f"⚠️ Whisper service error: {e}")
+            # Fallback to Google Web Speech API
+            try:
+                print("🔄 Falling back to Google Speech Recognition...")
+                text = recognizer.recognize_google(audio_data)
+                print(f"✅ Google transcription successful: {text[:100]}...")
+                return text if text.strip() else "I didn't catch what you said. Could you please try again?"
+            except Exception as google_error:
+                print(f"❌ Google fallback failed: {google_error}")
+                return "I'm having trouble with speech recognition. Please try again or check your microphone."
+        
+    except Exception as e:
+        print(f"❌ Unexpected transcription error: {e}")
+        return f"Sorry, I encountered an error processing your audio. Please try recording again."
+    
+    finally:
+        # Clean up the original audio file
+        if os.path.exists(audio_filepath):
+            try:
+                os.remove(audio_filepath)
+                print(f"🗑️ Cleaned up audio file: {audio_filepath}")
+            except OSError as e:
+                print(f"⚠️ Error deleting temp audio file {audio_filepath}: {e}")

modules/tts_handler.py

@@ -0,0 +1,62 @@
+# modules/tts_handler.py
+import subprocess
+import platform
+import sys
+import os
+import config
+import tempfile
+import numpy as np
+import wave
+
+def text_to_speech_file(text_to_speak):
+    """Generate TTS audio file - with fallback to silent audio if TTS fails"""
+    print(f"AI generating audio for: {text_to_speak[:100]}...")
+    
+    try:
+        # Try using system TTS (macOS say command)
+        if platform.system() == "Darwin":  # macOS
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as wav_file:
+                wav_filename = wav_file.name
+            
+            # Use macOS 'say' command to generate speech
+            command = ['say', '-o', wav_filename, '--data-format=LEF32@22050', text_to_speak]
+            process = subprocess.run(command, capture_output=True, text=True, timeout=30)
+            
+            if process.returncode == 0 and os.path.exists(wav_filename):
+                print("✅ TTS generated successfully with macOS 'say'")
+                return wav_filename
+            else:
+                print("❌ macOS 'say' command failed, falling back to silent audio")
+                return create_silent_audio()
+        else:
+            print("❌ TTS not available on this system, using silent audio")
+            return create_silent_audio()
+            
+    except Exception as e:
+        print(f"❌ TTS generation failed: {e}")
+        return create_silent_audio()
+
+def create_silent_audio():
+    """Create a short silent audio file as fallback"""
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as wav_file:
+            wav_filename = wav_file.name
+        
+        # Create 1 second of silence
+        sample_rate = 22050
+        duration = 1.0  # seconds
+        samples = int(sample_rate * duration)
+        audio_data = np.zeros(samples, dtype=np.int16)
+        
+        # Write WAV file
+        with wave.open(wav_filename, 'w') as wav_file:
+            wav_file.setnchannels(1)  # Mono
+            wav_file.setsampwidth(2)  # 2 bytes per sample
+            wav_file.setframerate(sample_rate)
+            wav_file.writeframes(audio_data.tobytes())
+        
+        print("✅ Silent audio fallback created")
+        return wav_filename
+    except Exception as e:
+        print(f"❌ Even silent audio creation failed: {e}")
+        return None

modules/web_search.py

@@ -0,0 +1,33 @@
+# modules/web_search.py
+
+def search_for_example_answers(query: str, num_results: int = 2):
+    """
+    Performs a targeted web search for high-quality example answers to an interview question.
+    Note: Web search is disabled in this deployment to ensure compatibility.
+    """
+    try:
+        from ddgs import DDGS
+        # Refine the query to find expert answers
+        search_query = f"expert sample answer for interview question: \"{query}\""
+        print(f"🌐 Searching for expert answers with query: '{search_query}'")
+        
+        with DDGS(timeout=10) as ddgs:
+            results = list(ddgs.text(search_query, max_results=num_results))
+            
+            if not results:
+                print("   -> No example answers found.")
+                return "No example answers found on the web."
+            
+            formatted_results = ""
+            for i, res in enumerate(results):
+                formatted_results += f"Example Answer Source {i+1}:\nTitle: {res.get('title', 'N/A')}\nSnippet: {res.get('body', 'N/A')}\n\n"
+            
+            print(f"   -> Found {len(results)} example answers.")
+            return formatted_results
+            
+    except ImportError:
+        print("💡 Web search not available in this deployment (ddgs not installed)")
+        return "Web search not available in this deployment environment."
+    except Exception as e:
+        print(f"💥 Web search failed: {e}")
+        return "Web search for example answers failed."

packages.txt

@@ -0,0 +1,2 @@
+ffmpeg
+portaudio19-dev

requirements.txt

@@ -0,0 +1,12 @@
+gradio>=4.0.0,<5.0.0
+groq
+openai-whisper
+pydub
+soundfile
+PyMuPDF
+python-docx
+reportlab
+speechrecognition
+matplotlib
+numpy
+python-dotenv

test_deployment.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""
+Test script to check if all dependencies can be imported for Hugging Face deployment
+"""
+
+import sys
+
+def test_imports():
+    """Test all required imports"""
+    print("🧪 Testing deployment readiness...")
+    
+    failed_imports = []
+    
+    # Test core dependencies
+    try:
+        import gradio
+        print("✅ gradio")
+    except ImportError as e:
+        failed_imports.append(f"gradio: {e}")
+        print("❌ gradio")
+    
+    try:
+        import groq
+        print("✅ groq")
+    except ImportError as e:
+        failed_imports.append(f"groq: {e}")
+        print("❌ groq")
+    
+    try:
+        import whisper
+        print("✅ openai-whisper")
+    except ImportError as e:
+        failed_imports.append(f"openai-whisper: {e}")
+        print("❌ openai-whisper")
+    
+    try:
+        import pydub
+        print("✅ pydub")
+    except ImportError as e:
+        failed_imports.append(f"pydub: {e}")
+        print("❌ pydub")
+    
+    try:
+        import soundfile
+        print("✅ soundfile")
+    except ImportError as e:
+        failed_imports.append(f"soundfile: {e}")
+        print("❌ soundfile")
+    
+    try:
+        import fitz  # PyMuPDF
+        print("✅ PyMuPDF")
+    except ImportError as e:
+        failed_imports.append(f"PyMuPDF: {e}")
+        print("❌ PyMuPDF")
+    
+    try:
+        import docx
+        print("✅ python-docx")
+    except ImportError as e:
+        failed_imports.append(f"python-docx: {e}")
+        print("❌ python-docx")
+    
+    try:
+        import reportlab
+        print("✅ reportlab")
+    except ImportError as e:
+        failed_imports.append(f"reportlab: {e}")
+        print("❌ reportlab")
+    
+    try:
+        import speech_recognition
+        print("✅ speechrecognition")
+    except ImportError as e:
+        failed_imports.append(f"speechrecognition: {e}")
+        print("❌ speechrecognition")
+    
+    try:
+        import matplotlib
+        print("✅ matplotlib")
+    except ImportError as e:
+        failed_imports.append(f"matplotlib: {e}")
+        print("❌ matplotlib")
+    
+    try:
+        import numpy
+        print("✅ numpy")
+    except ImportError as e:
+        failed_imports.append(f"numpy: {e}")
+        print("❌ numpy")
+    
+    # Test module imports
+    print("\n📦 Testing custom modules...")
+    
+    try:
+        import config
+        print("✅ config")
+    except ImportError as e:
+        failed_imports.append(f"config: {e}")
+        print("❌ config")
+    
+    try:
+        from modules.llm_handler import generate_coaching_question
+        print("✅ modules.llm_handler")
+    except ImportError as e:
+        failed_imports.append(f"modules.llm_handler: {e}")
+        print("❌ modules.llm_handler")
+    
+    try:
+        from modules.doc_processor import extract_text_from_document
+        print("✅ modules.doc_processor")
+    except ImportError as e:
+        failed_imports.append(f"modules.doc_processor: {e}")
+        print("❌ modules.doc_processor")
+    
+    try:
+        from modules.report_generator import generate_pdf_report
+        print("✅ modules.report_generator")
+    except ImportError as e:
+        failed_imports.append(f"modules.report_generator: {e}")
+        print("❌ modules.report_generator")
+    
+    # Summary
+    print("\n" + "="*50)
+    if failed_imports:
+        print(f"❌ {len(failed_imports)} import failures found:")
+        for failure in failed_imports:
+            print(f"   - {failure}")
+        print("\n🚨 App may not work properly on Hugging Face!")
+        return False
+    else:
+        print("✅ All imports successful!")
+        print("🚀 Ready for Hugging Face deployment!")
+        return True
+
+if __name__ == "__main__":
+    success = test_imports()
+    sys.exit(0 if success else 1)

test_report.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""Test script to verify report generation works correctly"""
+
+import os
+import sys
+sys.path.append('.')
+
+from modules.report_generator import generate_pdf_report
+import config
+
+# Test data
+test_data = {
+    'name': 'Test User',
+    'type': 'Product Strategy & Vision',
+    'q_and_a': [
+        {
+            'question': 'How would you define the product vision for a new mobile app?',
+            'response': 'I would start by understanding the target users, their pain points, and the market opportunity. Then I would create a compelling vision that aligns with business goals.',
+            'feedback': 'Great approach! You showed strong strategic thinking and considered multiple stakeholders.',
+            'overall_score': 8,
+            'scores': {'Strategic Thinking': 8, 'Problem Analysis': 7}
+        }
+    ]
+}
+
+# Create test report
+test_report_path = os.path.join(config.REPORT_FOLDER, 'test_report.pdf')
+print(f"🧪 Testing report generation...")
+print(f"📁 Report will be saved to: {test_report_path}")
+
+try:
+    result = generate_pdf_report(test_data, test_report_path)
+    if result:
+        print(f"✅ Test report generated successfully!")
+        print(f"📊 File size: {os.path.getsize(test_report_path)} bytes")
+    else:
+        print("❌ Report generation failed")
+except Exception as e:
+    print(f"❌ Test failed with error: {e}")

voice_model/en_US-lessac-medium.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5efe09e69902187827af646e1a6e9d269dee769f9877d17b16b1b46eeaaf019f
+size 63201294

voice_model/en_US-lessac-medium.onnx.json

@@ -0,0 +1,493 @@
+{
+  "audio": {
+    "sample_rate": 22050,
+    "quality": "medium"
+  },
+  "espeak": {
+    "voice": "en-us"
+  },
+  "inference": {
+    "noise_scale": 0.667,
+    "length_scale": 1,
+    "noise_w": 0.8
+  },
+  "phoneme_type": "espeak",
+  "phoneme_map": {},
+  "phoneme_id_map": {
+    "_": [
+      0
+    ],
+    "^": [
+      1
+    ],
+    "$": [
+      2
+    ],
+    " ": [
+      3
+    ],
+    "!": [
+      4
+    ],
+    "'": [
+      5
+    ],
+    "(": [
+      6
+    ],
+    ")": [
+      7
+    ],
+    ",": [
+      8
+    ],
+    "-": [
+      9
+    ],
+    ".": [
+      10
+    ],
+    ":": [
+      11
+    ],
+    ";": [
+      12
+    ],
+    "?": [
+      13
+    ],
+    "a": [
+      14
+    ],
+    "b": [
+      15
+    ],
+    "c": [
+      16
+    ],
+    "d": [
+      17
+    ],
+    "e": [
+      18
+    ],
+    "f": [
+      19
+    ],
+    "h": [
+      20
+    ],
+    "i": [
+      21
+    ],
+    "j": [
+      22
+    ],
+    "k": [
+      23
+    ],
+    "l": [
+      24
+    ],
+    "m": [
+      25
+    ],
+    "n": [
+      26
+    ],
+    "o": [
+      27
+    ],
+    "p": [
+      28
+    ],
+    "q": [
+      29
+    ],
+    "r": [
+      30
+    ],
+    "s": [
+      31
+    ],
+    "t": [
+      32
+    ],
+    "u": [
+      33
+    ],
+    "v": [
+      34
+    ],
+    "w": [
+      35
+    ],
+    "x": [
+      36
+    ],
+    "y": [
+      37
+    ],
+    "z": [
+      38
+    ],
+    "æ": [
+      39
+    ],
+    "ç": [
+      40
+    ],
+    "ð": [
+      41
+    ],
+    "ø": [
+      42
+    ],
+    "ħ": [
+      43
+    ],
+    "ŋ": [
+      44
+    ],
+    "œ": [
+      45
+    ],
+    "ǀ": [
+      46
+    ],
+    "ǁ": [
+      47
+    ],
+    "ǂ": [
+      48
+    ],
+    "ǃ": [
+      49
+    ],
+    "ɐ": [
+      50
+    ],
+    "ɑ": [
+      51
+    ],
+    "ɒ": [
+      52
+    ],
+    "ɓ": [
+      53
+    ],
+    "ɔ": [
+      54
+    ],
+    "ɕ": [
+      55
+    ],
+    "ɖ": [
+      56
+    ],
+    "ɗ": [
+      57
+    ],
+    "ɘ": [
+      58
+    ],
+    "ə": [
+      59
+    ],
+    "ɚ": [
+      60
+    ],
+    "ɛ": [
+      61
+    ],
+    "ɜ": [
+      62
+    ],
+    "ɞ": [
+      63
+    ],
+    "ɟ": [
+      64
+    ],
+    "ɠ": [
+      65
+    ],
+    "ɡ": [
+      66
+    ],
+    "ɢ": [
+      67
+    ],
+    "ɣ": [
+      68
+    ],
+    "ɤ": [
+      69
+    ],
+    "ɥ": [
+      70
+    ],
+    "ɦ": [
+      71
+    ],
+    "ɧ": [
+      72
+    ],
+    "ɨ": [
+      73
+    ],
+    "ɪ": [
+      74
+    ],
+    "ɫ": [
+      75
+    ],
+    "ɬ": [
+      76
+    ],
+    "ɭ": [
+      77
+    ],
+    "ɮ": [
+      78
+    ],
+    "ɯ": [
+      79
+    ],
+    "ɰ": [
+      80
+    ],
+    "ɱ": [
+      81
+    ],
+    "ɲ": [
+      82
+    ],
+    "ɳ": [
+      83
+    ],
+    "ɴ": [
+      84
+    ],
+    "ɵ": [
+      85
+    ],
+    "ɶ": [
+      86
+    ],
+    "ɸ": [
+      87
+    ],
+    "ɹ": [
+      88
+    ],
+    "ɺ": [
+      89
+    ],
+    "ɻ": [
+      90
+    ],
+    "ɽ": [
+      91
+    ],
+    "ɾ": [
+      92
+    ],
+    "ʀ": [
+      93
+    ],
+    "ʁ": [
+      94
+    ],
+    "ʂ": [
+      95
+    ],
+    "ʃ": [
+      96
+    ],
+    "ʄ": [
+      97
+    ],
+    "ʈ": [
+      98
+    ],
+    "ʉ": [
+      99
+    ],
+    "ʊ": [
+      100
+    ],
+    "ʋ": [
+      101
+    ],
+    "ʌ": [
+      102
+    ],
+    "ʍ": [
+      103
+    ],
+    "ʎ": [
+      104
+    ],
+    "ʏ": [
+      105
+    ],
+    "ʐ": [
+      106
+    ],
+    "ʑ": [
+      107
+    ],
+    "ʒ": [
+      108
+    ],
+    "ʔ": [
+      109
+    ],
+    "ʕ": [
+      110
+    ],
+    "ʘ": [
+      111
+    ],
+    "ʙ": [
+      112
+    ],
+    "ʛ": [
+      113
+    ],
+    "ʜ": [
+      114
+    ],
+    "ʝ": [
+      115
+    ],
+    "ʟ": [
+      116
+    ],
+    "ʡ": [
+      117
+    ],
+    "ʢ": [
+      118
+    ],
+    "ʲ": [
+      119
+    ],
+    "ˈ": [
+      120
+    ],
+    "ˌ": [
+      121
+    ],
+    "ː": [
+      122
+    ],
+    "ˑ": [
+      123
+    ],
+    "˞": [
+      124
+    ],
+    "β": [
+      125
+    ],
+    "θ": [
+      126
+    ],
+    "χ": [
+      127
+    ],
+    "ᵻ": [
+      128
+    ],
+    "ⱱ": [
+      129
+    ],
+    "0": [
+      130
+    ],
+    "1": [
+      131
+    ],
+    "2": [
+      132
+    ],
+    "3": [
+      133
+    ],
+    "4": [
+      134
+    ],
+    "5": [
+      135
+    ],
+    "6": [
+      136
+    ],
+    "7": [
+      137
+    ],
+    "8": [
+      138
+    ],
+    "9": [
+      139
+    ],
+    "̧": [
+      140
+    ],
+    "̃": [
+      141
+    ],
+    "̪": [
+      142
+    ],
+    "̯": [
+      143
+    ],
+    "̩": [
+      144
+    ],
+    "ʰ": [
+      145
+    ],
+    "ˤ": [
+      146
+    ],
+    "ε": [
+      147
+    ],
+    "↓": [
+      148
+    ],
+    "#": [
+      149
+    ],
+    "\"": [
+      150
+    ],
+    "↑": [
+      151
+    ],
+    "̺": [
+      152
+    ],
+    "̻": [
+      153
+    ]
+  },
+  "num_symbols": 256,
+  "num_speakers": 1,
+  "speaker_id_map": {},
+  "piper_version": "1.0.0",
+  "language": {
+    "code": "en_US",
+    "family": "en",
+    "region": "US",
+    "name_native": "English",
+    "name_english": "English",
+    "country_english": "United States"
+  },
+  "dataset": "lessac"
+}