resumemakerats 0.1.0__py3-none-any.whl

resumemakerats/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

resumemakerats/ats_scorer.py

@@ -0,0 +1,316 @@
+"""
+ATS Scorer - Hybrid rule-based + AI scoring.
+
+Independently scores each component (no circular derivation):
+- Keyword Match (40%): Fuzzy matching of JD keywords against resume text
+- Format Score (20%): ATS-unfriendly element detection
+- Section Completeness (10%): Required sections present
+- Experience Relevance (15%): AI-based semantic relevance
+- Skills Match (15%): Direct + fuzzy skill comparison
+"""
+
+import logging
+import re
+from typing import Dict, List, Optional, Set, Tuple
+
+from .models import ATSScore, ATSComponentScore, JobAnalysis, JSONResume
+from .llm_router import LLMRouter, LLMRole
+from .prompts.template_manager import TemplateManager
+from .transform import convert_json_resume_to_text
+
+logger = logging.getLogger(__name__)
+
+ATS_REQUIRED_SECTIONS = {"basics", "work", "education", "skills"}
+ATS_OPTIONAL_SECTIONS = {"projects", "awards", "certificates", "volunteer"}
+
+ATS_UNFRIENDLY_PATTERNS = [
+    r"\\begin{table}",
+    r"\\begin{tabular}",
+    r"<table",
+    r"\\column",
+    r"\\begin{columns}",
+    r"\\multirow",
+    r"\\multicolumn",
+    r"<img ",
+    r"\\includegraphics",
+    r"\\tikz",
+    r"\\begin{tikzpicture}",
+    r"\\header",
+    r"\\fancyhead",
+    r"\\fancyfoot",
+    r"textbf{",
+    r"\\begin{figure}",
+]
+
+CHARS_PER_PAGE = 3800
+
+
+def _normalize_skill(skill: str) -> str:
+    return re.sub(r"[^a-z0-9]", "", skill.lower().strip())
+
+
+def _fuzzy_match_ratio(a: str, b: str) -> float:
+    try:
+        from rapidfuzz import fuzz
+        return fuzz.token_sort_ratio(a.lower(), b.lower()) / 100.0
+    except ImportError:
+        if a.lower() == b.lower():
+            return 1.0
+        if a.lower() in b.lower() or b.lower() in a.lower():
+            return 0.8
+        return 0.0
+
+
+class ATSScorer:
+    def __init__(self, router: LLMRouter, template_dir: str = "prompts/templates"):
+        self.router = router
+        self.template_manager = TemplateManager(template_dir)
+
+    def score(
+        self,
+        resume_data: JSONResume,
+        job_analysis: JobAnalysis,
+        resume_text: Optional[str] = None,
+    ) -> ATSScore:
+        if not resume_text:
+            resume_text = convert_json_resume_to_text(resume_data)
+        resume_lower = resume_text.lower()
+
+        keyword_score = self._score_keywords(resume_lower, job_analysis)
+        format_score = self._score_format(resume_text, resume_data)
+        completeness_score = self._score_completeness(resume_data)
+        skills_score = self._score_skills(resume_data, job_analysis)
+        relevance_score = self._score_relevance_ai(resume_text, job_analysis)
+
+        components = ATSComponentScore(
+            keyword_match=keyword_score["score"],
+            format_score=format_score,
+            section_completeness=completeness_score,
+            experience_relevance=relevance_score,
+            skills_match=skills_score["score"],
+        )
+
+        overall = (
+            keyword_score["score"] * 0.40
+            + format_score * 0.20
+            + completeness_score * 0.10
+            + relevance_score * 0.15
+            + skills_score["score"] * 0.15
+        )
+
+        suggestions = self._generate_suggestions(
+            keyword_score, format_score, completeness_score, skills_score, job_analysis
+        )
+
+        return ATSScore(
+            overall_score=round(overall, 1),
+            components=components,
+            suggestions=suggestions,
+            missing_keywords=keyword_score["missing"],
+            matched_keywords=keyword_score["matched"],
+        )
+
+    def _score_keywords(
+        self, resume_lower: str, job_analysis: JobAnalysis
+    ) -> Dict:
+        all_keywords = list(
+            set(job_analysis.keywords + job_analysis.required_skills + job_analysis.preferred_skills)
+        )
+        if not all_keywords:
+            return {"score": 75.0, "matched": [], "missing": []}
+
+        matched = []
+        missing = []
+
+        for kw in all_keywords:
+            kw_lower = kw.lower().strip()
+            kw_norm = _normalize_skill(kw)
+
+            found = False
+            # Guard against substring false matches (e.g., "Java" in "JavaScript")
+            # Use (?<!\w) and (?!\w) so "C++" still matches but "R" won't match "React"
+            if re.search(r'(?<!\w)' + re.escape(kw_lower) + r'(?!\w)', resume_lower):
+                found = True
+            elif kw_norm:
+                # Only fuzzy-match against individual words, not the full resume string
+                for word in resume_lower.split():
+                    if _fuzzy_match_ratio(kw_norm, _normalize_skill(word)) >= 0.85:
+                        found = True
+                        break
+
+            if found:
+                matched.append(kw)
+            else:
+                missing.append(kw)
+
+        score = (len(matched) / len(all_keywords)) * 100 if all_keywords else 0
+        return {"score": round(score, 1), "matched": matched, "missing": missing}
+
+    def _score_format(self, resume_text: str, resume_data: JSONResume) -> float:
+        score = 100.0
+
+        if resume_data.basics and resume_data.basics.profiles:
+            for p in resume_data.basics.profiles:
+                if p.url and "github.com" in p.url:
+                    score = min(score + 2, 100)
+                    break
+
+        if not resume_data.basics or not resume_data.basics.name:
+            score -= 5
+
+        if resume_data.basics and resume_data.basics.email and resume_data.basics.phone:
+            pass
+        else:
+            score -= 5
+
+        clean_text = convert_json_resume_to_text(resume_data)
+        char_count = len(clean_text)
+        estimated_pages = char_count / CHARS_PER_PAGE
+        if estimated_pages > 3:
+            score -= 15
+        elif estimated_pages > 2:
+            score -= 5
+
+        return max(0, round(score, 1))
+
+    def _score_completeness(self, resume_data: JSONResume) -> float:
+        score = 0.0
+        total_possible = 0.0
+
+        section_checks = {
+            "basics": lambda r: r.basics is not None and r.basics.name is not None,
+            "work": lambda r: r.work is not None and len(r.work) > 0,
+            "education": lambda r: r.education is not None and len(r.education) > 0,
+            "skills": lambda r: r.skills is not None and len(r.skills) > 0,
+            "projects": lambda r: r.projects is not None and len(r.projects) > 0,
+            "summary": lambda r: r.basics is not None and r.basics.summary is not None and len(r.basics.summary) > 20,
+        }
+
+        weights = {
+            "basics": 15,
+            "work": 25,
+            "education": 20,
+            "skills": 20,
+            "projects": 10,
+            "summary": 10,
+        }
+
+        for section, check_fn in section_checks.items():
+            weight = weights[section]
+            total_possible += weight
+            if check_fn(resume_data):
+                score += weight
+
+        return round((score / total_possible) * 100, 1) if total_possible > 0 else 0
+
+    def _score_skills(
+        self, resume_data: JSONResume, job_analysis: JobAnalysis
+    ) -> Dict:
+        if not resume_data.skills:
+            return {"score": 50.0, "matched": 0, "total": 0}
+
+        jd_skill_sources = list(
+            set(job_analysis.keywords + job_analysis.required_skills + job_analysis.preferred_skills)
+        )
+        if not jd_skill_sources:
+            return {"score": 75.0, "matched": 0, "total": 0}
+
+        resume_skills = set()
+        for skill_cat in resume_data.skills:
+            if skill_cat.keywords:
+                resume_skills.update(_normalize_skill(k) for k in skill_cat.keywords)
+            if skill_cat.name:
+                resume_skills.add(_normalize_skill(skill_cat.name))
+
+        jd_skills = set(_normalize_skill(k) for k in jd_skill_sources)
+
+        if not jd_skills:
+            return {"score": 75.0, "matched": 0, "total": 0}
+
+        matched = 0
+        for jsk in jd_skills:
+            if any(
+                _fuzzy_match_ratio(jsk, rsk) >= 0.8 for rsk in resume_skills
+            ):
+                matched += 1
+
+        score = (matched / len(jd_skills)) * 100
+        return {"score": round(score, 1), "matched": matched, "total": len(jd_skills)}
+
+    def _score_relevance_ai(
+        self, resume_text: str, job_analysis: JobAnalysis
+    ) -> float:
+        prompt = self.template_manager.render_template(
+            "ats_scoring",
+            resume_text=resume_text[:3000],
+            job_title=job_analysis.title,
+            job_responsibilities="\n".join(job_analysis.key_responsibilities[:5]),
+            required_skills=", ".join(job_analysis.required_skills[:10]),
+        )
+
+        if not prompt:
+            return 50.0
+
+        try:
+            result = self.router.call_json(
+                role=LLMRole.JUDGE,
+                messages=[
+                    {"role": "system", "content": "You are an ATS scoring system. Score resume relevance to the job. Return ONLY valid JSON."},
+                    {"role": "user", "content": prompt},
+                ],
+            )
+            if isinstance(result, dict) and "score" in result:
+                return float(max(0, min(100, result["score"])))
+        except Exception as e:
+            logger.warning(f"AI relevance scoring failed: {e}")
+
+        return 50.0
+
+    def _generate_suggestions(
+        self,
+        keyword_score: Dict,
+        format_score: float,
+        completeness_score: float,
+        skills_score: Dict,
+        job_analysis: JobAnalysis,
+    ) -> List[str]:
+        suggestions = []
+
+        if keyword_score["missing"]:
+            top_missing = keyword_score["missing"][:5]
+            suggestions.append(
+                f"The Skills section is missing keywords: {', '.join(top_missing)}. Do NOT add them to the work bullets."
+            )
+
+        if format_score < 80:
+            suggestions.append(
+                "Remove ATS-unfriendly formatting (tables, columns, images, headers/footers)"
+            )
+
+        if completeness_score < 70:
+            suggestions.append(
+                "Add missing resume sections (summary, projects, or skills)"
+            )
+
+        if skills_score["score"] < 50:
+            suggestions.append(
+                "Reorder skills section to prioritize JD-required skills"
+            )
+
+        if keyword_score["score"] < 60:
+            suggestions.append(
+                "Mirror JD language more closely - use the same terminology"
+            )
+
+        if job_analysis.required_skills and len(keyword_score["matched"]) < len(
+            job_analysis.required_skills
+        ):
+            missing_req = [
+                s for s in job_analysis.required_skills if s in keyword_score["missing"]
+            ]
+            if missing_req:
+                suggestions.append(
+                    f"The Skills section is missing required skills: {', '.join(missing_req[:3])}. Do NOT add them to the work bullets."
+                )
+
+        return suggestions

resumemakerats/cli.py

@@ -0,0 +1,346 @@
+import json
+import logging
+import os
+import sys
+import shutil
+from datetime import datetime
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    datefmt="%H:%M:%S",
+)
+logger = logging.getLogger(__name__)
+
+
+def print_separator(char: str = "=", length: int = 60):
+    print(char * length)
+
+
+def print_section(title: str):
+    print()
+    print_separator()
+    print(f"  {title}")
+    print_separator()
+
+
+def print_ats_score(score):
+    print_section("ATS SCORE")
+    print(f"  Overall Score: {score.overall_score}/100")
+    print()
+    print(f"  Keyword Match:        {score.components.keyword_match:.1f}%  (weight: 40%)")
+    print(f"  Format Score:         {score.components.format_score:.1f}%  (weight: 20%)")
+    print(f"  Section Completeness:  {score.components.section_completeness:.1f}%  (weight: 10%)")
+    print(f"  Experience Relevance: {score.components.experience_relevance:.1f}%  (weight: 15%)")
+    print(f"  Skills Match:         {score.components.skills_match:.1f}%  (weight: 15%)")
+
+    if score.matched_keywords:
+        print()
+        print(f"  Matched Keywords ({len(score.matched_keywords)}):")
+        for kw in score.matched_keywords[:15]:
+            print(f"    + {kw}")
+        if len(score.matched_keywords) > 15:
+            print(f"    ... and {len(score.matched_keywords) - 15} more")
+
+    if score.missing_keywords:
+        print()
+        print(f"  Missing Keywords ({len(score.missing_keywords)}):")
+        for kw in score.missing_keywords[:15]:
+            print(f"    - {kw}")
+        if len(score.missing_keywords) > 15:
+            print(f"    ... and {len(score.missing_keywords) - 15} more")
+
+    if score.suggestions:
+        print()
+        print("  Suggestions:")
+        for i, s in enumerate(score.suggestions, 1):
+            print(f"    {i}. {s}")
+
+
+def print_skills_gap(gap):
+    print_section("SKILLS GAP ANALYSIS")
+    print(f"  Coverage: {gap.coverage_percentage}%")
+    print(f"  Gap Score: {gap.gap_score}/100")
+
+    if gap.matching_skills:
+        print()
+        print(f"  Matching Skills ({len(gap.matching_skills)}):")
+        for s in gap.matching_skills[:15]:
+            print(f"    + {s}")
+
+    if gap.missing_skills:
+        print()
+        print(f"  Missing Skills ({len(gap.missing_skills)}):")
+        for s in gap.missing_skills[:15]:
+            print(f"    - {s}")
+
+    if gap.partial_matches:
+        print()
+        print(f"  Partial Matches ({len(gap.partial_matches)}):")
+        for pm in gap.partial_matches[:10]:
+            print(f"    ~ {pm.skill} ({pm.match_percentage}% match)")
+
+
+def print_tailored_result(result):
+    print_section("TAILORED RESUME RESULTS")
+
+    if result.ats_score:
+        print(f"  Final ATS Score: {result.ats_score.overall_score}/100")
+
+    print(f"  Regeneration Attempts: {result.regeneration_attempts}")
+    print(f"  Consolidation Attempts: {result.consolidation_attempts}")
+    print(f"  Improvement Attempts: {result.improvement_attempts}")
+
+    if result.changes_made:
+        print()
+        print(f"  Changes Made ({len(result.changes_made)}):")
+        for change in result.changes_made:
+            print(f"    * {change}")
+
+    if result.keyword_injections:
+        print()
+        print(f"  Keywords Injected ({len(result.keyword_injections)}):")
+        for kw in result.keyword_injections:
+            print(f"    + {kw}")
+
+    if result.fabricated_items:
+        print()
+        print(f"  Fabricated Items ({len(result.fabricated_items)}):")
+        for item in result.fabricated_items:
+            print(f"    [{item.item_type}] {item.reason}")
+
+    if result.truncated_items:
+        print()
+        print(f"  Truncated Items ({len(result.truncated_items)}):")
+        for item in result.truncated_items:
+            section = item.get("section", "unknown")
+            name = item.get("name", "")
+            print(f"    [{section}] {name}")
+
+
+def prompt_input(prompt_text: str, default: str = None) -> str:
+    if default:
+        full_prompt = f"{prompt_text} [{default}]: "
+    else:
+        full_prompt = f"{prompt_text}: "
+    try:
+        value = input(full_prompt).strip()
+    except (EOFError, KeyboardInterrupt):
+        print()
+        sys.exit(1)
+    if not value and default:
+        return default
+    return value
+
+
+def prompt_multiline(prompt_text: str) -> str:
+    print(f"{prompt_text} (enter an empty line to finish):")
+    lines = []
+    try:
+        while True:
+            line = input()
+            if line.strip() == "":
+                break
+            lines.append(line)
+    except (EOFError, KeyboardInterrupt):
+        print()
+    return "\n".join(lines)
+
+
+def get_resume_text(resume_path: str) -> tuple:
+    if not os.path.exists(resume_path):
+        print(f"  ERROR: File not found: {resume_path}")
+        return None, None
+    with open(resume_path, "rb") as f:
+        resume_bytes = f.read()
+    filename = os.path.basename(resume_path)
+    return resume_bytes, filename
+
+
+def get_jd_text(jd_input: str) -> str:
+    if os.path.exists(jd_input):
+        with open(jd_input, "r", encoding="utf-8") as f:
+            return f.read().strip()
+    return jd_input.strip()
+
+
+def main():
+    print_separator("*")
+    print("  ResumeMakerATS - AI Resume Tailoring")
+    print_separator("*")
+    print()
+
+    api_key = os.environ.get("INCEPTION_API_KEY", "")
+    if not api_key:
+        api_key = prompt_input("INCEPTION_API_KEY")
+    if not api_key:
+        print("\nERROR: INCEPTION_API_KEY is required.")
+        print("Set it in .env file, as environment variable, or enter it now.")
+        sys.exit(1)
+
+    print()
+
+    resume_path = prompt_input("Path to your resume PDF")
+    if not resume_path:
+        print("\nERROR: Resume path is required.")
+        sys.exit(1)
+
+    resume_bytes, resume_filename = get_resume_text(resume_path)
+    if resume_bytes is None:
+        sys.exit(1)
+
+    print()
+    jd_prompt = ("Path to job description file (or press Enter to paste text")
+    jd_input = prompt_input(jd_prompt)
+    jd_text = ""
+
+    if jd_input:
+        jd_text = get_jd_text(jd_input)
+    else:
+        print()
+        jd_text = prompt_multiline("Paste the job description text")
+
+    if not jd_text:
+        print("\nERROR: Job description is required.")
+        sys.exit(1)
+
+    print()
+    output_path = prompt_input("Output tailored resume as", default="resume_tailored.pdf")
+    output_path = output_path or "resume_tailored.pdf"
+
+    print()
+    print_separator("-")
+    print(f"  Resume: {resume_path}")
+    print(f"  JD:     {'<pasted text>' if not os.path.exists(jd_input) else jd_input}")
+    print(f"  Output: {output_path}")
+    print_separator("-")
+    print()
+
+    print("  Reading resume...")
+    from .resume_parser import extract_text_from_file, parse_resume_to_json
+
+    resume_text = extract_text_from_file(resume_bytes, resume_filename)
+    if not resume_text:
+        print("ERROR: Could not extract text from resume")
+        sys.exit(1)
+
+    from .llm_router import LLMRouter
+    router = LLMRouter(inception_api_key=api_key)
+    logger.info("LLM Router initialized")
+
+    template_dir = os.path.join(os.path.dirname(__file__), "prompts", "templates")
+    resume_text_truncated = resume_text[:8000]
+
+    from .resume_converter import ResumeConverter
+    resume_dict = ResumeConverter(router, template_dir=template_dir).convert(resume_text_truncated)
+
+    if not resume_dict or not resume_dict.get("basics", {}).get("name"):
+        logger.warning("AI parsing failed, falling back to rule-based parser")
+        resume_dict = parse_resume_to_json(resume_text)
+
+    from .models import JSONResume, GenerationConfig, FabricationConfig
+    try:
+        parsed = JSONResume(**resume_dict)
+    except Exception as e:
+        print(f"ERROR: Could not parse resume data: {e}")
+        sys.exit(1)
+
+    print(f"  Parsed resume for: {parsed.basics.name if parsed.basics else 'Unknown'}")
+    print()
+
+    if jd_input and os.path.exists(jd_input):
+        print(f"  Reading job description from file ({len(jd_text)} chars)...")
+    else:
+        print(f"  Using pasted job description ({len(jd_text)} chars)...")
+
+    from .jd_analyzer import JDAnalyzer
+
+    print()
+    print("  Analyzing job description...")
+    jd_analyzer = JDAnalyzer(router, template_dir=template_dir)
+    job_analysis = jd_analyzer.analyze(jd_text)
+
+    if not job_analysis:
+        print("ERROR: Failed to analyze job description")
+        sys.exit(1)
+
+    print(f"  Job Title: {job_analysis.title}")
+    print(f"  Required Skills: {', '.join(job_analysis.required_skills[:10])}")
+    print(f"  Keywords: {', '.join(job_analysis.keywords[:10])}")
+
+    print()
+    print("  Tailoring resume (this may take 1-3 minutes)...")
+    from .resume_tailor import ResumeTailor
+
+    config = GenerationConfig(
+        target_ats_score=92.0,
+        target_pages=1,
+        fabrication=FabricationConfig(
+            enabled=False,
+            aggressiveness=3,
+            max_fake_work_entries=0,
+            max_fake_projects=0,
+        ),
+    )
+
+    tailor = ResumeTailor(router=router, config=config, template_dir=template_dir)
+    result = tailor.tailor(parsed, jd_text, job_analysis=job_analysis)
+
+    print_tailored_result(result)
+
+    print()
+    print("  Generating ATS-friendly PDF...")
+
+    tailored_highlights = []
+    if result.resume_data and result.resume_data.work:
+        for job in result.resume_data.work:
+            if job.highlights:
+                tailored_highlights.extend(job.highlights)
+
+    pdf_bytes = None
+    if tailored_highlights:
+        try:
+            from .pdf_editor import replace_work_bullets
+            print(f"  Editing original PDF in-place ({len(tailored_highlights)} tailored bullets)...")
+            pdf_bytes = replace_work_bullets(resume_path, tailored_highlights, output_path)
+            print("  Format preserved from original resume!")
+        except Exception as e:
+            logger.warning(f"In-place PDF editing failed: {e}")
+            print(f"  In-place editing failed: {e}")
+            print("  Falling back to full render...")
+            pdf_bytes = None
+
+    if pdf_bytes is None:
+        from .renderer import render_pdf
+        pdf_bytes = render_pdf(result.resume_data, output_path=output_path)
+
+    print_section("OUTPUT")
+    print(f"  PDF saved: {output_path}")
+    print(f"  PDF size: {len(pdf_bytes):,} bytes")
+
+    if result.ats_score:
+        print()
+        print(f"  Final ATS Score:    {result.ats_score.overall_score}/100")
+        if result.ats_score.overall_score >= 85.0:
+            print("  Status:             On par with JD requirements")
+        else:
+            print("  Status:             Below target (target: 85)")
+
+    storage_dir = os.path.join(os.path.dirname(output_path) or ".", "storage")
+    os.makedirs(storage_dir, exist_ok=True)
+    storage_path = os.path.join(storage_dir, "resume_tailored.pdf")
+    shutil.copy(output_path, storage_path)
+    print(f"  Stored:             {storage_path}")
+
+    print()
+    print_separator("*")
+    print("  Done!")
+    print_separator("*")
+
+
+if __name__ == "__main__":
+    main()

resumemakerats/config.py

@@ -0,0 +1,6 @@
+"""
+Configuration settings for the hiring agent application.
+"""
+
+# Global development mode flag
+DEVELOPMENT_MODE = True