michael-agent 1.0.4__py3-none-any.whl → 1.0.5__py3-none-any.whl

michael_agent/dashboard/app.py

@@ -267,12 +267,13 @@ def generate_jd():
             "errors": []
         }
         
-        # Use the JD generator node to create the job description
+        # Use the JD generator node to create the job description and screening questions
         result_state = jd_generator.generate_job_description(state)
         
         return jsonify({
             'success': True,
-            'job_description_text': result_state.get('job_description_text', 'Error generating job description')
+            'job_description_text': result_state.get('job_description_text', 'Error generating job description'),
+            'screening_questions': result_state.get('screening_questions', [])
         })
     except Exception as e:
         logger.error(f"Error generating job description: {str(e)}")
@@ -295,7 +296,8 @@ def save_jd():
             "job_id": job_id,
             "timestamp": datetime.now().isoformat(),
             "job_data": data.get("metadata", {}),
-            "job_description": data.get("content", "")
+            "job_description": data.get("content", ""),
+            "screening_questions": data.get("screening_questions", [])
         }
         
         # Save to job_descriptions directory
@@ -521,6 +523,9 @@ def get_job(job_id):
             required_skills = jd_data['job_data'].get('required_skills', [])
             preferred_skills = jd_data['job_data'].get('preferred_skills', [])
         
+        # Extract screening questions if available
+        screening_questions = jd_data.get('screening_questions', [])
+        
         return jsonify({
             'id': job_id,
             'title': title,
@@ -530,7 +535,8 @@ def get_job(job_id):
             'employment_type': employment_type,
             'experience_level': experience_level,
             'required_skills': required_skills,
-            'preferred_skills': preferred_skills
+            'preferred_skills': preferred_skills,
+            'screening_questions': screening_questions
         })
     except Exception as e:
         logger.error(f"Error getting job details: {str(e)}")
@@ -1028,6 +1034,16 @@ def get_candidate(candidate_id):
         # Add more detailed debug logging
         logger.info(f"Returning candidate data for {candidate_id}, name={name}, has_experience={len(experience)}, has_education={len(education)}")
         
+        # Extract screening questions and answers if available
+        screening_responses = None
+        if 'screening_questions' in candidate_data and 'screening_answers' in candidate_data:
+            screening_responses = {
+                'questions': candidate_data['screening_questions'],
+                'answers': candidate_data['screening_answers']
+            }
+        elif 'resume_data' in candidate_data and 'screening_responses' in candidate_data['resume_data']:
+            screening_responses = candidate_data['resume_data']['screening_responses']
+        
         # Return data with sensible defaults for all fields to prevent frontend errors
         response_data = {
             'id': candidate_id,
@@ -1046,6 +1062,7 @@ def get_candidate(candidate_id):
                 'weaknesses': [],
                 'overall': 'No analysis available'
             },
+            'screening_responses': screening_responses,
             'resume_path': resume_path or '',
             'status': candidate_data.get('status', 'new') or 'new'
         }
@@ -1170,6 +1187,7 @@ def apply_for_job():
     try:
         # Check if all required fields are present
         if 'resume_file' not in request.files:
+            logger.error("No resume file provided in request")
             return jsonify({'success': False, 'error': 'No resume file provided'}), 400
         
         resume_file = request.files['resume_file']
@@ -1178,8 +1196,12 @@ def apply_for_job():
         email = request.form.get('email')
         
         if not resume_file or not job_id or not name or not email:
+            logger.error(f"Missing required fields: resume_file={bool(resume_file)}, job_id={job_id}, name={name}, email={email}")
             return jsonify({'success': False, 'error': 'Missing required fields'}), 400
         
+        # Log all form data for debugging
+        logger.info(f"Received application form data: {request.form}")
+        
         # Check if directory exists and create if not
         import os
         from datetime import datetime
@@ -1190,13 +1212,44 @@ def apply_for_job():
         
         # Generate unique filename with timestamp
         timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
-        filename = f"{job_id}_{request.form.get('name').replace(' ', '_')}.{resume_file.filename.split('.')[-1]}"
+        filename = f"{timestamp}_{job_id}_{request.form.get('name').replace(' ', '_')}.{resume_file.filename.split('.')[-1]}"
         filepath = os.path.join(incoming_dir, filename)
         
         # Save the file
         resume_file.save(filepath)
         logger.info(f"Saved resume file to {filepath}")
         
+        # Get job screening questions
+        screening_questions = []
+        job_file = os.path.join(settings.JOB_DESCRIPTIONS_DIR, f'{job_id}.json')
+        if os.path.exists(job_file):
+            try:
+                with open(job_file, 'r') as f:
+                    job_data = json.load(f)
+                    screening_questions = job_data.get('screening_questions', [])
+                    logger.info(f"Found {len(screening_questions)} screening questions for job {job_id}")
+            except Exception as e:
+                logger.error(f"Error reading job file for screening questions: {str(e)}")
+        
+        # Extract screening answers from form data
+        # Look for fields named screening_answer_0, screening_answer_1, etc.
+        screening_responses = []
+        for i, question in enumerate(screening_questions):
+            answer_key = f'screening_answer_{i}'
+            if answer_key in request.form:
+                answer = request.form.get(answer_key)
+                logger.info(f"Found screening answer {i}: {answer}")
+                screening_responses.append({
+                    "question": question,
+                    "answer": answer
+                })
+            else:
+                logger.warning(f"Missing screening answer for question {i}")
+                screening_responses.append({
+                    "question": question,
+                    "answer": "No answer provided"
+                })
+        
         # Create metadata file with applicant details
         metadata = {
             'job_id': job_id,
@@ -1204,41 +1257,28 @@ def apply_for_job():
             'email': email,
             'phone': request.form.get('phone', ''),
             'cover_letter': request.form.get('cover_letter', ''),
+            'screening_questions': screening_questions,
+            'screening_responses': screening_responses,
             'application_date': datetime.now().isoformat(),
             'status': 'new',
             'resume_path': filepath
         }
         
-        metadata_path = f"{filepath}.json"
+        metadata_path = filepath.replace('.pdf', '.json')
         with open(metadata_path, 'w') as f:
             json.dump(metadata, f, indent=2)
         
+        logger.info(f"Saved metadata with screening responses to {metadata_path}")
+        
         # In a real implementation, trigger the workflow to process the resume
         from langgraph_workflow.graph_builder import process_new_resume
         
-        # Get job description
-        job_file = os.path.join(settings.JOB_DESCRIPTIONS_DIR, f'{job_id}.json')
-        job_description = None
-        
-        if os.path.exists(job_file):
-            with open(job_file, 'r') as f:
-                job_data = json.load(f)
-                
-                # Extract title from job description using regex
-                import re
-                title_match = re.search(r'\*\*Job Title:\s*(.*?)\*\*', job_data.get('job_description', ''))
-                title = title_match.group(1) if title_match else "Untitled Job"
-                
-                job_description = {
-                    'id': job_id,
-                    'title': title,
-                    'content': job_data.get('job_description', ''),
-                    'metadata': job_data.get('job_data', {})
-                }
-        
-        # We only need to save the file and metadata - the file system watcher will handle the processing
-        # This prevents duplicate workflow execution
-        logger.info(f"Resume uploaded through career portal - file system watcher will process it automatically")
+        # Start processing in a background thread to avoid blocking the response
+        import threading
+        thread = threading.Thread(target=process_new_resume, args=(filepath, job_id))
+        thread.daemon = True
+        thread.start()
+        logger.info(f"Started background processing for resume: {filepath}")
         
         return jsonify({
             'success': True,

michael_agent/dashboard/templates/career_portal.html

@@ -168,6 +168,12 @@
                             <label for="cover-letter" class="form-label">Cover Letter</label>
                             <textarea class="form-control" id="cover-letter" name="cover_letter" rows="4"></textarea>
                         </div>
+                        
+                        <!-- Screening Questions Section (will be populated dynamically) -->
+                        <div id="screening-questions-container" class="mb-3 d-none">
+                            <h5 class="mb-3">Screening Questions</h5>
+                            <div id="screening-questions-list"></div>
+                        </div>
                     </form>
                 </div>
                 <div class="modal-footer">
@@ -222,20 +228,65 @@
             
             // Apply button in job modal
             document.getElementById('apply-button').addEventListener('click', function() {
-                // Get job details from the current modal
                 const jobId = this.getAttribute('data-job-id');
-                const jobTitle = document.getElementById('modal-job-title').textContent;
-                
-                // Set values in application modal
+                if (!jobId) return;
+                 // Set job ID in hidden field
                 document.getElementById('application-job-id').value = jobId;
+
+                // Get job title
+                const jobTitle = document.getElementById('modal-job-title').textContent;
                 document.getElementById('application-job-title').textContent = jobTitle;
                 
+                console.log('Fetching job details for screening questions, job ID:', jobId);
+                
+                // Fetch job details to get screening questions
+                fetch(`/api/jobs/${jobId}`)
+                    .then(response => response.json())
+                    .then(jobDetails => {
+                        console.log('Job details received:', jobDetails);
+                        // Show screening questions if available
+                        if (jobDetails.screening_questions && jobDetails.screening_questions.length > 0) {
+                            console.log('Screening questions found:', jobDetails.screening_questions);
+                            const questionsContainer = document.getElementById('screening-questions-container');
+                            const questionsList = document.getElementById('screening-questions-list');
+                            
+                            // Show the container
+                            questionsContainer.classList.remove('d-none');
+                            
+                            // Clear previous questions
+                            questionsList.innerHTML = '';
+                            
+                            // Add each question
+                            jobDetails.screening_questions.forEach((question, index) => {
+                                const questionDiv = document.createElement('div');
+                                questionDiv.className = 'mb-3';
+                                questionDiv.innerHTML = `
+                                    <label class="form-label fw-bold">${index + 1}. ${question}</label>
+                                    <textarea class="form-control" name="screening_answer_${index}" rows="2" required></textarea>
+                                `;
+                                questionsList.appendChild(questionDiv);
+                            });
+                        } else {
+                            console.log('No screening questions found for this job');
+                            // Hide the container if no questions
+                            document.getElementById('screening-questions-container').classList.add('d-none');
+                        }
+                    })
+                    .catch(error => {
+                        console.error('Error fetching job details:', error);
+                        document.getElementById('screening-questions-container').classList.add('d-none');
+                    });
+                
                 // Hide job details modal and show application modal
                 const jobModal = bootstrap.Modal.getInstance(document.getElementById('job-details-modal'));
                 jobModal.hide();
                 
-                const applicationModal = new bootstrap.Modal(document.getElementById('application-modal'));
-                applicationModal.show();
+                // Show application modal after a short delay to ensure the previous modal is closed
+                setTimeout(() => {
+                    const applicationModal = new bootstrap.Modal(document.getElementById('application-modal'));
+                    applicationModal.show();
+                    console.log('Application modal shown');
+                }, 300);
             });
             
             // Submit application
@@ -259,6 +310,24 @@
                 }
                 formData.append('resume_file', resumeFile);
                 
+                // Collect screening question answers
+                const screeningAnswers = [];
+                document.querySelectorAll('[name^="screening_answer_"]').forEach(input => {
+                    // Check if the answer field is empty
+                    if (!input.value.trim() && input.required) {
+                        alert('Please answer all screening questions');
+                        valid = false;
+                        return;
+                    }
+                    screeningAnswers.push(input.value);
+                });
+                
+                // Add screening answers as JSON
+                if (screeningAnswers.length > 0) {
+                    console.log('Adding screening answers to form data:', screeningAnswers);
+                    formData.append('screening_answers', JSON.stringify(screeningAnswers));
+                }
+                
                 // Show spinner
                 this.disabled = true;
                 document.getElementById('submit-spinner').classList.remove('d-none');
@@ -281,6 +350,10 @@
                         
                         // Reset form
                         form.reset();
+                        
+                        // Clear screening questions
+                        document.getElementById('screening-questions-container').classList.add('d-none');
+                        document.getElementById('screening-questions-list').innerHTML = '';
                     } else {
                         alert('Error submitting application: ' + data.error);
                     }

michael_agent/dashboard/templates/jd_creation.html

@@ -105,6 +105,11 @@
                         <label for="application_deadline" class="form-label">Application Deadline (Optional)</label>
                         <input type="date" class="form-control" id="application_deadline" name="application_deadline">
                     </div>
+                    
+                    <div class="alert alert-info mb-3">
+                        <h5><i class="bi bi-info-circle"></i> Screening Questions</h5>
+                        <p>When you generate a job description, 5 relevant screening questions will be automatically created based on the job details. These questions will be presented to candidates when they apply.</p>
+                    </div>
 
                     <div class="text-center">
                         <button type="submit" class="btn btn-primary" id="generate-btn">
@@ -128,6 +133,15 @@
                 <div id="jd-sections">
                     <h3 id="jd-title" class="mb-3"></h3>
                     <div id="jd-content"></div>
+                    
+                    <hr class="my-4">
+                    <div id="screening-questions-section" class="mt-4 p-4 bg-light border rounded">
+                        <h4 class="mb-3"><i class="bi bi-question-circle"></i> Screening Questions</h4>
+                        <div class="alert alert-info">
+                            <strong>Important:</strong> These questions will be presented to candidates when they apply for this position.
+                        </div>
+                        <ol id="screening-questions-list" class="fw-bold"></ol>
+                    </div>
                 </div>
             </div>
         </div>
@@ -240,6 +254,25 @@
                         // Display the generated JD
                         document.getElementById('jd-title').textContent = jobData.position;
                         document.getElementById('jd-content').innerHTML = data.job_description_text.replace(/\n/g, '<br>');
+                        
+                        // Display screening questions
+                        const screeningQuestionsList = document.getElementById('screening-questions-list');
+                        screeningQuestionsList.innerHTML = ''; // Clear previous questions
+                        
+                        if (data.screening_questions && data.screening_questions.length > 0) {
+                            data.screening_questions.forEach(question => {
+                                const li = document.createElement('li');
+                                li.className = 'mb-2';
+                                li.textContent = question;
+                                screeningQuestionsList.appendChild(li);
+                            });
+                            // Store screening questions for saving
+                            window.screeningQuestions = data.screening_questions;
+                        } else {
+                            screeningQuestionsList.innerHTML = '<div class="alert alert-warning">No screening questions were generated.</div>';
+                            window.screeningQuestions = [];
+                        }
+                        
                         document.getElementById('result-card').style.display = 'block';
                         
                         // Scroll to result
@@ -264,7 +297,16 @@
                 const jdText = document.getElementById('jd-content').innerText;
                 const title = document.getElementById('jd-title').innerText;
                 
-                navigator.clipboard.writeText(title + '\n\n' + jdText)
+                // Prepare screening questions text
+                let screeningQuestionsText = '';
+                if (window.screeningQuestions && window.screeningQuestions.length > 0) {
+                    screeningQuestionsText = '\n\nScreening Questions:\n';
+                    window.screeningQuestions.forEach((question, index) => {
+                        screeningQuestionsText += `${index + 1}. ${question}\n`;
+                    });
+                }
+                
+                navigator.clipboard.writeText(title + '\n\n' + jdText + screeningQuestionsText)
                     .then(() => {
                         const originalText = this.textContent;
                         this.textContent = 'Copied!';
@@ -291,6 +333,7 @@
                     body: JSON.stringify({
                         title: title,
                         content: jdText,
+                        screening_questions: window.screeningQuestions || [],
                         metadata: {
                             position: document.getElementById('position').value,
                             location: document.getElementById('location').value,

michael_agent/dashboard/templates/resume_scoring.html

@@ -177,6 +177,15 @@
                                     </div>
                                 </div>
                                 
+                                <div class="card border-primary mb-3">
+                                    <div class="card-header bg-light">Screening Responses</div>
+                                    <div class="card-body">
+                                        <div id="screening-responses-container">
+                                            <p class="text-muted">No screening responses available</p>
+                                        </div>
+                                    </div>
+                                </div>
+                                
                                 <div class="card border-success">
                                     <div class="card-header bg-light">Actions</div>
                                     <div class="card-body">
@@ -482,6 +491,9 @@
                             
                             // AI Analysis - make sure we don't pass undefined
                             renderAIAnalysis(candidate.ai_analysis || {});
+                            
+                            // Screening Responses - make sure we don't pass undefined
+                            renderScreeningResponses(candidate.screening_responses || {});
                         } catch (error) {
                             console.error('Error processing candidate data:', error);
                             document.getElementById('resume-details-card').style.display = 'block';
@@ -906,6 +918,38 @@
                 }
             }
             
+            // Render screening questions and answers
+            function renderScreeningResponses(screeningData) {
+                const container = document.getElementById('screening-responses-container');
+                container.innerHTML = '';
+                
+                if (!screeningData || !screeningData.questions || !screeningData.answers || 
+                    screeningData.questions.length === 0 || screeningData.answers.length === 0) {
+                    container.innerHTML = '<p class="text-muted">No screening responses available</p>';
+                    return;
+                }
+                
+                let html = '<div class="list-group">';
+                
+                // Loop through questions and answers
+                for (let i = 0; i < Math.min(screeningData.questions.length, screeningData.answers.length); i++) {
+                    const question = screeningData.questions[i];
+                    const answer = screeningData.answers[i];
+                    
+                    html += `
+                        <div class="list-group-item">
+                            <div class="d-flex w-100 justify-content-between">
+                                <h6 class="mb-2">Q${i+1}: ${question}</h6>
+                            </div>
+                            <p class="mb-1"><strong>Answer:</strong> ${answer}</p>
+                        </div>
+                    `;
+                }
+                
+                html += '</div>';
+                container.innerHTML = html;
+            }
+            
             // Update statistics
             function updateStatistics(stats) {
                 document.getElementById('total-resumes').textContent = stats.total;

michael_agent/langgraph_workflow/graph_builder.py

@@ -269,7 +269,7 @@ def start_workflow():
         logger.error(traceback.format_exc())
         raise
 
-def process_new_resume(resume_path: str, job_description: Dict[str, Any] = None):
+def process_new_resume(resume_path, job_id=None):
     """Process a new resume through the workflow"""
     try:
         # Extract job ID from filename (e.g., 20250626225207_Michael_Jone.pdf)
@@ -280,6 +280,28 @@ def process_new_resume(resume_path: str, job_description: Dict[str, Any] = None)
         # Create initial state with extracted job ID
         initial_state = create_initial_state(resume_path=resume_path, job_id=job_id)
         
+        # Check for metadata file with screening questions/answers
+        metadata_path = f"{resume_path}.json"
+        if os.path.exists(metadata_path):
+            try:
+                with open(metadata_path, 'r') as f:
+                    metadata = json.load(f)
+                    
+                    # Extract screening questions and answers
+                    if 'screening_questions' in metadata and 'screening_answers' in metadata:
+                        logger.info(f"Found screening questions/answers for resume {resume_path}")
+                        initial_state['screening_questions'] = metadata['screening_questions']
+                        initial_state['screening_answers'] = metadata['screening_answers']
+                        
+                    # Also extract candidate name and email if available
+                    if 'name' in metadata:
+                        initial_state['candidate_name'] = metadata['name']
+                    if 'email' in metadata:
+                        initial_state['candidate_email'] = metadata['email']
+                    
+            except Exception as e:
+                logger.error(f"Error loading metadata file: {str(e)}")
+        
         # Start workflow with initial state
         workflow = build_workflow()
         logger.info(f"[Job {job_id}] Starting workflow processing with job ID {job_id}")

michael_agent/langgraph_workflow/nodes/jd_generator.py

@@ -70,6 +70,35 @@ def get_jd_prompt(job_data: Dict[str, Any]) -> str:
     proposition for potential candidates.
     """
 
+def get_screening_questions_prompt(job_data: Dict[str, Any]) -> str:
+    """Generate the prompt for screening questions creation"""
+    position = job_data.get('position', 'Software Engineer') 
+    return f"""
+    You are an HR specialist creating initial screening questions for job applicants.
+    Create 5 simple screening questions for a {position} role.
+    
+    These questions should:
+    1. Be simple and quick to answer (yes/no or short responses)
+    2. Relate directly to the role's basic requirements
+    3. Help filter candidates early in the process
+    4. Be easy to understand without technical jargon
+    5. Assess key role-related experience or skills
+    
+    Job details:
+    Position: {job_data.get('position', 'Software Engineer')}
+    Required skills: {', '.join(job_data.get('required_skills', []))}
+    Experience level: {job_data.get('experience_level', 'Not specified')}
+    
+    Format your response as a JSON array with exactly 5 questions:
+    [
+      "Question 1",
+      "Question 2",
+      "Question 3", 
+      "Question 4",
+      "Question 5"
+    ]
+    """
+
 def generate_job_description(state: Dict[str, Any]) -> Dict[str, Any]:
     """
     LangGraph node to generate a job description
@@ -83,8 +112,8 @@ def generate_job_description(state: Dict[str, Any]) -> Dict[str, Any]:
     logger.info("Starting job description generation")
     
     # Check if job description already exists in state
-    if state.get("job_description") and state.get("job_description_text"):
-        logger.info("Job description already exists, skipping generation")
+    if state.get("job_description") and state.get("job_description_text") and state.get("screening_questions"):
+        logger.info("Job description and screening questions already exist, skipping generation")
         return state
     
     try:
@@ -108,25 +137,73 @@ def generate_job_description(state: Dict[str, Any]) -> Dict[str, Any]:
                 "preferred_skills": ["Azure", "CI/CD", "TypeScript"]
             }
         
-        # Generate the prompt
-        prompt = get_jd_prompt(job_data)
+        # Generate the prompt for job description
+        jd_prompt = get_jd_prompt(job_data)
+        
+        # Generate the prompt for screening questions
+        sq_prompt = get_screening_questions_prompt(job_data)
+        
+        # Invoke the language model for job description
+        jd_response = llm.invoke(jd_prompt)
+        generated_jd_text = jd_response.content
+        
+        # Invoke the language model for screening questions
+        sq_response = llm.invoke(sq_prompt)
+        generated_sq_text = sq_response.content
+        
+        # Extract questions from the response (handling JSON format)
+        screening_questions = []
+        try:
+            import json
+            import re
+            
+            # Try to parse JSON directly
+            try:
+                screening_questions = json.loads(generated_sq_text)
+            except json.JSONDecodeError:
+                # Extract JSON array using regex if direct parsing fails
+                json_match = re.search(r'\[\s*".*"\s*\]', generated_sq_text, re.DOTALL)
+                if json_match:
+                    screening_questions = json.loads(json_match.group(0))
+                else:
+                    # Simple line-by-line extraction as fallback
+                    lines = generated_sq_text.strip().split('\n')
+                    for line in lines:
+                        question = line.strip().strip('"[]').strip('"').strip()
+                        if question and not question.startswith('#') and not question.startswith('//'):
+                            screening_questions.append(question)
+        except Exception as e:
+            logger.error(f"Error parsing screening questions: {str(e)}")
+            # Fallback questions
+            screening_questions = [
+                f"Do you have experience as a {job_data.get('position', 'professional')}?",
+                f"Are you familiar with {', '.join(job_data.get('required_skills', ['the required skills']))}?",
+                f"Can you work in {job_data.get('location', 'this location')}?",
+                f"Are you available for {job_data.get('employment_type', 'this position type')}?",
+                "How many years of relevant experience do you have?"
+            ]
         
-        # Invoke the language model
-        response = llm.invoke(prompt)
-        generated_text = response.content
+        # Ensure we have exactly 5 questions
+        if len(screening_questions) > 5:
+            screening_questions = screening_questions[:5]
+        while len(screening_questions) < 5:
+            screening_questions.append(f"Do you have experience with {job_data.get('preferred_skills', ['the preferred skills'])[0] if job_data.get('preferred_skills') else 'the relevant technologies'}?")
         
-        # Update the state with the generated job description
+        # Update the state with the generated job description and screening questions
         state["job_description"] = job_data
-        state["job_description_text"] = generated_text
+        state["job_description_text"] = generated_jd_text
+        state["screening_questions"] = screening_questions
         state["status"] = "jd_generated"
         
-        logger.info("Job description generated successfully")
+        logger.info("Job description and screening questions generated successfully")
         
     except Exception as e:
         error_message = f"Error generating job description: {str(e)}"
         logger.error(error_message)
         
         # Add error to state
+        if "errors" not in state:
+            state["errors"] = []
         state["errors"].append({
             "step": "jd_generator",
             "error": error_message
@@ -135,5 +212,15 @@ def generate_job_description(state: Dict[str, Any]) -> Dict[str, Any]:
         # Set fallback job description text if needed
         if not state.get("job_description_text"):
             state["job_description_text"] = "Default job description text for fallback purposes."
+            
+        # Set fallback screening questions if needed
+        if not state.get("screening_questions"):
+            state["screening_questions"] = [
+                "Do you have experience with this role?",
+                "Are you familiar with the required skills?",
+                "Can you work in the specified location?",
+                "Are you available for the listed employment type?",
+                "How many years of relevant experience do you have?"
+            ]
     
     return state

michael_agent/langgraph_workflow/nodes/question_generator.py

@@ -27,9 +27,9 @@ def create_llm():
         logger.error(f"Error initializing Azure OpenAI: {str(e)}")
         return None
 
-def get_question_generation_prompt(resume_text: str, jd_text: str, relevance_score: float) -> str:
+def get_question_generation_prompt(resume_text: str, jd_text: str, relevance_score: float, screening_data=None) -> str:
     """Generate the prompt for interview question generation"""
-    return f"""
+    base_prompt = f"""
     You are an expert technical interviewer and recruiter.
     
     Generate a set of interview questions for a candidate based on their resume and the job description.
@@ -42,34 +42,47 @@ def get_question_generation_prompt(resume_text: str, jd_text: str, relevance_sco
     {jd_text[:1000]}
     
     The candidate's resume relevance score is {relevance_score:.2f} out of 1.0.
+    """
     
+    # Add screening questions and answers if available
+    if screening_data and 'questions' in screening_data and 'answers' in screening_data:
+        screening_prompt = "\nThe candidate has already answered these initial screening questions:\n"
+        for i, (q, a) in enumerate(zip(screening_data['questions'], screening_data['answers'])):
+            screening_prompt += f"Question {i+1}: {q}\nAnswer {i+1}: {a}\n\n"
+        base_prompt += screening_prompt
+        
+    # Add format instructions for the response
+    result_prompt = base_prompt + """
     Generate 10 questions in the following JSON format:
     ```json
-    {{
+    {
         "technical_questions": [
-            {{
+            {
                 "question": "string",
                 "difficulty": "easy|medium|hard",
                 "category": "technical_skill|domain_knowledge|problem_solving",
                 "purpose": "brief explanation of what this question assesses"
-            }},
+            },
             // 4 more technical questions...
         ],
         "behavioral_questions": [
-            {{
+            {
                 "question": "string",
                 "category": "teamwork|leadership|conflict_resolution|problem_solving|adaptability",
                 "purpose": "brief explanation of what this question assesses"
-            }},
+            },
             // 4 more behavioral questions...
         ],
         "follow_up_areas": ["Area 1", "Area 2", "Area 3"]  // Important areas to explore further based on resume gaps
-    }}
+    }
     ```
     
     Focus on questions that will reveal the candidate's true abilities related to the job requirements.
     Include questions that address any potential gaps between the resume and job description.
+    Also, do not repeat questions that were already asked in the screening process.
     """
+    
+    return result_prompt
 
 def generate_interview_questions(state: Dict[str, Any]) -> Dict[str, Any]:
     """Generate interview questions based on resume and job description."""
@@ -162,8 +175,17 @@ def generate_interview_questions(state: Dict[str, Any]) -> Dict[str, Any]:
         # Get resume score from state (default to 0.5 if missing)
         relevance_score = state.get("relevance_score", 0.5)
         
+        # Prepare screening data if available
+        screening_data = None
+        if state.get("screening_questions") and state.get("screening_answers"):
+            screening_data = {
+                "questions": state.get("screening_questions"),
+                "answers": state.get("screening_answers")
+            }
+            logger.info("Including screening questions and answers in question generation")
+            
         # Generate the prompt
-        prompt = get_question_generation_prompt(resume_text, jd_text, relevance_score)
+        prompt = get_question_generation_prompt(resume_text, jd_text, relevance_score, screening_data)
         print(f"[QUESTION_GENERATOR] Created prompt with resume length {len(resume_text)} and JD length {len(jd_text)}")
         
         # Invoke the language model

michael_agent/langgraph_workflow/nodes/resume_analyzer.py

@@ -316,15 +316,15 @@ def extract_jd_sections(jd_text: str) -> Dict[str, str]:
     
     return sections
 
-def compute_similarity_score_llm(client, resume_text: str, jd_text: str) -> float:
+def compute_similarity_score_llm(client, resume_text: str, jd_text: str, screening_data: Dict[str, Any] = None) -> float:
     """Compute similarity score between resume and job description using LLM"""
     try:
         # Truncate texts if they are too long for the LLM context window
         resume_truncated = resume_text[:2000]  # Adjust based on your LLM's limits
         jd_truncated = jd_text[:2000]  # Adjust based on your LLM's limits
         
-        # Create the prompt
-        prompt = f"""
+        # Start building the prompt
+        base_prompt = f"""
         Your task is to compare a resume and job description to determine how well the candidate matches the job requirements.
         
         Job Description:
@@ -332,7 +332,17 @@ def compute_similarity_score_llm(client, resume_text: str, jd_text: str) -> floa
         
         Resume:
         {resume_truncated}
+        """
         
+        # Add screening questions and answers if available
+        if screening_data and 'questions' in screening_data and 'answers' in screening_data:
+            screening_context = "\nCandidate's screening question responses:\n"
+            for i, (q, a) in enumerate(zip(screening_data['questions'], screening_data['answers'])):
+                screening_context += f"Question {i+1}: {q}\nAnswer {i+1}: {a}\n\n"
+            base_prompt += screening_context
+            
+        # Complete the prompt with instructions
+        prompt = base_prompt + """
         Based on the match between the resume and job description, provide a relevance score between 0.0 and 1.0, 
         where 1.0 means perfect match and 0.0 means no match at all.
         
@@ -475,11 +485,21 @@ def analyze_resume(state: Dict[str, Any]) -> Dict[str, Any]:
             resume_sections = extract_resume_sections(resume_text)
             jd_sections = extract_jd_sections(jd_text)
             
+            # Prepare screening data if available
+            screening_data = None
+            if state.get("screening_questions") and state.get("screening_answers"):
+                screening_data = {
+                    "questions": state.get("screening_questions"),
+                    "answers": state.get("screening_answers")
+                }
+                logger.info("Including screening questions and answers in similarity scoring")
+                
             # Compute overall similarity score using LLM
             overall_score = compute_similarity_score_llm(
                 chat_client, 
                 resume_sections["full"], 
-                jd_sections["full"]
+                jd_sections["full"],
+                screening_data
             )
         
         # Store the score in state
@@ -596,6 +616,13 @@ def save_snapshot(state: Dict[str, Any]) -> None:
         if "job_description" in state:
             save_state["job_description"] = state["job_description"]
         
+        # Add screening questions and answers if available
+        if "screening_questions" in state:
+            save_state["screening_questions"] = state["screening_questions"]
+            
+        if "screening_answers" in state:
+            save_state["screening_answers"] = state["screening_answers"]
+        
         # Add relevance score if available
         if "relevance_score" in state:
             save_state["relevance_score"] = state["relevance_score"]
@@ -628,4 +655,155 @@ def save_snapshot(state: Dict[str, Any]) -> None:
         
     except Exception as e:
         logger.error(f"Error saving state snapshot: {str(e)}")
-        logger.error(traceback.format_exc())
+        logger.error(traceback.format_exc())
+
+def analyze_resume_with_llm(resume_text: str, jd_text: str, llm, screening_data: Dict[str, Any] = None) -> Dict[str, Any]:
+    """
+    Analyze the resume using Azure OpenAI, comparing to job description
+    
+    Args:
+        resume_text: The text of the resume
+        jd_text: The text of the job description
+        llm: The LLM client to use
+        screening_data: Dictionary containing screening questions and answers
+        
+    Returns:
+        Analysis results
+    """
+    
+    # Create the system prompt
+    system_prompt = f"""
+    You are an expert resume analyzer and HR professional.
+    Your task is to analyze a resume against a job description and provide
+    a relevance score (0.0-1.0) and detailed feedback.
+    
+    Resume text:
+    {resume_text[:3000] if resume_text else "No resume text provided"}
+    
+    Job Description:
+    {jd_text[:1500] if jd_text else "No job description provided"}
+    """
+    
+    # Add screening questions and answers if available
+    if screening_data and 'questions' in screening_data and 'answers' in screening_data:
+        screening_context = "\n\nCandidate's screening question responses:\n"
+        for i, (q, a) in enumerate(zip(screening_data['questions'], screening_data['answers'])):
+            screening_context += f"Question {i+1}: {q}\nAnswer {i+1}: {a}\n\n"
+        system_prompt += screening_context
+    
+    # Complete the prompt with instructions
+    system_prompt += """
+    Analyze the resume against the job description and provide your assessment in the following JSON format:
+    {
+      "relevance_score": 0.85, // A float from 0.0 to 1.0 indicating overall fit
+      "skill_match": {
+        "matched_skills": ["skill1", "skill2"], // Skills found in both resume and JD
+        "missing_skills": ["skill3", "skill4"]  // Important JD skills not found in resume
+      },
+      "experience_match": {
+        "score": 0.7, // 0.0 to 1.0
+        "feedback": "Candidate has relevant experience in..."
+      },
+      "education_match": {
+        "score": 0.8,
+        "feedback": "Candidate has appropriate education..."
+      },
+      "overall_feedback": "The candidate is a strong fit because..."
+    }
+    
+    Please ensure the JSON is valid and properly formatted.
+    """
+    
+    try:
+        # Truncate text if it's too long to avoid token limits
+        truncated_resume = resume_text[:3000] if resume_text and len(resume_text) > 3000 else resume_text
+        truncated_jd = jd_text[:1500] if jd_text and len(jd_text) > 1500 else jd_text
+        
+        # Create the user message
+        user_message = f"""
+        Resume: {truncated_resume}
+        
+        Job Description: {truncated_jd}
+        
+        Provide a detailed analysis of this resume against the job description in the JSON format specified.
+        """
+        
+        # Get the response
+        response = llm.invoke([
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_message}
+        ])
+        
+        # Extract and parse the JSON response
+        import json
+        import re
+        
+        content = response.content
+        
+        # Try to find a JSON object in the response
+        json_match = re.search(r'\{[\s\S]*\}', content)
+        if json_match:
+            try:
+                return json.loads(json_match.group(0))
+            except json.JSONDecodeError:
+                return parse_analysis_response(content)
+        else:
+            return parse_analysis_response(content)
+    except Exception as e:
+        logger.error(f"Error analyzing resume with LLM: {str(e)}")
+        return {
+            "relevance_score": 0.5,
+            "skill_match": {"matched_skills": [], "missing_skills": []},
+            "experience_match": {"score": 0.5, "feedback": "Error analyzing experience"},
+            "education_match": {"score": 0.5, "feedback": "Error analyzing education"},
+            "overall_feedback": f"Error analyzing resume: {str(e)}"
+        }
+
+def parse_analysis_response(content: str) -> Dict[str, Any]:
+    """
+    Parse the LLM's response to extract analysis information when JSON parsing fails
+    
+    Args:
+        content: The text response from the LLM
+        
+    Returns:
+        Dictionary with analysis results extracted from the text
+    """
+    # Default values
+    result = {
+        "relevance_score": 0.5,
+        "skill_match": {"matched_skills": [], "missing_skills": []},
+        "experience_match": {"score": 0.5, "feedback": "Unable to extract from response"},
+        "education_match": {"score": 0.5, "feedback": "Unable to extract from response"},
+        "overall_feedback": "Analysis completed with limited structure"
+    }
+    
+    # Extract relevance score using regex
+    import re
+    score_match = re.search(r'relevance_score["\s:]+([0-9\.]+)', content)
+    if score_match:
+        try:
+            result["relevance_score"] = float(score_match.group(1))
+        except ValueError:
+            pass
+    
+    # Extract matched skills
+    matched_skills_match = re.search(r'matched_skills["\s:]+\[(.*?)\]', content, re.DOTALL)
+    if matched_skills_match:
+        skills_text = matched_skills_match.group(1)
+        skills = [s.strip().strip('"\'').strip() for s in skills_text.split(',')]
+        result["skill_match"]["matched_skills"] = [s for s in skills if s]
+    
+    # Extract missing skills
+    missing_skills_match = re.search(r'missing_skills["\s:]+\[(.*?)\]', content, re.DOTALL)
+    if missing_skills_match:
+        skills_text = missing_skills_match.group(1)
+        skills = [s.strip().strip('"\'').strip() for s in skills_text.split(',')]
+        result["skill_match"]["missing_skills"] = [s for s in skills if s]
+    
+    # Extract overall feedback
+    feedback_match = re.search(r'overall_feedback["\s:]+["\'](.*?)["\']', content, re.DOTALL)
+    if feedback_match:
+        result["overall_feedback"] = feedback_match.group(1).strip()
+    
+    return result

michael_agent/langgraph_workflow/nodes/sentiment_analysis.py

@@ -74,19 +74,33 @@ def extract_cover_letter(resume_text: str) -> Optional[str]:
     
     return cover_letter_text
 
-def analyze_text_sentiment_openai_chat(client, text: str) -> Dict[str, Any]:
+def analyze_text_sentiment_openai_chat(client, text: str, screening_data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
     """
     Analyze text sentiment using Azure OpenAI Chat
     Args:
         client: Azure OpenAI client
         text: Text to analyze
+        screening_data: Dictionary containing screening questions and answers for additional context
     Returns:
         Sentiment analysis result
     """
     try:
-        # Create the prompt
-        prompt = f"""
-        Analyze the sentiment of the following text. Respond with a JSON object containing:
+        # Create the base prompt
+        base_prompt = f"""
+        Analyze the sentiment of the following text.
+        """
+        
+        # Add screening questions and answers context if available
+        screening_context = ""
+        if screening_data and 'questions' in screening_data and 'answers' in screening_data:
+            screening_context = "\n\nCandidate's screening question responses:\n"
+            for i, (q, a) in enumerate(zip(screening_data['questions'], screening_data['answers'])):
+                screening_context += f"Question {i+1}: {q}\nAnswer {i+1}: {a}\n\n"
+            base_prompt += f"\nConsider the following screening question responses as additional context for sentiment analysis:{screening_context}"
+        
+        # Complete the prompt
+        prompt = base_prompt + f"""
+        Respond with a JSON object containing:
         - sentiment: either "positive", "neutral", or "negative"
         - positive_score: a float between 0 and 1
         - neutral_score: a float between 0 and 1
@@ -256,6 +270,15 @@ def analyze_sentiment(state: Dict[str, Any]) -> Dict[str, Any]:
         # If no cover letter found, use the first 1000 characters of resume as a sample
         sample_text = cover_letter if cover_letter else resume_text[:1000]
         
+        # Prepare screening data if available
+        screening_data = None
+        if state.get("screening_questions") and state.get("screening_answers"):
+            screening_data = {
+                "questions": state.get("screening_questions"),
+                "answers": state.get("screening_answers")
+            }
+        logger.info(f"Screening data prepared: {screening_data}")
+        
         # Initialize clients and results
         sentiment_result = None
         chat_client = None
@@ -268,7 +291,7 @@ def analyze_sentiment(state: Dict[str, Any]) -> Dict[str, Any]:
         # Only use chat-based or basic sentiment analysis
         if chat_client:
             # Method 1: Use Azure OpenAI Chat for sentiment analysis
-            sentiment_result = analyze_text_sentiment_openai_chat(chat_client, sample_text)
+            sentiment_result = analyze_text_sentiment_openai_chat(chat_client, sample_text, screening_data)
             logger.info("Used Azure OpenAI Chat for sentiment analysis")
         else:
             # Fallback: Basic sentiment analysis
@@ -279,6 +302,7 @@ def analyze_sentiment(state: Dict[str, Any]) -> Dict[str, Any]:
         sentiment_result["cover_letter_available"] = True if cover_letter else False
         sentiment_result["text_used"] = "cover_letter" if cover_letter else "resume_sample"
         sentiment_result["available"] = True
+        sentiment_result["screening_data_used"] = screening_data is not None
         
         # Update state
         state["sentiment_score"] = sentiment_result

michael_agent/main.py

@@ -16,39 +16,41 @@ from dotenv import load_dotenv
 load_dotenv()
 
 # Then import settings which may depend on environment variables
-from .config import settings
+from config import settings 
 
 # Import our logging utilities early to set up logging
-from .utils.logging_utils import workflow_logger as logger
-
-def ensure_directories():
-    """Ensure all required directories exist"""
-    required_directories = [
-        settings.RESUME_WATCH_DIR,
-        settings.OUTPUT_DIR,
-        settings.LOG_DIR,
-        os.path.join(settings.LOG_DIR, "snapshots"),
-        settings.LANGGRAPH_CHECKPOINT_DIR,
-        settings.JOB_DESCRIPTIONS_DIR
-    ]
-
-    for directory in required_directories:
-        os.makedirs(directory, exist_ok=True)
-        logger.info(f"Ensured directory exists: {directory}")
-    
-    # Import node tracer after directories are created
-    from .utils import node_tracer
+from utils.logging_utils import workflow_logger as logger
+
+# Ensure all required directories exist
+required_directories = [
+    settings.RESUME_WATCH_DIR,
+    settings.OUTPUT_DIR,
+    settings.LOG_DIR,
+    os.path.join(settings.LOG_DIR, "snapshots"),
+    settings.LANGGRAPH_CHECKPOINT_DIR,
+    settings.JOB_DESCRIPTIONS_DIR
+]
+
+for directory in required_directories:
+    os.makedirs(directory, exist_ok=True)
+    logger.info(f"Ensured directory exists: {directory}")
+
+# Import our node tracer to apply logging to all workflow nodes
+# This must be imported after directories are created but before the workflow starts
+import utils.node_tracer
+from utils.id_mapper import get_timestamp_id, get_all_ids_for_timestamp
 
 def start_langgraph():
     """Start the LangGraph workflow in a separate thread"""
+    global langgraph_app  # Add a global reference to store the app
     try:
-        from .langgraph_workflow.graph_builder import start_workflow
+        from langgraph_workflow.graph_builder import start_workflow
         logger.info("Starting LangGraph workflow engine...")
-        langgraph_app = start_workflow()
+        langgraph_app = start_workflow()  # Store the returned app
         
         # Keep the thread alive with a simple loop
         while True:
-            time.sleep(10)
+            time.sleep(10)  # Sleep to avoid high CPU usage
     except Exception as e:
         logger.error(f"Error starting LangGraph workflow: {str(e)}")
         logger.error(traceback.format_exc())
@@ -56,14 +58,22 @@ def start_langgraph():
 def start_flask_dashboard():
     """Start the Flask dashboard in a separate thread"""
     try:
-        from .dashboard.app import app, socketio
-        port = int(os.getenv("FLASK_PORT", 5000))
-        logger.info(f"Starting Flask dashboard on port {port}...")
-        socketio.run(app, host='0.0.0.0', port=port, debug=False, allow_unsafe_werkzeug=True)
+        from dashboard.app import app, socketio
+        # Use threading instead of eventlet for the background tasks
+        import threading
+
+        # Configure Socket.IO to not use eventlet
+        socketio.init_app(app, async_mode='threading')
+
+        port = int(os.getenv("FLASK_PORT", 8080))
+        logger.info(f"Starting Flask dashboard on http://localhost:{port}")
+        # Start the Flask app with threading
+        socketio.run(app, host='0.0.0.0', port=port, debug=os.getenv("FLASK_ENV") == "development", use_reloader=False, allow_unsafe_werkzeug=True)
     except Exception as e:
         logger.error(f"Error starting Flask dashboard: {str(e)}")
         logger.error(traceback.format_exc())
 
+
 def main():
     """Main entry point for the application"""
     logger.info("=" * 50)
@@ -71,9 +81,7 @@ def main():
     logger.info(f"Date/Time: {datetime.now().isoformat()}")
     logger.info("=" * 50)
 
-    ensure_directories()
-    
-    port = int(os.getenv("FLASK_PORT", 5000))
+    port = int(os.getenv("FLASK_PORT", 8080))
     logger.info(f"Dashboard will be available at: http://localhost:{port}")
     
     try:
@@ -84,10 +92,15 @@ def main():
 
         # Give LangGraph more time to initialize
         logger.info("Waiting for LangGraph to initialize...")
-        time.sleep(5)
+        time.sleep(5)  # Increased from 2 to 5 seconds
 
         logger.info("LangGraph initialization complete")
 
+        # Verify job description directory exists and is accessible
+        job_description_dir = "job_descriptions"
+        os.makedirs(job_description_dir, exist_ok=True)
+        logger.info(f"Job description directory verified: {job_description_dir}")
+
         # Start Flask dashboard in the main thread
         logger.info("Starting Flask dashboard in main thread...")
         start_flask_dashboard()
@@ -98,6 +111,49 @@ def main():
         logger.error(traceback.format_exc())
     finally:
         logger.info("SmartRecruitAgent shutting down...")
-
+    
 if __name__ == "__main__":
     main()
+
+def on_created(self, event):
+    """Process newly created resume files"""
+    # Skip temporary files and directories
+    if event.is_directory or event.src_path.endswith('.tmp'):
+        return
+        
+    # Check if the file matches resume extensions
+    file_ext = os.path.splitext(event.src_path)[1].lower()
+    if file_ext not in self.valid_extensions:
+        return
+        
+    try:
+        # Create timestamped filename if needed
+        filename = os.path.basename(event.src_path)
+        if not self.has_timestamp_prefix(filename):
+            # Add timestamp as job ID prefix
+            timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
+            new_filename = f"{timestamp}_{filename}"
+            new_path = os.path.join(os.path.dirname(event.src_path), new_filename)
+            os.rename(event.src_path, new_path)
+            file_path = new_path
+        else:
+            file_path = event.src_path
+            
+        logger.info(f"New resume detected: {file_path}")
+        
+        # Process the resume through the workflow
+        self.processor_func(file_path)
+    except Exception as e:
+        logger.error(f"Error processing new resume {event.src_path}: {str(e)}")
+        logger.error(traceback.format_exc())
+    
+def has_timestamp_prefix(self, filename):
+    """Check if filename has a timestamp prefix in format YYYYMMDDHHMMSS_"""
+    # Extract the first part before underscore
+    parts = filename.split('_', 1)
+    if len(parts) < 2:
+        return False
+        
+    prefix = parts[0]
+    # Check if prefix is a 14-digit number (YYYYMMDDHHMMSS)
+    return len(prefix) == 14 and prefix.isdigit()

{michael_agent-1.0.4.dist-info → michael_agent-1.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: michael_agent
-Version: 1.0.4
+Version: 1.0.5
 Summary: SmartRecruitAgent - A recruitment automation library
 Home-page: https://github.com/yourusername/agent
 Author: Michael Jone

{michael_agent-1.0.4.dist-info → michael_agent-1.0.5.dist-info}/RECORD

@@ -1,29 +1,29 @@
 michael_agent/__init__.py,sha256=prEeI3mdpO8R5QTpniRR_Tl21uqF7pGJHwBidQ9JIKQ,179
-michael_agent/main.py,sha256=j5BXOxg_8YE-bnu3cKrylQCHCssZ6PP4UbGorRVJMd4,3385
+michael_agent/main.py,sha256=a_sUmlS2fSZ0dfU0f0ukjhr36cmWESfr_7DG6lot0-s,5790
 michael_agent/monitor.py,sha256=RThpdPW7lf5zI3ilMShVeDf4Vao5Yq0E4Rao9uuS9XY,2473
 michael_agent/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 michael_agent/config/settings.py,sha256=_4uvWQnMscK01Sd0zT5wesVW5uN0njtKYRMsjMQXEOY,3180
 michael_agent/dashboard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-michael_agent/dashboard/app.py,sha256=UtMswD7TGGJBY9cMeuFQPJAtgaRiXFso6PsTHtvPGN8,61963
+michael_agent/dashboard/app.py,sha256=kArwbsiYR1FzAcxOA_Xzf3uDlFuXj4uDFGvMN9QWuuw,64161
 michael_agent/dashboard/static/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 michael_agent/dashboard/static/styles.css,sha256=vSG1saAHIYxw_7sH5z9NipzvkRx3x4kMEjhgx0aUKow,6030
 michael_agent/dashboard/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-michael_agent/dashboard/templates/career_portal.html,sha256=ImVi7f2lvbv-xgQE7AtRpbrWDA_CbeQj02xGwOtS7-U,24128
+michael_agent/dashboard/templates/career_portal.html,sha256=7hUcKQvAh_U8S0hdnJdzKDzZ-a3vuz3T-hJdp6CqvIU,28419
 michael_agent/dashboard/templates/dashboard.html,sha256=VepZKTvsaPQaCVR-Nxw00gx3ueiBZMxlIIIxr__6nKU,39877
-michael_agent/dashboard/templates/jd_creation.html,sha256=5YqYLFhfQaE8GogWXuZeRQ24IHg7M_J9O3ai5ojhwhE,15931
-michael_agent/dashboard/templates/resume_scoring.html,sha256=ylvM9OVGqi-T1XaAR49OYbuV_3KiKa2SswWGe2O5yOc,54843
+michael_agent/dashboard/templates/jd_creation.html,sha256=mACZFlDmPZVvDCibV4xhnlLXMSkNjdFnrAyRLPFKEmk,18725
+michael_agent/dashboard/templates/resume_scoring.html,sha256=m7piNDOs_tKuH9BSGl3DZpsaN8wGVAfnLaUTsd4ByBE,57187
 michael_agent/dashboard/templates/upload_resume.html,sha256=mG-92r1L3A4N-tEdaSRd35ez92fx6Wg7y9gnvhObc_w,19995
 michael_agent/langgraph_workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-michael_agent/langgraph_workflow/graph_builder.py,sha256=xdsZ_lVWFn5B8xNXg_L49H-Jwfj-p7nxPVOwtc9Rf2U,14487
+michael_agent/langgraph_workflow/graph_builder.py,sha256=G7bhOxi6QyCCGkF-8D2Q2TkAidT0hoMKGN52lUM8whg,15658
 michael_agent/langgraph_workflow/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 michael_agent/langgraph_workflow/nodes/assessment_handler.py,sha256=qgMB8fJdyA2CP8VWY2m-7-418LcY302S-SR_JHamSTE,6401
-michael_agent/langgraph_workflow/nodes/jd_generator.py,sha256=G8cM3NkGqd44iUAbJJDed9kFjJ-F02_FXB6I_7AE_kA,5105
+michael_agent/langgraph_workflow/nodes/jd_generator.py,sha256=h1seH2JHgvDEJA03oTzzBs7fC63CVuavLuDwFYv3k9M,9364
 michael_agent/langgraph_workflow/nodes/jd_poster.py,sha256=6F1jQRG_IoiopIOpIDjSpuCE3I6_A7-ZEMkV8FtKXQs,4550
-michael_agent/langgraph_workflow/nodes/question_generator.py,sha256=XgDc5f7-ifsJ3UdzB22NjKMqjUcG2_elTZ5LOPGVkt8,11670
+michael_agent/langgraph_workflow/nodes/question_generator.py,sha256=bXCrq6lxeabimp7uAL9ndiLVS3t8pzwVXcaz6lepqqI,12813
 michael_agent/langgraph_workflow/nodes/recruiter_notifier.py,sha256=xLVhRP1I-QIcO_b0lYLuMnMTpGHAFakG-luPJrhkN6Y,8522
-michael_agent/langgraph_workflow/nodes/resume_analyzer.py,sha256=XG4MksqSqhhNwGSfDauIbEpPmxogDJ6skJgR-xpeY0g,24027
+michael_agent/langgraph_workflow/nodes/resume_analyzer.py,sha256=z5X5Mo2dAT1F33dFY_JN_PSKpQYrb0dgV4jOeUMCYD0,31403
 michael_agent/langgraph_workflow/nodes/resume_ingestor.py,sha256=h14J4AcFk22BWoFHCPRkK3HpzY8RvwGW6_jjqBxLXNU,9279
-michael_agent/langgraph_workflow/nodes/sentiment_analysis.py,sha256=H-geV4AbFbt1EpiLKnpaXdvrrjjXMN-Dzzg4sZOjhdM,11657
+michael_agent/langgraph_workflow/nodes/sentiment_analysis.py,sha256=St2opmz3naiCw9Z0b4CVMWXOdYCDpdV55LMaigZOJj4,13017
 michael_agent/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 michael_agent/utils/email_utils.py,sha256=PsL3QTQuV_iVou_2Y3o_Dohz7tN9YNp9FPxsTKkDRv0,4989
 michael_agent/utils/id_mapper.py,sha256=GzYRuAhGWf2BUAb9hVMS3KR8bmYExnmXRWkQ_j-kWaw,397
@@ -32,7 +32,7 @@ michael_agent/utils/lms_api.py,sha256=tmntU6tjyAdMLak_vfoxBkWNIPUKvejeEwb2t6yQBU
 michael_agent/utils/logging_utils.py,sha256=Ld7fs2uuCOM0bx-totxHzKzKHl5lfAe3TXeH1QYJBjw,7179
 michael_agent/utils/monitor_utils.py,sha256=1Ig6C79bQ_OOLKhgFNmm0ybntQavqzyJ3zsxD0iZxxw,11069
 michael_agent/utils/node_tracer.py,sha256=N1MWly4qfzh87Fo1xRS5hpefoAvfSyZIPvMOegPrtBY,3411
-michael_agent-1.0.4.dist-info/METADATA,sha256=sqpBqSp6klOnKtRHLKwTKWswuhQwEo7P6fv-QW3Y33s,1340
-michael_agent-1.0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-michael_agent-1.0.4.dist-info/top_level.txt,sha256=-r35JOIHnK3RsMhJ77tDKfWtmfGDr_iT2642k-suUDo,14
-michael_agent-1.0.4.dist-info/RECORD,,
+michael_agent-1.0.5.dist-info/METADATA,sha256=hUavXJcuPMKXoDvQ6PBuXgNgcW2p21Lkjf_Xts1SrzY,1340
+michael_agent-1.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+michael_agent-1.0.5.dist-info/top_level.txt,sha256=-r35JOIHnK3RsMhJ77tDKfWtmfGDr_iT2642k-suUDo,14
+michael_agent-1.0.5.dist-info/RECORD,,