@pranavraut033/ats-checker 1.0.5 → 1.1.1

package/dist/index.js

@@ -2,6 +2,7 @@
 
 // src/utils/text.ts
 var STOP_WORDS = /* @__PURE__ */ new Set([
+  // articles / prepositions / conjunctions
   "the",
   "and",
   "or",
@@ -17,12 +18,16 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "by",
   "from",
   "as",
+  "into",
+  "onto",
+  "upon",
+  "via",
+  "per",
+  "plus",
+  // verbs / modals
   "is",
   "are",
   "be",
-  "this",
-  "that",
-  "it",
   "was",
   "were",
   "will",
@@ -31,19 +36,117 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "must",
   "have",
   "has",
-  "had"
+  "had",
+  "do",
+  "does",
+  "did",
+  "get",
+  "give",
+  "go",
+  "use",
+  "see",
+  "help",
+  "work",
+  "build",
+  "show",
+  "need",
+  "want",
+  "make",
+  "let",
+  // pronouns / determiners
+  "it",
+  "its",
+  "this",
+  "that",
+  "these",
+  "those",
+  "we",
+  "our",
+  "you",
+  "your",
+  "they",
+  "their",
+  "us",
+  "who",
+  "what",
+  "which",
+  "how",
+  // common English fillers that leak into JDs
+  "no",
+  "not",
+  "all",
+  "any",
+  "also",
+  "more",
+  "well",
+  "very",
+  "highly",
+  "across",
+  "over",
+  "under",
+  "within",
+  "about",
+  "out",
+  "up",
+  "down",
+  "new",
+  "if",
+  "so",
+  "such",
+  "both",
+  "each",
+  "one",
+  "many",
+  "only",
+  // JD/HR boilerplate — never skills
+  "years",
+  "year",
+  "experience",
+  "required",
+  "requirement",
+  "requirements",
+  "preferred",
+  "role",
+  "degree",
+  "practices",
+  "best",
+  "skills",
+  "team",
+  "field",
+  "related",
+  "relevant",
+  "desired",
+  "strong",
+  "solid",
+  "good",
+  "first",
+  "based",
+  "day",
+  "week",
+  "month",
+  "time",
+  "fast",
+  "open",
+  "dynamic"
 ]);
 function normalizeWhitespace(text) {
   return text.replace(/\r\n?/g, "\n").replace(/\s+/g, " ").trim();
 }
 function normalizeForComparison(text) {
-  return normalizeWhitespace(text).toLowerCase();
+  return normalizeWhitespace(text).normalize("NFKC").toLowerCase();
 }
 function splitLines(text) {
   return text.replace(/\r\n?/g, "\n").split("\n").map((line) => line.trim()).filter(Boolean);
 }
+var TECH_TOKEN_RE = /[a-z0-9][a-z0-9.#+\-/]*[a-z0-9#+]/g;
 function tokenize(text) {
-  return normalizeForComparison(text).split(/[^a-z0-9+]+/i).map((word) => word.trim()).filter((word) => word.length > 1 && !STOP_WORDS.has(word));
+  const normalized = normalizeForComparison(text);
+  return (normalized.match(TECH_TOKEN_RE) ?? []).filter(
+    (t) => /[a-z]/.test(t) && !STOP_WORDS.has(t)
+  );
+}
+function escapeRegExp(input) {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function unique(values) {
   const seen = /* @__PURE__ */ new Set();
@@ -99,37 +202,30 @@ function normalizeSkills(skills, aliases) {
 }
 
 // src/core/parser/jd.parser.ts
-var DEGREE_KEYWORDS = [
-  "bachelor",
-  "b.s",
-  "bs",
-  "bsc",
-  "master",
-  "m.s",
-  "ms",
-  "msc",
-  "phd",
-  "doctorate",
-  "mba",
-  "associate"
+var DEGREE_VARIANTS = [
+  [/\b(?:bachelor(?:'s)?|b\.s\.?|bs\.?|bsc\.?)\b/i, "bachelor"],
+  [/\b(?:master(?:'s)?|m\.s\.?|ms\.?|msc\.?)\b/i, "master"],
+  [/\b(?:phd|ph\.d\.?|doctorate)\b/i, "phd"],
+  [/\bmba\b/i, "mba"],
+  [/\bassociate(?:'s)?\b/i, "associate"]
 ];
 function extractRequiredSkills(lines) {
   const required = [];
   for (const line of lines) {
     if (/must|require|required|need/i.test(line)) {
-      required.push(...line.split(/[,.;•-]/));
+      required.push(...tokenize(line));
     }
   }
-  return required.map((value) => value.trim()).filter(Boolean);
+  return required;
 }
 function extractPreferredSkills(lines) {
   const preferred = [];
   for (const line of lines) {
     if (/preferred|nice to have|plus/i.test(line)) {
-      preferred.push(...line.split(/[,.;•-]/));
+      preferred.push(...tokenize(line));
     }
   }
-  return preferred.map((value) => value.trim()).filter(Boolean);
+  return preferred;
 }
 function extractRoleKeywords(text) {
   const roleMatch = text.match(/(engineer|developer|manager|scientist|analyst|designer|architect)/i);
@@ -144,23 +240,41 @@ function extractMinExperience(text) {
   return void 0;
 }
 function extractEducationRequirements(text) {
-  const normalized = normalizeForComparison(text);
-  return DEGREE_KEYWORDS.filter((degree) => normalized.includes(degree));
+  const found = /* @__PURE__ */ new Set();
+  for (const [pattern, canonical] of DEGREE_VARIANTS) {
+    if (pattern.test(text)) found.add(canonical);
+  }
+  return [...found];
 }
 function parseJobDescription(jobDescription, config) {
   const normalizedText = normalizeWhitespace(jobDescription);
   const lines = splitLines(jobDescription);
-  const requiredSkillsRaw = extractRequiredSkills(lines);
-  const preferredSkillsRaw = extractPreferredSkills(lines);
+  const skillVocab = /* @__PURE__ */ new Set();
+  for (const [canonical, aliases] of Object.entries(config.skillAliases)) {
+    skillVocab.add(canonical.toLowerCase());
+    for (const alias of aliases) skillVocab.add(alias.toLowerCase());
+  }
+  for (const s of config.profile?.mandatorySkills ?? []) skillVocab.add(s.toLowerCase());
+  for (const s of config.profile?.optionalSkills ?? []) skillVocab.add(s.toLowerCase());
+  const isSkillLike = (t) => {
+    if (skillVocab.has(t)) return true;
+    if (/[.#+]/.test(t) && /[a-z]/.test(t)) return true;
+    if (t.includes("/")) return t.split("/").some((p) => p.length >= 2 && !STOP_WORDS.has(p));
+    return false;
+  };
+  const requiredSkillsRaw = extractRequiredSkills(lines).filter(isSkillLike);
+  const preferredSkillsRaw = extractPreferredSkills(lines).filter(isSkillLike);
   const requiredSkills = normalizeSkills(requiredSkillsRaw, config.skillAliases);
   const preferredSkills = normalizeSkills(preferredSkillsRaw, config.skillAliases);
-  const keywords = unique([...requiredSkills, ...preferredSkills, ...tokenize(normalizedText)]);
+  const bodyTokens = tokenize(normalizedText).filter(isSkillLike);
+  const roleKeywords = extractRoleKeywords(jobDescription);
+  const keywords = unique([...requiredSkills, ...preferredSkills, ...roleKeywords, ...bodyTokens]);
   return {
     raw: jobDescription,
     normalizedText,
     requiredSkills,
     preferredSkills,
-    roleKeywords: extractRoleKeywords(jobDescription),
+    roleKeywords,
     keywords,
     minExperienceYears: extractMinExperience(jobDescription),
     educationRequirements: extractEducationRequirements(jobDescription)
@@ -205,6 +319,14 @@ function parseDateToken(raw) {
       return { year, month };
     }
   }
+  const slashMatch = cleaned.match(/^(\d{1,2})\/(\d{4})$/);
+  if (slashMatch) {
+    const month = Number.parseInt(slashMatch[1], 10);
+    const year = Number.parseInt(slashMatch[2], 10);
+    if (month >= 1 && month <= 12 && !Number.isNaN(year)) {
+      return { year, month };
+    }
+  }
   const yearMatch = cleaned.match(/(20\d{2}|19\d{2})/);
   if (yearMatch) {
     const year = Number.parseInt(yearMatch[1], 10);
@@ -217,9 +339,11 @@ function monthsBetween(start, end) {
   const endMonth = end.month ?? 12;
   return (end.year - start.year) * 12 + (endMonth - startMonth + 1);
 }
-function parseDateRange(text) {
+function parseDateRange(text, referenceDate) {
   const normalized = text.trim();
-  const rangeMatch = normalized.match(/([A-Za-z]{3,9}\s+\d{4}|\d{4})\s*(?:-|to|–|—)\s*(Present|Current|Now|[A-Za-z]{3,9}\s+\d{4}|\d{4})/i);
+  const rangeMatch = normalized.match(
+    /(\d{1,2}\/\d{4}|[A-Za-z]{3,9}\s+\d{4}|\d{4})\s*(?:-|to|–|—)\s*(Present|Current|Now|\d{1,2}\/\d{4}|[A-Za-z]{3,9}\s+\d{4}|\d{4})/i
+  );
   if (!rangeMatch) {
     return null;
   }
@@ -230,20 +354,50 @@ function parseDateRange(text) {
   if (!startToken) {
     return null;
   }
+  const ref = referenceDate ?? /* @__PURE__ */ new Date();
   const endTokenResolved = endToken ?? {
-    year: (/* @__PURE__ */ new Date()).getFullYear(),
-    month: (/* @__PURE__ */ new Date()).getMonth() + 1
+    year: ref.getFullYear(),
+    month: ref.getMonth() + 1
   };
   const durationInMonths = monthsBetween(startToken, endTokenResolved);
   return {
     raw: normalized,
     start: rangeMatch[1],
     end: isPresent ? "present" : rangeMatch[2],
-    durationInMonths: durationInMonths > 0 ? durationInMonths : void 0
+    durationInMonths: durationInMonths > 0 ? durationInMonths : void 0,
+    startYear: startToken.year,
+    startMonth: startToken.month,
+    endYear: endTokenResolved.year,
+    endMonth: endTokenResolved.month
   };
 }
 function sumExperienceYears(ranges) {
-  const months = ranges.map((range) => range.durationInMonths ?? 0).reduce((total, value) => total + value, 0);
+  const withBounds = ranges.filter(
+    (r) => r.startYear !== void 0 && r.endYear !== void 0
+  );
+  if (withBounds.length === ranges.length && ranges.length > 0) {
+    const toIndex = (year, month) => year * 12 + month;
+    const intervals = withBounds.map((r) => ({
+      s: toIndex(r.startYear, r.startMonth ?? 1),
+      e: toIndex(r.endYear, r.endMonth ?? 12)
+    })).sort((a, b) => a.s - b.s);
+    let totalMonths = 0;
+    let curStart = intervals[0].s;
+    let curEnd = intervals[0].e;
+    for (let i = 1; i < intervals.length; i++) {
+      const { s, e } = intervals[i];
+      if (s <= curEnd) {
+        curEnd = Math.max(curEnd, e);
+      } else {
+        totalMonths += curEnd - curStart + 1;
+        curStart = s;
+        curEnd = e;
+      }
+    }
+    totalMonths += curEnd - curStart + 1;
+    return Number((totalMonths / 12).toFixed(2));
+  }
+  const months = ranges.reduce((total, r) => total + (r.durationInMonths ?? 0), 0);
   return Number((months / 12).toFixed(2));
 }
 
@@ -277,9 +431,6 @@ var ACTION_VERBS = [
   "reduced",
   "increased"
 ];
-function escapeRegExp(input) {
-  return input.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
-}
 function detectSection(line) {
   const normalized = line.trim().toLowerCase();
   for (const [section, aliases] of Object.entries(SECTION_ALIASES)) {
@@ -327,7 +478,7 @@ function parseActionVerbs(text) {
   const words = tokenize(text);
   return ACTION_VERBS.filter((verb) => words.includes(verb));
 }
-function parseExperience(sectionContent) {
+function parseExperience(sectionContent, referenceDate) {
   if (!sectionContent) {
     return { entries: [], rangesInMonths: [], jobTitles: [] };
   }
@@ -336,7 +487,7 @@ function parseExperience(sectionContent) {
   const rangesInMonths = [];
   const jobTitles = [];
   for (const line of lines) {
-    const range = parseDateRange(line);
+    const range = parseDateRange(line, referenceDate);
     if (range) {
       const previous = entries[entries.length - 1];
       if (previous && !previous.dates) {
@@ -376,11 +527,18 @@ function parseResume(resumeText, config) {
   const { sections, detected } = extractSections(resumeText);
   const skills = parseSkills(sections.skills, config.skillAliases);
   const actionVerbs = parseActionVerbs(normalizedText);
-  const experienceData = parseExperience(sections.experience);
+  const experienceData = parseExperience(sections.experience, config.referenceDate);
   const educationEntries = parseEducation(sections.education);
-  const totalExperienceYears = sumExperienceYears(
+  let totalExperienceYears = sumExperienceYears(
     experienceData.entries.map((entry) => entry.dates).filter((range) => Boolean(range))
   );
+  if (totalExperienceYears === 0) {
+    const textToScan = sections.summary ?? normalizedText;
+    const yearsMatch = textToScan.match(/(\d{1,2})\+?\s*years?/i);
+    if (yearsMatch) {
+      totalExperienceYears = Number.parseInt(yearsMatch[1], 10);
+    }
+  }
   const requiredSections = ["summary", "experience", "skills", "education"];
   const warnings = [];
   for (const section of requiredSections) {
@@ -500,8 +658,9 @@ function scoreSkills(resume, job, config) {
     0,
     100
   );
-  const missing = [...required].filter((skill) => !resumeSkills.has(skill));
-  return { score, missing };
+  const matched = [...required].filter((skill) => resumeSkills.has(skill)).sort();
+  const missing = [...required].filter((skill) => !resumeSkills.has(skill)).sort();
+  return { score, matched, missing };
 }
 function scoreExperience(resume, job, config) {
   const requiredYears = job.minExperienceYears ?? config.profile?.minExperience ?? 0;
@@ -519,11 +678,15 @@ function scoreExperience(resume, job, config) {
   return { score, missingYears: Number(missingYears.toFixed(2)) };
 }
 function scoreKeywords(resume, job, config) {
-  const jobKeywordSet = new Set(job.keywords.map((value) => value.toLowerCase()));
+  const jobKeywordSet = new Set(
+    job.keywords.map((k) => normalizeSkill(k, config.skillAliases))
+  );
   if (jobKeywordSet.size === 0) {
     return { score: 100, matchedKeywords: [], missingKeywords: [], overusedKeywords: [] };
   }
-  const resumeTokens = tokenize(resume.normalizedText);
+  const resumeTokens = tokenize(resume.normalizedText).map(
+    (t) => normalizeSkill(t, config.skillAliases)
+  );
   const resumeTokenSet = new Set(resumeTokens);
   const matchedKeywords = [...jobKeywordSet].filter((keyword) => resumeTokenSet.has(keyword));
   const missingKeywords = [...jobKeywordSet].filter((keyword) => !resumeTokenSet.has(keyword));
@@ -537,9 +700,9 @@ function scoreKeywords(resume, job, config) {
   });
   return {
     score,
-    matchedKeywords: unique(matchedKeywords),
-    missingKeywords: unique(missingKeywords),
-    overusedKeywords: unique(overusedKeywords)
+    matchedKeywords: unique(matchedKeywords).sort(),
+    missingKeywords: unique(missingKeywords).sort(),
+    overusedKeywords: unique(overusedKeywords).sort()
   };
 }
 function scoreEducation(resume, job) {
@@ -571,12 +734,18 @@ function calculateScore(resume, job, config) {
   return {
     score: clamp(Number(weightedScore.toFixed(2)), 0, 100),
     breakdown,
+    matchedSkills: skillsResult.matched,
+    missingSkills: skillsResult.missing,
     matchedKeywords: keywordResult.matchedKeywords,
     missingKeywords: keywordResult.missingKeywords,
     overusedKeywords: keywordResult.overusedKeywords,
     suggestions: [],
     warnings: [],
-    missingSkills: skillsResult.missing,
+    // detectedSections / parsedExperienceYears / experienceGap / experienceEntries: filled by index.ts
+    experienceGap: experienceResult.missingYears,
+    detectedSections: [],
+    parsedExperienceYears: 0,
+    experienceEntries: [],
     missingExperienceYears: experienceResult.missingYears,
     educationScore
   };
@@ -584,7 +753,9 @@ function calculateScore(resume, job, config) {
 
 // src/profiles/index.ts
 var defaultSkillAliases = {
-  javascript: ["js", "node", "node.js", "nodejs"],
+  // ponytail: "node" split from javascript — Node.js runtime !== JS language
+  javascript: ["js"],
+  node: ["node.js", "nodejs"],
   typescript: ["ts"],
   react: ["reactjs", "react.js"],
   "c++": ["cpp"],
@@ -598,7 +769,31 @@ var defaultSkillAliases = {
   docker: ["containers"],
   kubernetes: ["k8s"],
   html: ["html5"],
-  css: ["css3"]
+  css: ["css3"],
+  // ML / data science
+  pytorch: ["torch"],
+  tensorflow: ["tf"],
+  "scikit-learn": ["sklearn"],
+  pandas: [],
+  numpy: [],
+  fastapi: [],
+  flask: [],
+  django: [],
+  // data / infra
+  kafka: [],
+  redis: [],
+  elasticsearch: ["elastic"],
+  spark: ["apache spark"],
+  // common pure-letter tech skills (no symbol chars)
+  accessibility: ["a11y"],
+  frontend: ["front-end"],
+  backend: ["back-end"],
+  security: ["cybersecurity"],
+  testing: ["unittest", "pytest"],
+  microservices: [],
+  agile: ["scrum"],
+  blockchain: [],
+  devops: []
 };
 var softwareEngineerProfile = {
   name: "software-engineer",
@@ -679,7 +874,8 @@ function resolveConfig(config = {}) {
       ...DEFAULT_SECTION_PENALTIES,
       ...config.sectionPenalties ?? {}
     },
-    allowPartialMatches: config.allowPartialMatches ?? true
+    allowPartialMatches: config.allowPartialMatches ?? true,
+    referenceDate: config.referenceDate ? new Date(config.referenceDate) : void 0
   };
   return resolved;
 }
@@ -1376,9 +1572,15 @@ function analyzeResume(input) {
   return {
     score: finalScore,
     breakdown: scoring.breakdown,
+    matchedSkills: scoring.matchedSkills,
+    missingSkills: scoring.missingSkills,
     matchedKeywords: scoring.matchedKeywords,
     missingKeywords: scoring.missingKeywords,
     overusedKeywords: scoring.overusedKeywords,
+    experienceGap: scoring.experienceGap,
+    detectedSections: parsedResume.detectedSections,
+    parsedExperienceYears: parsedResume.totalExperienceYears,
+    experienceEntries: parsedResume.experience,
     suggestions,
     warnings: [...suggestionResult.warnings, ...llmWarnings]
   };
@@ -1435,9 +1637,15 @@ async function analyzeResumeAsync(input) {
   return {
     score: finalScore,
     breakdown: scoring.breakdown,
+    matchedSkills: scoring.matchedSkills,
+    missingSkills: scoring.missingSkills,
     matchedKeywords: scoring.matchedKeywords,
     missingKeywords: scoring.missingKeywords,
     overusedKeywords: scoring.overusedKeywords,
+    experienceGap: scoring.experienceGap,
+    detectedSections: parsedResume.detectedSections,
+    parsedExperienceYears: parsedResume.totalExperienceYears,
+    experienceEntries: parsedResume.experience,
     suggestions,
     warnings: [...suggestionResult.warnings, ...llmWarnings]
   };