@pranavraut033/ats-checker 1.1.0 → 1.1.1

package/dist/index.mjs

@@ -1,5 +1,6 @@
 // src/utils/text.ts
 var STOP_WORDS = /* @__PURE__ */ new Set([
+  // articles / prepositions / conjunctions
   "the",
   "and",
   "or",
@@ -15,12 +16,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",
@@ -29,7 +34,98 @@ 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();
@@ -43,7 +139,12 @@ function splitLines(text) {
 var TECH_TOKEN_RE = /[a-z0-9][a-z0-9.#+\-/]*[a-z0-9#+]/g;
 function tokenize(text) {
   const normalized = normalizeForComparison(text);
-  return (normalized.match(TECH_TOKEN_RE) ?? []).filter((t) => !STOP_WORDS.has(t));
+  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 +200,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 +238,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 +317,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);
@@ -219,7 +339,9 @@ function monthsBetween(start, end) {
 }
 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;
   }
@@ -240,11 +362,40 @@ function parseDateRange(text, referenceDate) {
     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));
 }
 
@@ -278,9 +429,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)) {
@@ -379,9 +527,16 @@ function parseResume(resumeText, config) {
   const actionVerbs = parseActionVerbs(normalizedText);
   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) {
@@ -584,10 +739,11 @@ function calculateScore(resume, job, config) {
     overusedKeywords: keywordResult.overusedKeywords,
     suggestions: [],
     warnings: [],
-    // detectedSections / parsedExperienceYears / experienceGap: filled by index.ts
+    // detectedSections / parsedExperienceYears / experienceGap / experienceEntries: filled by index.ts
     experienceGap: experienceResult.missingYears,
     detectedSections: [],
     parsedExperienceYears: 0,
+    experienceEntries: [],
     missingExperienceYears: experienceResult.missingYears,
     educationScore
   };
@@ -611,7 +767,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",
@@ -1398,6 +1578,7 @@ function analyzeResume(input) {
     experienceGap: scoring.experienceGap,
     detectedSections: parsedResume.detectedSections,
     parsedExperienceYears: parsedResume.totalExperienceYears,
+    experienceEntries: parsedResume.experience,
     suggestions,
     warnings: [...suggestionResult.warnings, ...llmWarnings]
   };
@@ -1462,6 +1643,7 @@ async function analyzeResumeAsync(input) {
     experienceGap: scoring.experienceGap,
     detectedSections: parsedResume.detectedSections,
     parsedExperienceYears: parsedResume.totalExperienceYears,
+    experienceEntries: parsedResume.experience,
     suggestions,
     warnings: [...suggestionResult.warnings, ...llmWarnings]
   };