Resume analysis upgrade: structured CV↔JD analysis (sub-scores, matched/missing skills, experience, summary, verdict), .docx parsing, strong skills-based fallback; store full cv_analysis

requirements.txt

@@ -22,6 +22,7 @@ pymongo[srv]==4.6.1
 dnspython>=2.3.0
 
 PyPDF2==3.0.1
+python-docx==1.1.2
 
 # ─── Auth (JWT) ──────────────────────────────────────────────
 PyJWT==2.10.1

routes/applications.py

@@ -5,7 +5,7 @@ import uuid
 import os
 import logging
 from services.application_manager import create_application, get_applications_by_job, get_applications_by_user, update_status, get_application_by_id
-from services.ai_engine import score_cv_against_job
+from services.ai_engine import score_cv_against_job, analyze_cv_against_job
 from services.job_manager import get_job
 from services.email_service import send_status_email
 from services.reminders import run_reminder_check
@@ -46,49 +46,58 @@ async def apply(
             with open(resume_path, "wb") as f:
                 f.write(content)
             
-            # Try to extract text from resume
-            if resume.filename.endswith('.txt'):
+            # Try to extract text from resume (txt / pdf / docx)
+            fn = (resume.filename or "").lower()
+            if fn.endswith('.txt'):
                 cv_text = content.decode('utf-8', errors='ignore')
-            elif resume.filename.endswith('.pdf'):
+            elif fn.endswith('.pdf'):
                 try:
                     import PyPDF2
                     with open(resume_path, 'rb') as f:
                         reader = PyPDF2.PdfReader(f)
                         cv_text = ' '.join([page.extract_text() or '' for page in reader.pages])
-                except ImportError:
-                    logger.warning("PyPDF2 not installed, cannot extract PDF text")
-                    cv_text = ""
                 except Exception as e:
                     logger.error(f"PDF extraction error: {e}")
                     cv_text = ""
+            elif fn.endswith('.docx'):
+                try:
+                    import docx  # python-docx
+                    d = docx.Document(resume_path)
+                    parts = [p.text for p in d.paragraphs if p.text]
+                    for tbl in d.tables:
+                        for row in tbl.rows:
+                            parts.append(" ".join(c.text for c in row.cells if c.text))
+                    cv_text = "\n".join(parts)
+                except Exception as e:
+                    logger.error(f"DOCX extraction error: {e}")
+                    cv_text = ""
             else:
-                # For doc/docx, simple placeholder
                 cv_text = f"Resume uploaded: {resume.filename}"
-                
+
         except Exception as e:
             logger.error(f"Resume processing error: {e}")
             resume_path = f"resume_{uuid.uuid4()}_{resume.filename}"
-    
+
     # Get job details for scoring
     job = get_job(job_id)
     job_description = job.get('description', '') if job else ''
     job_title = job.get('title', '') if job else ''
-    
-    # Calculate CV match score (0-100)
+
+    # Rich CV↔JD analysis (AI when available, structured heuristic otherwise)
     cv_score = 0
+    cv_analysis = None
     if cv_text and job_description:
-        cv_score = score_cv_against_job(cv_text, job_description, job_title)
-        logger.info(f"CV Score for {candidate_name}: {cv_score}%")
+        cv_analysis = analyze_cv_against_job(cv_text, job_description, job_title)
+        cv_score = cv_analysis.get("overall_score", 0)
+        logger.info(f"CV analysis for {candidate_name}: {cv_score}% ({cv_analysis.get('source')})")
     else:
         logger.warning(f"No CV text extracted for {candidate_name}, skipping scoring")
-    
-    # Auto-decision: If score >= 50, auto shortlist
+
+    # Auto-decision: score >= 50 -> auto shortlist
     auto_status = "shortlisted" if cv_score >= 50 else "pending"
-    
     if auto_status == "shortlisted":
-        logger.info(f"✅ Auto-shortlisted {candidate_name} for {job_title} with score {cv_score}%")
-    
-    # Create application with CV score and auto status
+        logger.info(f"✅ Auto-shortlisted {candidate_name} for {job_title} ({cv_score}%)")
+
     app = create_application({
         "job_id": job_id,
         "user_id": user_id,
@@ -96,13 +105,13 @@ async def apply(
         "candidate_email": candidate_email,
         "cover_letter": cover_letter,
         "resume_path": resume_path,
-        "cv_text": (cv_text or "")[:8000],  # durable in Mongo -> used for interview personalisation + CV view
+        "cv_text": (cv_text or "")[:8000],  # durable in Mongo -> interview personalisation + CV view
         "cv_score": cv_score,
+        "cv_analysis": cv_analysis,         # full breakdown for the recruiter
         "status": auto_status,
         "applied_at": datetime.now().isoformat()
     })
-    
-    # Return application (cv_score hidden from candidate in frontend)
+
     return {
         "id": app["id"],
         "job_id": app["job_id"],
@@ -113,7 +122,7 @@ async def apply(
         "resume_path": app["resume_path"],
         "status": app["status"],
         "applied_at": app["applied_at"],
-        "cv_score": cv_score  # Will be hidden in frontend for candidates
+        "cv_score": cv_score,
     }
 
 

services/ai_engine.py

@@ -450,30 +450,118 @@ def generate_contextual_questions(job_description):
 # CV SCORING AGAINST JOB DESCRIPTION
 # ─────────────────────────────────────────────
 
-def score_cv_against_job(cv_text, job_description, job_title):
-    """
-    Score CV against job description using Gemini AI
-    Returns score from 0-100
-    """
+# Skills the analyzer recognises in a JD/CV (lowercase; multi-word allowed).
+CV_SKILL_VOCAB = [
+    # languages
+    "python", "java", "javascript", "typescript", "c++", "c#", "go", "golang", "ruby",
+    "php", "swift", "kotlin", "scala", "rust", "matlab", "sql",
+    # web / frontend / backend
+    "react", "angular", "vue", "next.js", "nextjs", "node.js", "node", "express",
+    "django", "flask", "fastapi", "spring", "laravel", "html", "css", "tailwind",
+    "bootstrap", "redux", "graphql", "rest api", "rest", "microservices",
+    # data / ml
+    "machine learning", "deep learning", "nlp", "computer vision", "tensorflow",
+    "pytorch", "scikit-learn", "scikit", "pandas", "numpy", "data analysis",
+    "data science", "power bi", "tableau", "excel", "statistics", "spark", "hadoop",
+    # cloud / devops
+    "aws", "azure", "gcp", "docker", "kubernetes", "ci/cd", "jenkins", "terraform",
+    "linux", "git", "github", "gitlab", "devops",
+    # databases
+    "mongodb", "postgresql", "mysql", "redis", "firebase", "sqlite", "oracle", "elasticsearch",
+    # mobile
+    "android", "ios", "flutter", "react native",
+    # design
+    "figma", "photoshop", "illustrator", "ui/ux", "ux design", "ui design",
+    # security / qa
+    "cybersecurity", "penetration testing", "testing", "selenium", "qa", "junit", "automation",
+    # business / soft
+    "communication", "leadership", "teamwork", "problem solving", "agile", "scrum",
+    "project management", "marketing", "seo", "sales", "content writing",
+    "accounting", "finance", "customer service",
+]
+
+_STOP = set("the a an and or but in on at to for of with by from as is was are be have "
+            "has had this that these those will can our we you your role job".split())
+
+
+def _keyword_overlap(cv_lower, jd_lower):
+    """Percentage of meaningful JD keywords that appear in the CV."""
+    words = [w for w in re.findall(r"[a-zA-Z][a-zA-Z+.#-]{2,}", jd_lower) if w not in _STOP]
+    kws = list(dict.fromkeys(words))[:40]
+    if not kws:
+        return 50
+    hits = sum(1 for k in kws if k in cv_lower)
+    return int(min(100, round(hits / len(kws) * 100)))
+
+
+def _fallback_cv_analysis(cv_text, job_description):
+    """Structured CV analysis without AI — skills match + experience + education."""
+    cv = (cv_text or "").lower()
+    jd = (job_description or "").lower()
+
+    required = [s for s in CV_SKILL_VOCAB if s in jd]
+    matched  = [s for s in required if s in cv]
+    missing  = [s for s in required if s not in cv]
+    skill_match = int(round(len(matched) / len(required) * 100)) if required else _keyword_overlap(cv, jd)
+
+    cv_years  = [int(x) for x in re.findall(r"(\d+)\+?\s*(?:years|yrs|year)", cv)]
+    exp_years = max(cv_years) if cv_years else 0
+    jd_years  = [int(x) for x in re.findall(r"(\d+)\+?\s*(?:years|yrs|year)", jd)]
+    need      = max(jd_years) if jd_years else 0
+    if need:
+        experience_match = int(min(100, round((exp_years / need) * 100))) if exp_years else 20
+    else:
+        experience_match = 70 if exp_years else 50
+
+    edu_kw = ["bachelor", "master", "phd", "bsc", "msc", "b.s", "m.s", "mba", "degree",
+              "university", "diploma", "b.e", "b.tech", "computer science", "software engineering"]
+    education_match = 80 if any(k in cv for k in edu_kw) else 40
+
+    relevance = _keyword_overlap(cv, jd)
+    overall = int(round(skill_match * 0.5 + experience_match * 0.2 + education_match * 0.1 + relevance * 0.2))
+    overall = max(0, min(100, overall))
+    verdict = ("Strong match" if overall >= 75 else "Good match" if overall >= 55
+               else "Partial match" if overall >= 35 else "Weak match")
+    summary = (f"Matched {len(matched)} of {len(required) or '—'} key skills"
+               + (f"; ~{exp_years} yrs experience detected" if exp_years else "")
+               + f". {verdict}.")
+    return {
+        "overall_score": overall,
+        "skill_match": skill_match,
+        "experience_match": experience_match,
+        "education_match": education_match,
+        "relevance": relevance,
+        "matched_skills": [s.title() for s in matched][:15],
+        "missing_skills": [s.title() for s in missing][:15],
+        "experience_years": exp_years or None,
+        "summary": summary,
+        "verdict": verdict,
+        "source": "heuristic",
+    }
+
+
+def analyze_cv_against_job(cv_text, job_description, job_title):
+    """Rich CV↔JD analysis: overall + sub-scores + matched/missing skills + summary.
+    Uses Gemini when available, falls back to a structured heuristic otherwise."""
+    if not cv_text or len(cv_text.strip()) < 20:
+        return {
+            "overall_score": 0, "skill_match": 0, "experience_match": 0,
+            "education_match": 0, "relevance": 0, "matched_skills": [], "missing_skills": [],
+            "experience_years": None, "summary": "No readable text could be extracted from this CV.",
+            "verdict": "Unreadable", "source": "none",
+        }
+
     api_key = os.getenv("GOOGLE_API_KEY")
-    
     if not api_key or api_key == "AIzaSyDB9W3DC-38GpXrrjUJu8OjgsnudmhEIVA":
-        logger.warning("No valid API key for CV scoring")
-        return calculate_fallback_score(cv_text, job_description)
-    
+        return _fallback_cv_analysis(cv_text, job_description)
+
     try:
-        logger.info("🤖 Scoring CV against job description...")
-        
         llm = ChatGoogleGenerativeAI(
-            model=GEMINI_MODEL,
-            google_api_key=api_key,
-            temperature=0.1,
-            max_tokens=200,
-            max_retries=1,
+            model=GEMINI_MODEL, google_api_key=api_key,
+            temperature=0.1, max_tokens=700, max_retries=1,
         )
-        
         prompt = ChatPromptTemplate.from_template("""
-You are an expert HR recruiter. Analyze the candidate's CV against the job description and give a match score.
+You are an expert technical recruiter. Analyse the candidate's CV against the job and return a STRUCTURED match assessment.
 
 JOB TITLE: {job_title}
 JOB DESCRIPTION:
@@ -482,67 +570,49 @@ JOB DESCRIPTION:
 CANDIDATE CV:
 {cv_text}
 
-SCORING CRITERIA (0-100):
-- 90-100: Perfect match, all requirements met with strong experience
-- 70-89: Very good match, most requirements met
-- 50-69: Good match, some gaps but promising
-- 30-49: Partial match, significant gaps
-- 0-29: Poor match, not suitable
-
-Consider:
-1. Required skills vs candidate skills
-2. Years of experience match
-3. Relevant technologies/domain knowledge
-4. Education/certifications if mentioned
-5. Overall relevance to the role
-
-Return ONLY the score as a number between 0 and 100.
-Example: 85
+Score each 0-100 and identify skills. Be fair and evidence-based — do not invent skills not in the CV.
+Return ONLY this JSON (no markdown):
+{{"overall_score": <0-100>, "skill_match": <0-100>, "experience_match": <0-100>, "education_match": <0-100>, "relevance": <0-100>, "experience_years": <int or null>, "matched_skills": ["..."], "missing_skills": ["..."], "summary": "<2 sentences>", "verdict": "Strong match|Good match|Partial match|Weak match"}}
 """)
-        
         chain = prompt | llm | StrOutputParser()
         result = safe_invoke(chain, {
-            "cv_text": cv_text[:3000],
-            "job_description": job_description,
-            "job_title": job_title
-        })
-        if result is None:
-            return calculate_fallback_score(cv_text, job_description)
-        score = int(result.strip())
-        score = max(0, min(100, score))
-        logger.info(f"✅ CV Score: {score}% for job: {job_title}")
-        return score
-        
+            "cv_text": (cv_text or "")[:4000],
+            "job_description": (job_description or "")[:2000],
+            "job_title": job_title or "the role",
+        }, timeout=25)
+        if not result:
+            return _fallback_cv_analysis(cv_text, job_description)
+        m = re.search(r"\{.*\}", result, re.DOTALL)
+        if not m:
+            return _fallback_cv_analysis(cv_text, job_description)
+        d = json.loads(m.group(0))
+
+        def _clamp(v):
+            try: return max(0, min(100, int(v)))
+            except Exception: return 0
+        analysis = {
+            "overall_score":    _clamp(d.get("overall_score", 0)),
+            "skill_match":      _clamp(d.get("skill_match", 0)),
+            "experience_match": _clamp(d.get("experience_match", 0)),
+            "education_match":  _clamp(d.get("education_match", 0)),
+            "relevance":        _clamp(d.get("relevance", 0)),
+            "experience_years": d.get("experience_years"),
+            "matched_skills":   [str(s) for s in (d.get("matched_skills") or [])][:15],
+            "missing_skills":   [str(s) for s in (d.get("missing_skills") or [])][:15],
+            "summary":          str(d.get("summary", ""))[:400],
+            "verdict":          str(d.get("verdict", "")) or "Partial match",
+            "source":           "ai",
+        }
+        logger.info(f"✅ AI CV analysis: {analysis['overall_score']}% for {job_title}")
+        return analysis
     except Exception as e:
-        logger.error(f"CV scoring error: {e}")
-        return calculate_fallback_score(cv_text, job_description)
+        logger.error(f"CV analysis error: {e}")
+        return _fallback_cv_analysis(cv_text, job_description)
 
 
-def calculate_fallback_score(cv_text, job_description):
-    """
-    Fallback scoring when AI is unavailable
-    """
-    cv_lower = cv_text.lower()
-    job_lower = job_description.lower()
-    
-    # Extract keywords from job description
-    words = job_lower.split()
-    common_words = set(['the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 
-                        'for', 'of', 'with', 'by', 'from', 'as', 'is', 'was', 'are', 
-                        'be', 'have', 'has', 'had', 'this', 'that', 'these', 'those'])
-    keywords = [w for w in words if len(w) > 3 and w not in common_words]
-    keywords = list(set(keywords))[:30]
-    
-    # Count matches
-    matches = sum(1 for kw in keywords if kw in cv_lower)
-    score = int((matches / len(keywords)) * 100) if keywords else 50
-    
-    # Boost for longer CV (more detail)
-    if len(cv_text) > 500:
-        score = min(100, score + 10)
-    
-    logger.info(f"⚠️ Fallback CV Score: {score}%")
-    return min(100, max(0, score))
+def score_cv_against_job(cv_text, job_description, job_title):
+    """Backward-compatible wrapper — returns just the overall 0-100 score."""
+    return analyze_cv_against_job(cv_text, job_description, job_title)["overall_score"]
 
 
 # ─────────────────────────────────────────────

services/application_manager.py

@@ -21,6 +21,7 @@ def create_application(data):
             "resume_path": data.get("resume_path"),
             "cv_text": data.get("cv_text", ""),
             "cv_score": data.get("cv_score", 0),
+            "cv_analysis": data.get("cv_analysis"),  # full CV↔JD breakdown for recruiters
             "status": data.get("status", "pending"),
             "applied_at": data.get("applied_at", datetime.now().isoformat()),
             "updated_at": datetime.now().isoformat()