@pranavraut033/ats-checker 1.2.0 → 1.3.2

package/dist/{index.js → index.cjs}

@@ -185,27 +185,187 @@ function containsTableLikeStructure(text) {
 }
 
 // src/utils/skills.ts
+var aliasIndexCache = /* @__PURE__ */ new WeakMap();
+function getAliasIndex(aliases) {
+  let index = aliasIndexCache.get(aliases);
+  if (!index) {
+    index = /* @__PURE__ */ new Map();
+    for (const [canonical, aliasList] of Object.entries(aliases)) {
+      const lower = canonical.toLowerCase();
+      index.set(lower, lower);
+      for (const alias of aliasList) {
+        index.set(alias.toLowerCase(), lower);
+      }
+    }
+    aliasIndexCache.set(aliases, index);
+  }
+  return index;
+}
 function normalizeSkill(skill, aliases) {
   const normalized = skill.trim().toLowerCase();
-  for (const [canonical, aliasList] of Object.entries(aliases)) {
-    if (canonical.toLowerCase() === normalized) {
-      return canonical.toLowerCase();
+  return getAliasIndex(aliases).get(normalized) ?? normalized;
+}
+function normalizeSkills(skills, aliases) {
+  return unique(skills.map((skill) => normalizeSkill(skill, aliases)));
+}
+function deriveSkillAliases(registry) {
+  const aliases = {};
+  for (const entry of registry) {
+    aliases[entry.canonical] = entry.aliases;
+  }
+  return aliases;
+}
+function buildCategoryIndex(registry) {
+  const index = /* @__PURE__ */ new Map();
+  for (const entry of registry) {
+    index.set(entry.canonical.toLowerCase(), entry.category);
+  }
+  return index;
+}
+function mergeKeywordRegistries(base, overrides) {
+  const byCanonical = /* @__PURE__ */ new Map();
+  for (const entry of base) byCanonical.set(entry.canonical.toLowerCase(), entry);
+  for (const entry of overrides) byCanonical.set(entry.canonical.toLowerCase(), entry);
+  return [...byCanonical.values()];
+}
+
+// src/utils/languages.ts
+var KNOWN_LANGUAGES = [
+  "english",
+  "spanish",
+  "french",
+  "german",
+  "italian",
+  "portuguese",
+  "dutch",
+  "russian",
+  "mandarin",
+  "chinese",
+  "cantonese",
+  "japanese",
+  "korean",
+  "arabic",
+  "hindi",
+  "polish",
+  "turkish",
+  "vietnamese",
+  "swedish",
+  "norwegian",
+  "danish",
+  "finnish",
+  "greek",
+  "hebrew",
+  "thai",
+  "indonesian",
+  "ukrainian",
+  "czech"
+];
+var LANGUAGE_ALIASES = {
+  mandarin: "chinese",
+  cantonese: "chinese"
+};
+var LEVEL_RANK = {
+  a1: 1,
+  a2: 2,
+  b1: 3,
+  b2: 4,
+  c1: 5,
+  c2: 6,
+  basic: 1,
+  elementary: 1,
+  limited: 2,
+  conversational: 3,
+  intermediate: 3,
+  professional: 4,
+  "upper intermediate": 4,
+  advanced: 4,
+  fluent: 5,
+  native: 6,
+  "native speaker": 6,
+  bilingual: 6,
+  // German
+  grundkenntnisse: 1,
+  gering: 2,
+  gut: 3,
+  fortgeschritten: 4,
+  flie\u00DFend: 5,
+  muttersprache: 6,
+  muttersprachler: 6,
+  // French
+  "d\xE9butant": 1,
+  "\xE9l\xE9mentaire": 1,
+  "limit\xE9": 2,
+  "interm\xE9diaire": 3,
+  "avanc\xE9": 4,
+  courant: 5,
+  natif: 6,
+  "langue maternelle": 6,
+  bilingue: 6
+};
+var LANGUAGE_GROUP = KNOWN_LANGUAGES.join("|");
+var LEVEL_GROUP = Object.keys(LEVEL_RANK).sort((a, b) => b.length - a.length).map((l) => l.replace(/\s+/g, "\\s+")).join("|");
+var BOUNDARY_START = "(?:^|(?<=[^a-z\xE0-\xFF]))";
+var BOUNDARY_END = "(?:$|(?=[^a-z\xE0-\xFF]))";
+var LANGUAGE_LEVEL_RE = new RegExp(
+  `\\b(${LANGUAGE_GROUP})\\b(?:\\s*[\\(:\\-]?\\s*(${BOUNDARY_START}(?:${LEVEL_GROUP})${BOUNDARY_END}|[abc][12]))?`,
+  "gi"
+);
+var LEVEL_BEFORE_LANGUAGE_RE = new RegExp(
+  `${BOUNDARY_START}(${LEVEL_GROUP})${BOUNDARY_END}\\s+(?:in\\s+)?(${LANGUAGE_GROUP})\\b`,
+  "gi"
+);
+function canonicalLanguage(name) {
+  const lower = name.toLowerCase();
+  return LANGUAGE_ALIASES[lower] ?? lower;
+}
+function toParsedLanguage(name, level) {
+  const normalizedLevel = level?.toLowerCase().replace(/\s+/g, " ");
+  return {
+    name: canonicalLanguage(name),
+    level: normalizedLevel,
+    levelRank: normalizedLevel ? LEVEL_RANK[normalizedLevel] : void 0
+  };
+}
+function parseLanguageMentions(text) {
+  const found = /* @__PURE__ */ new Map();
+  for (const match of text.matchAll(LANGUAGE_LEVEL_RE)) {
+    const parsed = toParsedLanguage(match[1], match[2]);
+    const existing = found.get(parsed.name);
+    if (!existing || (parsed.levelRank ?? 0) > (existing.levelRank ?? 0)) {
+      found.set(parsed.name, parsed);
     }
-    if (aliasList.some((alias) => alias.toLowerCase() === normalized)) {
-      return canonical.toLowerCase();
+  }
+  for (const match of text.matchAll(LEVEL_BEFORE_LANGUAGE_RE)) {
+    const parsed = toParsedLanguage(match[2], match[1]);
+    const existing = found.get(parsed.name);
+    if (!existing || (parsed.levelRank ?? 0) > (existing.levelRank ?? 0)) {
+      found.set(parsed.name, parsed);
     }
   }
-  return normalized;
+  return [...found.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
-function normalizeSkills(skills, aliases) {
-  return unique(skills.map((skill) => normalizeSkill(skill, aliases)));
+function diffLanguages(resumeLanguages, requiredLanguages) {
+  const byName = new Map(resumeLanguages.map((l) => [l.name, l]));
+  const matched = [];
+  const missing = [];
+  for (const required of requiredLanguages) {
+    const have = byName.get(required.name);
+    const requiredRank = required.levelRank ?? 0;
+    const haveRank = have?.levelRank ?? 0;
+    if (have && haveRank >= requiredRank) {
+      matched.push(required);
+    } else {
+      missing.push(required);
+    }
+  }
+  return { matched, missing };
 }
 
 // src/core/parser/jd.parser.ts
 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"],
+  [/\b(?:bachelor(?:'s)?|b\.s\.?|bs\.?|bsc\.?|licence)\b/i, "bachelor"],
+  [/\b(?:master(?:'s)?|m\.s\.?|ms\.?|msc\.?|diplom)\b/i, "master"],
+  [/\b(?:phd|ph\.d\.?|doctorate|doktor|doctorat)\b/i, "phd"],
   [/\bmba\b/i, "mba"],
   [/\bassociate(?:'s)?\b/i, "associate"]
 ];
@@ -228,18 +388,38 @@ function extractPreferredSkills(lines) {
   return preferred;
 }
 function extractRoleKeywords(text) {
-  const roleMatch = text.match(/(engineer|developer|manager|scientist|analyst|designer|architect)/i);
-  const titleTokens = roleMatch ? roleMatch[0].split(/\s+/) : [];
-  return unique(tokenize(titleTokens.join(" ") || text.split(/\n/)[0] || ""));
+  const roleMatches = text.match(/(engineer|developer|manager|scientist|analyst|designer|architect|director|consultant|lead|vp)/gi) ?? [];
+  const fallback = roleMatches.length === 0 ? [text.split(/\n/)[0] ?? ""] : [];
+  return unique(tokenize([...roleMatches, ...fallback].join(" ")));
 }
 function extractMinExperience(text) {
-  const match = text.match(/(\d{1,2})\+?\s+(?:years|yrs)/i);
-  if (match) {
-    return Number.parseInt(match[1], 10);
+  const match = text.match(/(\d{1,2})\+?\s*(?:years?|yrs\.?|jahre?|ans?|années?)/i);
+  if (!match) return void 0;
+  const parsed = Number.parseInt(match[1], 10);
+  return parsed <= 60 ? parsed : void 0;
+}
+var SURFACE_TOKEN_RE = /[a-z0-9][a-z0-9.#+\-/]*[a-z0-9#+]/gi;
+function collectKeywordSurfaceForms(rawText, aliases) {
+  const matches = rawText.match(SURFACE_TOKEN_RE) ?? [];
+  const surfaceForms = {};
+  for (const match of matches) {
+    const canonical = normalizeSkill(match, aliases);
+    if (!(canonical in surfaceForms)) {
+      surfaceForms[canonical] = match;
+    }
   }
-  return void 0;
+  return surfaceForms;
+}
+var LANG_SECTION_RE = /^\s*(?:languages?|sprache|langue)s?\s*[:\-–—]?\s*/i;
+var LANG_REQUIREMENT_HINT_RE = /\b(fluent|required|must|need|speak|proficient|native|conversational|intermediate|advanced|professional|[abc][12])\b/i;
+function isLanguageRequired(lang, jobDescription) {
+  return splitLines(jobDescription).some((line) => {
+    const lower = line.toLowerCase();
+    if (!lower.includes(lang.name)) return false;
+    return LANG_SECTION_RE.test(line) || LANG_REQUIREMENT_HINT_RE.test(line);
+  });
 }
-function extractEducationRequirements(text) {
+function extractDegreeLevels(text) {
   const found = /* @__PURE__ */ new Set();
   for (const [pattern, canonical] of DEGREE_VARIANTS) {
     if (pattern.test(text)) found.add(canonical);
@@ -277,7 +457,13 @@ function parseJobDescription(jobDescription, config) {
     roleKeywords,
     keywords,
     minExperienceYears: extractMinExperience(jobDescription),
-    educationRequirements: extractEducationRequirements(jobDescription)
+    educationRequirements: extractDegreeLevels(jobDescription),
+    keywordSurfaceForms: collectKeywordSurfaceForms(jobDescription, config.skillAliases),
+    // A language only counts as required if its mention carries a requirement/level cue
+    // or sits in a "Languages:" line — plain references ("our Berlin office") don't count.
+    requiredLanguages: parseLanguageMentions(jobDescription).filter(
+      (lang) => isLanguageRequired(lang, jobDescription)
+    )
   };
 }
 
@@ -306,11 +492,37 @@ var MONTHS = {
   nov: 11,
   november: 11,
   dec: 12,
-  december: 12
+  december: 12,
+  // German
+  januar: 1,
+  j\u00E4nner: 1,
+  februar: 2,
+  m\u00E4rz: 3,
+  maerz: 3,
+  mai: 5,
+  juni: 6,
+  juli: 7,
+  oktober: 10,
+  dezember: 12,
+  // French
+  janvier: 1,
+  f\u00E9vrier: 2,
+  fevrier: 2,
+  mars: 3,
+  avril: 4,
+  juin: 6,
+  juillet: 7,
+  ao\u00FBt: 8,
+  aout: 8,
+  septembre: 9,
+  octobre: 10,
+  novembre: 11,
+  d\u00E9cembre: 12,
+  decembre: 12
 };
 function parseDateToken(raw) {
   const cleaned = raw.trim().toLowerCase();
-  const monthMatch = cleaned.match(/([a-z]{3,9})\s*(\d{4})/i);
+  const monthMatch = cleaned.match(/([a-zà-ÿ]{3,9})\s*(\d{4})/i);
   if (monthMatch) {
     const monthName = monthMatch[1].toLowerCase();
     const year = Number.parseInt(monthMatch[2], 10);
@@ -342,14 +554,14 @@ function monthsBetween(start, end) {
 function parseDateRange(text, referenceDate) {
   const normalized = text.trim();
   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
+    /(\d{1,2}\/\d{4}|[A-Za-zà-ÿ]{3,9}\s+\d{4}|\d{4})\s*(?:-|to|through|until|bis|jusqu'à|à|–|—)\s*(Present|Current|Now|Aktuell|Heute|Actuellement|Présent|\d{1,2}\/\d{4}|[A-Za-zà-ÿ]{3,9}\s+\d{4}|\d{4})/i
   );
   if (!rangeMatch) {
     return null;
   }
   const startToken = parseDateToken(rangeMatch[1]);
   const endRaw = rangeMatch[2];
-  const isPresent = /present|current|now/i.test(endRaw);
+  const isPresent = /present|current|now|aktuell|heute|actuellement|présent|actuel/i.test(endRaw);
   const endToken = isPresent ? void 0 : parseDateToken(endRaw);
   if (!startToken) {
     return null;
@@ -403,14 +615,23 @@ function sumExperienceYears(ranges) {
 
 // src/core/parser/resume.parser.ts
 var SECTION_ALIASES = {
-  summary: ["summary", "profile", "about"],
-  experience: ["experience", "work experience", "professional experience", "employment"],
-  skills: ["skills", "technical skills", "technologies"],
-  education: ["education", "academics", "academic background"],
-  projects: ["projects", "portfolio"],
-  certifications: ["certifications", "licenses"]
+  summary: ["summary", "profile", "about", "zusammenfassung", "profil", "r\xE9sum\xE9", "\xE0 propos"],
+  experience: [
+    "experience",
+    "work experience",
+    "professional experience",
+    "employment",
+    "erfahrung",
+    "berufserfahrung",
+    "exp\xE9rience",
+    "exp\xE9rience professionnelle"
+  ],
+  skills: ["skills", "technical skills", "technologies", "f\xE4higkeiten", "kenntnisse", "comp\xE9tences"],
+  education: ["education", "academics", "academic background", "ausbildung", "formation", "\xE9tudes"],
+  projects: ["projects", "portfolio", "projekte", "projets"],
+  certifications: ["certifications", "licenses", "zertifizierungen", "certifications professionnelles"]
 };
-var ACTION_VERBS = [
+var STRONG_VERBS = [
   "led",
   "managed",
   "built",
@@ -431,6 +652,21 @@ var ACTION_VERBS = [
   "reduced",
   "increased"
 ];
+var WEAK_VERBS = ["worked", "helped", "performed", "responsible", "assisted", "participated", "involved"];
+var METRIC_RE = /\d|%|\$|\bk\+|\bm\+/i;
+function classifyAchievement(line) {
+  const lower = line.toLowerCase();
+  const hasMetric = METRIC_RE.test(line);
+  const hasStrongVerb = STRONG_VERBS.some((verb) => new RegExp(`\\b${verb}\\b`).test(lower));
+  const hasWeakVerb = WEAK_VERBS.some((verb) => new RegExp(`\\b${verb}\\b`).test(lower));
+  if (hasStrongVerb && hasMetric) {
+    return { text: line, strength: "strong", reason: "strong verb + quantified impact" };
+  }
+  if (hasWeakVerb) {
+    return { text: line, strength: "weak", reason: "weak verb" };
+  }
+  return { text: line, strength: "weak", reason: "no quantified impact" };
+}
 function detectSection(line) {
   const normalized = line.trim().toLowerCase();
   for (const [section, aliases] of Object.entries(SECTION_ALIASES)) {
@@ -471,21 +707,27 @@ function extractSections(text) {
 }
 function parseSkills(sectionContent, aliases) {
   if (!sectionContent) return [];
-  const raw = sectionContent.split(/[,;\n]/).map((skill) => skill.trim()).filter(Boolean);
+  const hasBullets = /[•·‣▪○●◦]/.test(sectionContent);
+  const normalized = hasBullets ? sectionContent.replace(/\n/g, " ") : sectionContent;
+  const raw = normalized.split(/[,;\n]|[•·‣▪○●◦]/).map((skill) => skill.trim().replace(/^[-•·‣▪○●◦\s]+|[-•·‣▪○●◦\s]+$/g, "").trim()).filter(Boolean);
   return normalizeSkills(raw, aliases);
 }
 function parseActionVerbs(text) {
   const words = tokenize(text);
-  return ACTION_VERBS.filter((verb) => words.includes(verb));
+  return {
+    strong: STRONG_VERBS.filter((verb) => words.includes(verb)),
+    weak: WEAK_VERBS.filter((verb) => words.includes(verb))
+  };
 }
 function parseExperience(sectionContent, referenceDate) {
   if (!sectionContent) {
-    return { entries: [], rangesInMonths: [], jobTitles: [] };
+    return { entries: [], rangesInMonths: [], jobTitles: [], achievements: [] };
   }
   const lines = splitLines(sectionContent);
   const entries = [];
   const rangesInMonths = [];
   const jobTitles = [];
+  const achievements = [];
   for (const line of lines) {
     const range = parseDateRange(line, referenceDate);
     if (range) {
@@ -500,20 +742,22 @@ function parseExperience(sectionContent, referenceDate) {
       }
       continue;
     }
-    const titleMatch = line.match(/^(Senior|Lead|Principal|Staff|Software|Full\s*Stack|Frontend|Backend|Engineer|Developer|Manager|Analyst)[^,-]*/i);
+    const titleMatch = line.match(/^(Senior|Lead|Principal|Staff|VP|Director|Consultant|Architect|Software|Full\s*Stack|Frontend|Backend|Engineer|Developer|Manager|Analyst)[^,-]*/i);
     if (titleMatch) {
       const title = titleMatch[0].trim();
       jobTitles.push(title.toLowerCase());
       const entry = { title, description: line };
       entries.push(entry);
+      achievements.push(classifyAchievement(line));
       continue;
     }
     if (entries.length > 0) {
       const current = entries[entries.length - 1];
       current.description = [current.description, line].filter(Boolean).join(" ").trim();
     }
+    achievements.push(classifyAchievement(line));
   }
-  return { entries, rangesInMonths, jobTitles: unique(jobTitles) };
+  return { entries, rangesInMonths, jobTitles: unique(jobTitles), achievements };
 }
 function parseEducation(sectionContent) {
   if (!sectionContent) return [];
@@ -536,7 +780,8 @@ function parseResume(resumeText, config) {
     const textToScan = sections.summary ?? normalizedText;
     const yearsMatch = textToScan.match(/(\d{1,2})\+?\s*years?/i);
     if (yearsMatch) {
-      totalExperienceYears = Number.parseInt(yearsMatch[1], 10);
+      const parsed = Number.parseInt(yearsMatch[1], 10);
+      totalExperienceYears = parsed <= 60 ? parsed : 0;
     }
   }
   const requiredSections = ["summary", "experience", "skills", "education"];
@@ -563,11 +808,14 @@ function parseResume(resumeText, config) {
     sectionContent: sections,
     skills,
     jobTitles: experienceData.jobTitles,
-    actionVerbs,
+    actionVerbs: actionVerbs.strong,
+    weakVerbs: actionVerbs.weak,
+    achievements: experienceData.achievements,
     educationEntries,
     experience: experienceData.entries,
     totalExperienceYears,
     keywords: collectKeywords(normalizedText),
+    languages: parseLanguageMentions(resumeText),
     warnings
   };
 }
@@ -649,6 +897,14 @@ var REQUIRED_SKILL_WEIGHT = 0.7;
 var OPTIONAL_SKILL_WEIGHT = 0.3;
 var EXPERIENCE_YEARS_WEIGHT = 0.75;
 var EXPERIENCE_ROLE_WEIGHT = 0.25;
+var ALL_CATEGORIES = ["technical", "tool", "concept", "soft", "marketing", "domain"];
+function emptyCategoryBuckets() {
+  const buckets = {};
+  for (const category of ALL_CATEGORIES) {
+    buckets[category] = { matched: [], missing: [] };
+  }
+  return buckets;
+}
 function scoreSkills(resume, job, config) {
   const profileRequired = config.profile?.mandatorySkills ?? [];
   const profileOptional = config.profile?.optionalSkills ?? [];
@@ -687,42 +943,83 @@ function scoreExperience(resume, job, config) {
   const missingYears = Math.max(requiredYears - resume.totalExperienceYears, 0);
   return { score, missingYears: Number(missingYears.toFixed(2)) };
 }
+function keywordWeightOf(keyword, requiredSet, preferredSet, jdFrequencies) {
+  const base = requiredSet.has(keyword) ? 3 : preferredSet.has(keyword) ? 2 : 1;
+  const freqBonus = Math.min((jdFrequencies[keyword] ?? 1) - 1, 3) * 0.25;
+  return base + freqBonus;
+}
 function scoreKeywords(resume, job, config) {
   const jobKeywordSet = new Set(
     job.keywords.map((k) => normalizeSkill(k, config.skillAliases))
   );
   if (jobKeywordSet.size === 0) {
-    return { score: 100, matchedKeywords: [], missingKeywords: [], overusedKeywords: [] };
+    return {
+      score: 100,
+      matchedKeywords: [],
+      missingKeywords: [],
+      overusedKeywords: [],
+      keywordsByCategory: emptyCategoryBuckets(),
+      keywordWeights: []
+    };
   }
   const resumeTokens = tokenize(resume.normalizedText).map(
     (t) => normalizeSkill(t, config.skillAliases)
   );
   const resumeTokenSet = new Set(resumeTokens);
+  const resumeFrequencies = countFrequencies(resumeTokens);
+  const requiredSet = new Set(job.requiredSkills);
+  const preferredSet = new Set(job.preferredSkills);
+  const jdFrequencies = countFrequencies(
+    tokenize(job.normalizedText).map((t) => normalizeSkill(t, config.skillAliases))
+  );
+  const weightOf = (keyword) => keywordWeightOf(keyword, requiredSet, preferredSet, jdFrequencies);
   const matchedKeywords = [...jobKeywordSet].filter((keyword) => resumeTokenSet.has(keyword));
   const missingKeywords = [...jobKeywordSet].filter((keyword) => !resumeTokenSet.has(keyword));
-  const coverage = matchedKeywords.length / jobKeywordSet.size;
-  const score = clamp(coverage * 100, 0, 100);
-  const frequencies = countFrequencies(resumeTokens);
+  const totalWeight = [...jobKeywordSet].reduce((sum, keyword) => sum + weightOf(keyword), 0);
+  const matchedWeight = matchedKeywords.reduce((sum, keyword) => sum + weightOf(keyword), 0);
+  const score = clamp(matchedWeight / totalWeight * 100, 0, 100);
   const totalTokens = resumeTokens.length || 1;
   const overusedKeywords = matchedKeywords.filter((keyword) => {
-    const density = (frequencies[keyword] ?? 0) / totalTokens;
+    const density = (resumeFrequencies[keyword] ?? 0) / totalTokens;
     return density > config.keywordDensity.max;
   });
+  const keywordsByCategory = emptyCategoryBuckets();
+  for (const keyword of matchedKeywords) {
+    keywordsByCategory[config.categoryIndex.get(keyword) ?? "technical"].matched.push(keyword);
+  }
+  for (const keyword of missingKeywords) {
+    keywordsByCategory[config.categoryIndex.get(keyword) ?? "technical"].missing.push(keyword);
+  }
+  for (const bucket of Object.values(keywordsByCategory)) {
+    bucket.matched.sort();
+    bucket.missing.sort();
+  }
+  const keywordWeights = [...jobKeywordSet].map((term) => {
+    const weight = Number(weightOf(term).toFixed(2));
+    return {
+      term,
+      category: config.categoryIndex.get(term) ?? "technical",
+      jdWeight: weight,
+      resumeWeight: resumeFrequencies[term] ?? 0,
+      importance: weight
+    };
+  }).sort((a, b) => a.term.localeCompare(b.term));
   return {
     score,
     matchedKeywords: unique(matchedKeywords).sort(),
     missingKeywords: unique(missingKeywords).sort(),
-    overusedKeywords: unique(overusedKeywords).sort()
+    overusedKeywords: unique(overusedKeywords).sort(),
+    keywordsByCategory,
+    keywordWeights
   };
 }
 function scoreEducation(resume, job) {
   if (job.educationRequirements.length === 0) {
     return 100;
   }
-  const resumeEducationText = resume.educationEntries.join(" ");
-  const normalizedEducation = resumeEducationText.toLowerCase();
+  const resumeDegreeLevels = extractDegreeLevels(resume.educationEntries.join(" "));
   const matched = job.educationRequirements.filter(
-    (requirement) => normalizedEducation.includes(requirement.toLowerCase())
+    (requirement) => resumeDegreeLevels.includes(requirement)
   );
   if (matched.length === 0) {
     return 0;
@@ -741,6 +1038,14 @@ function calculateScore(resume, job, config) {
     education: educationScore
   };
   const weightedScore = breakdown.skills * config.weights.skills + breakdown.experience * config.weights.experience + breakdown.keywords * config.weights.keywords + breakdown.education * config.weights.education;
+  const achievementStrength = {
+    strong: resume.achievements.filter((a) => a.strength === "strong").length,
+    weak: resume.achievements.filter((a) => a.strength === "weak").length
+  };
+  const { matched: matchedLanguages, missing: missingLanguages } = diffLanguages(
+    resume.languages,
+    job.requiredLanguages
+  );
   return {
     score: clamp(Number(weightedScore.toFixed(2)), 0, 100),
     breakdown,
@@ -749,6 +1054,11 @@ function calculateScore(resume, job, config) {
     matchedKeywords: keywordResult.matchedKeywords,
     missingKeywords: keywordResult.missingKeywords,
     overusedKeywords: keywordResult.overusedKeywords,
+    keywordsByCategory: keywordResult.keywordsByCategory,
+    keywordWeights: keywordResult.keywordWeights,
+    achievementStrength,
+    matchedLanguages,
+    missingLanguages,
     suggestions: [],
     warnings: [],
     // detectedSections / parsedExperienceYears / experienceGap / experienceEntries: filled by index.ts
@@ -762,49 +1072,195 @@ function calculateScore(resume, job, config) {
 }
 
 // src/profiles/index.ts
-var defaultSkillAliases = {
+var defaultKeywordRegistry = [
+  // languages / frameworks
   // ponytail: "node" split from javascript — Node.js runtime !== JS language
-  javascript: ["js"],
-  node: ["node.js", "nodejs"],
-  typescript: ["ts"],
-  react: ["reactjs", "react.js"],
-  "c++": ["cpp"],
-  "c#": ["csharp"],
-  python: ["py"],
-  sql: ["postgres", "mysql", "sqlite"],
-  graphql: ["gql"],
-  aws: ["amazon web services"],
-  azure: ["microsoft azure"],
-  gcp: ["google cloud", "google cloud platform"],
-  docker: ["containers"],
-  kubernetes: ["k8s"],
-  html: ["html5"],
-  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: []
-};
+  { canonical: "javascript", aliases: ["js"], category: "technical" },
+  { canonical: "node", aliases: ["node.js", "nodejs"], category: "technical" },
+  { canonical: "typescript", aliases: ["ts"], category: "technical" },
+  { canonical: "react", aliases: ["reactjs", "react.js"], category: "technical" },
+  { canonical: "angular", aliases: ["angularjs"], category: "technical" },
+  { canonical: "vue", aliases: ["vue.js", "vuejs"], category: "technical" },
+  { canonical: "svelte", aliases: [], category: "technical" },
+  { canonical: "next.js", aliases: ["nextjs"], category: "technical" },
+  { canonical: "c++", aliases: ["cpp"], category: "technical" },
+  { canonical: "c#", aliases: ["csharp", ".net"], category: "technical" },
+  { canonical: "java", aliases: [], category: "technical" },
+  { canonical: "python", aliases: ["py"], category: "technical" },
+  { canonical: "go", aliases: ["golang"], category: "technical" },
+  { canonical: "rust", aliases: [], category: "technical" },
+  { canonical: "ruby", aliases: ["ruby on rails", "rails"], category: "technical" },
+  { canonical: "php", aliases: [], category: "technical" },
+  { canonical: "swift", aliases: [], category: "technical" },
+  { canonical: "kotlin", aliases: [], category: "technical" },
+  { canonical: "scala", aliases: [], category: "technical" },
+  { canonical: "html", aliases: ["html5"], category: "technical" },
+  { canonical: "css", aliases: ["css3"], category: "technical" },
+  { canonical: "ios development", aliases: ["ios"], category: "technical" },
+  { canonical: "android development", aliases: ["android"], category: "technical" },
+  { canonical: "react native", aliases: [], category: "technical" },
+  { canonical: "flutter", aliases: [], category: "technical" },
+  { canonical: "machine learning", aliases: ["ml"], category: "technical" },
+  { canonical: "deep learning", aliases: [], category: "technical" },
+  { canonical: "natural language processing", aliases: ["nlp"], category: "technical" },
+  // tools / platforms / infra
+  { canonical: "sql", aliases: ["postgres", "mysql", "sqlite"], category: "tool" },
+  { canonical: "graphql", aliases: ["gql"], category: "tool" },
+  { canonical: "aws", aliases: ["amazon web services"], category: "tool" },
+  { canonical: "azure", aliases: ["microsoft azure"], category: "tool" },
+  { canonical: "gcp", aliases: ["google cloud", "google cloud platform"], category: "tool" },
+  { canonical: "docker", aliases: ["containers"], category: "tool" },
+  { canonical: "kubernetes", aliases: ["k8s"], category: "tool" },
+  { canonical: "terraform", aliases: [], category: "tool" },
+  { canonical: "ansible", aliases: [], category: "tool" },
+  { canonical: "jenkins", aliases: [], category: "tool" },
+  { canonical: "git", aliases: ["github", "gitlab"], category: "tool" },
+  { canonical: "jira", aliases: [], category: "tool" },
+  { canonical: "confluence", aliases: [], category: "tool" },
+  { canonical: "pytorch", aliases: ["torch"], category: "tool" },
+  { canonical: "tensorflow", aliases: ["tf"], category: "tool" },
+  { canonical: "scikit-learn", aliases: ["sklearn"], category: "tool" },
+  { canonical: "pandas", aliases: [], category: "tool" },
+  { canonical: "numpy", aliases: [], category: "tool" },
+  { canonical: "fastapi", aliases: [], category: "tool" },
+  { canonical: "flask", aliases: [], category: "tool" },
+  { canonical: "django", aliases: [], category: "tool" },
+  { canonical: "kafka", aliases: [], category: "tool" },
+  { canonical: "redis", aliases: [], category: "tool" },
+  { canonical: "elasticsearch", aliases: ["elastic"], category: "tool" },
+  { canonical: "spark", aliases: ["apache spark"], category: "tool" },
+  { canonical: "tableau", aliases: [], category: "tool" },
+  { canonical: "power bi", aliases: ["powerbi"], category: "tool" },
+  { canonical: "excel", aliases: ["microsoft excel", "ms excel"], category: "tool" },
+  { canonical: "salesforce", aliases: [], category: "tool" },
+  { canonical: "hubspot", aliases: [], category: "tool" },
+  { canonical: "sap", aliases: [], category: "tool" },
+  { canonical: "quickbooks", aliases: [], category: "tool" },
+  { canonical: "workday", aliases: [], category: "tool" },
+  { canonical: "zendesk", aliases: [], category: "tool" },
+  { canonical: "servicenow", aliases: [], category: "tool" },
+  { canonical: "figma", aliases: [], category: "tool" },
+  { canonical: "photoshop", aliases: ["adobe photoshop"], category: "tool" },
+  { canonical: "illustrator", aliases: ["adobe illustrator"], category: "tool" },
+  { canonical: "autocad", aliases: [], category: "tool" },
+  // engineering concepts
+  { canonical: "accessibility", aliases: ["a11y"], category: "concept" },
+  { canonical: "frontend", aliases: ["front-end"], category: "concept" },
+  { canonical: "backend", aliases: ["back-end"], category: "concept" },
+  { canonical: "security", aliases: ["cybersecurity"], category: "concept" },
+  { canonical: "testing", aliases: ["unittest", "pytest"], category: "concept" },
+  { canonical: "microservices", aliases: [], category: "concept" },
+  { canonical: "agile", aliases: ["scrum"], category: "concept" },
+  { canonical: "kanban", aliases: [], category: "concept" },
+  { canonical: "blockchain", aliases: [], category: "concept" },
+  { canonical: "devops", aliases: [], category: "concept" },
+  { canonical: "ci/cd", aliases: ["continuous integration", "continuous deployment"], category: "concept" },
+  { canonical: "rest api", aliases: ["restful api", "rest apis"], category: "concept" },
+  { canonical: "design patterns", aliases: [], category: "concept" },
+  { canonical: "data structures", aliases: [], category: "concept" },
+  { canonical: "algorithms", aliases: [], category: "concept" },
+  { canonical: "cloud computing", aliases: [], category: "concept" },
+  { canonical: "system design", aliases: [], category: "concept" },
+  { canonical: "tdd", aliases: ["test driven development", "test-driven development"], category: "concept" },
+  { canonical: "ux design", aliases: ["user experience"], category: "concept" },
+  { canonical: "ui design", aliases: ["user interface design"], category: "concept" },
+  { canonical: "project management", aliases: [], category: "concept" },
+  { canonical: "change management", aliases: [], category: "concept" },
+  { canonical: "risk management", aliases: [], category: "concept" },
+  { canonical: "quality assurance", aliases: ["qa"], category: "concept" },
+  // product / data domain
+  { canonical: "roadmap", aliases: [], category: "domain" },
+  { canonical: "stakeholder management", aliases: [], category: "domain" },
+  { canonical: "prioritization", aliases: [], category: "domain" },
+  { canonical: "a/b testing", aliases: ["ab testing"], category: "domain" },
+  { canonical: "analytics", aliases: [], category: "domain" },
+  { canonical: "statistics", aliases: ["stats"], category: "domain" },
+  { canonical: "data visualization", aliases: [], category: "domain" },
+  // finance / accounting domain
+  { canonical: "financial analysis", aliases: [], category: "domain" },
+  { canonical: "budgeting", aliases: [], category: "domain" },
+  { canonical: "forecasting", aliases: [], category: "domain" },
+  { canonical: "bookkeeping", aliases: [], category: "domain" },
+  { canonical: "accounts payable", aliases: ["ap"], category: "domain" },
+  { canonical: "accounts receivable", aliases: ["ar"], category: "domain" },
+  { canonical: "payroll", aliases: [], category: "domain" },
+  { canonical: "auditing", aliases: ["audit"], category: "domain" },
+  { canonical: "tax preparation", aliases: [], category: "domain" },
+  { canonical: "gaap", aliases: [], category: "domain" },
+  // sales / account management domain
+  { canonical: "lead generation", aliases: [], category: "domain" },
+  { canonical: "account management", aliases: [], category: "domain" },
+  { canonical: "crm", aliases: ["customer relationship management"], category: "domain" },
+  { canonical: "sales pipeline", aliases: [], category: "domain" },
+  { canonical: "cold calling", aliases: [], category: "domain" },
+  { canonical: "upselling", aliases: ["cross-selling"], category: "domain" },
+  { canonical: "customer retention", aliases: [], category: "domain" },
+  // human resources domain
+  { canonical: "recruiting", aliases: ["talent acquisition"], category: "domain" },
+  { canonical: "onboarding", aliases: [], category: "domain" },
+  { canonical: "employee relations", aliases: [], category: "domain" },
+  { canonical: "benefits administration", aliases: [], category: "domain" },
+  { canonical: "performance management", aliases: [], category: "domain" },
+  // healthcare domain
+  { canonical: "patient care", aliases: [], category: "domain" },
+  { canonical: "clinical documentation", aliases: [], category: "domain" },
+  { canonical: "hipaa", aliases: [], category: "domain" },
+  { canonical: "electronic health records", aliases: ["ehr", "emr"], category: "domain" },
+  { canonical: "medical billing", aliases: [], category: "domain" },
+  // legal domain
+  { canonical: "contract review", aliases: [], category: "domain" },
+  { canonical: "legal research", aliases: [], category: "domain" },
+  { canonical: "litigation", aliases: [], category: "domain" },
+  { canonical: "regulatory compliance", aliases: ["compliance"], category: "domain" },
+  { canonical: "due diligence", aliases: [], category: "domain" },
+  // education domain
+  { canonical: "curriculum development", aliases: [], category: "domain" },
+  { canonical: "lesson planning", aliases: [], category: "domain" },
+  { canonical: "classroom management", aliases: [], category: "domain" },
+  { canonical: "instructional design", aliases: [], category: "domain" },
+  // operations / supply chain domain
+  { canonical: "supply chain management", aliases: ["supply chain"], category: "domain" },
+  { canonical: "inventory management", aliases: [], category: "domain" },
+  { canonical: "procurement", aliases: [], category: "domain" },
+  { canonical: "vendor management", aliases: [], category: "domain" },
+  { canonical: "logistics", aliases: [], category: "domain" },
+  // customer service domain
+  { canonical: "customer support", aliases: ["customer service"], category: "domain" },
+  { canonical: "technical support", aliases: [], category: "domain" },
+  { canonical: "conflict resolution", aliases: [], category: "domain" },
+  // soft skills
+  { canonical: "communication", aliases: [], category: "soft" },
+  { canonical: "leadership", aliases: [], category: "soft" },
+  { canonical: "teamwork", aliases: ["collaboration"], category: "soft" },
+  { canonical: "problem solving", aliases: ["problem-solving"], category: "soft" },
+  { canonical: "adaptability", aliases: ["flexibility"], category: "soft" },
+  { canonical: "time management", aliases: [], category: "soft" },
+  { canonical: "critical thinking", aliases: [], category: "soft" },
+  { canonical: "creativity", aliases: [], category: "soft" },
+  { canonical: "attention to detail", aliases: [], category: "soft" },
+  { canonical: "decision making", aliases: ["decision-making"], category: "soft" },
+  { canonical: "emotional intelligence", aliases: [], category: "soft" },
+  { canonical: "negotiation", aliases: [], category: "soft" },
+  { canonical: "organization", aliases: ["organizational skills"], category: "soft" },
+  { canonical: "public speaking", aliases: ["presentation skills"], category: "soft" },
+  { canonical: "mentoring", aliases: ["coaching"], category: "soft" },
+  { canonical: "interpersonal skills", aliases: [], category: "soft" },
+  { canonical: "work ethic", aliases: [], category: "soft" },
+  // marketing
+  { canonical: "seo", aliases: ["search engine optimization"], category: "marketing" },
+  { canonical: "branding", aliases: ["brand strategy"], category: "marketing" },
+  { canonical: "campaign management", aliases: [], category: "marketing" },
+  { canonical: "content marketing", aliases: [], category: "marketing" },
+  { canonical: "social media marketing", aliases: ["social media"], category: "marketing" },
+  { canonical: "email marketing", aliases: [], category: "marketing" },
+  { canonical: "digital marketing", aliases: [], category: "marketing" },
+  { canonical: "copywriting", aliases: [], category: "marketing" },
+  { canonical: "market research", aliases: [], category: "marketing" },
+  { canonical: "ppc", aliases: ["pay-per-click", "google ads"], category: "marketing" },
+  { canonical: "conversion rate optimization", aliases: ["cro"], category: "marketing" },
+  { canonical: "public relations", aliases: ["pr"], category: "marketing" }
+];
+var defaultSkillAliases = deriveSkillAliases(defaultKeywordRegistry);
 var softwareEngineerProfile = {
   name: "software-engineer",
   mandatorySkills: ["javascript", "typescript", "react", "node"],
@@ -874,9 +1330,12 @@ function resolveConfig(config = {}) {
     keywords: config.weights?.keywords ?? DEFAULT_WEIGHTS.keywords,
     education: config.weights?.education ?? DEFAULT_WEIGHTS.education
   };
+  const keywordRegistry = mergeKeywordRegistries(defaultKeywordRegistry, config.keywordRegistry ?? []);
   const resolved = {
     weights: normalizeWeights(weights),
-    skillAliases: { ...defaultSkillAliases, ...config.skillAliases ?? {} },
+    skillAliases: { ...deriveSkillAliases(keywordRegistry), ...config.skillAliases ?? {} },
+    keywordRegistry,
+    categoryIndex: buildCategoryIndex(keywordRegistry),
     profile: config.profile ?? softwareEngineerProfile,
     rules: config.rules ?? [],
     keywordDensity: config.keywordDensity ?? DEFAULT_KEYWORD_DENSITY,
@@ -896,6 +1355,18 @@ function formatList(values, max = 6) {
   const trimmed = uniqueValues.slice(0, max);
   return trimmed.join(", ") + (uniqueValues.length > max ? "..." : "");
 }
+function buildAliasReplacementSuggestions(resume, job, config) {
+  const jobKeywordSet = new Set(job.keywords.map((k) => normalizeSkill(k, config.skillAliases)));
+  const replacements = [];
+  for (const token of unique(tokenize(resume.normalizedText))) {
+    const canonical = normalizeSkill(token, config.skillAliases);
+    const jdSurface = job.keywordSurfaceForms[canonical];
+    if (jdSurface && jobKeywordSet.has(canonical) && jdSurface.toLowerCase() !== token.toLowerCase()) {
+      replacements.push(`Replace "${token}" with "${jdSurface}" to match the job description's wording.`);
+    }
+  }
+  return unique(replacements).slice(0, 5);
+}
 var SuggestionEngine = class {
   generate(input) {
     const suggestions = [];
@@ -910,6 +1381,7 @@ var SuggestionEngine = class {
         `Incorporate job-specific keywords: ${formatList(input.score.missingKeywords)}`
       );
     }
+    suggestions.push(...buildAliasReplacementSuggestions(input.resume, input.job, input.config));
     if (input.score.overusedKeywords.length > 0) {
       suggestions.push(
         `Avoid keyword stuffing for: ${formatList(input.score.overusedKeywords)}`
@@ -930,6 +1402,21 @@ var SuggestionEngine = class {
         "Strengthen bullet points with impact verbs (led, built, improved, delivered)."
       );
     }
+    if (input.resume.weakVerbs.length > 0) {
+      suggestions.push(
+        `Replace weak verbs (${formatList(input.resume.weakVerbs)}) with stronger ones (e.g. led, built, optimized).`
+      );
+    }
+    if (input.score.missingLanguages.length > 0) {
+      const formatted = input.score.missingLanguages.map((l) => l.level ? `${l.name} (${l.level})` : l.name).join(", ");
+      suggestions.push(`Mention your proficiency in: ${formatted}`);
+    }
+    const weakAchievement = input.resume.achievements.find((a) => a.strength === "weak");
+    if (weakAchievement) {
+      suggestions.push(
+        `Strengthen "${weakAchievement.text}" \u2014 add scope/metrics, e.g. "Built and maintained scalable services handling 500k+ requests/day."`
+      );
+    }
     if (input.resume.detectedSections.length < 2 && input.resume.raw.trim().length > 300) {
       suggestions.push(
         "Your resume may use a multi-column layout. Export as a single-column PDF or paste plain text \u2014 most ATS systems and this parser work best with a linear layout."
@@ -1572,7 +2059,8 @@ function analyzeResume(input) {
     resume: parsedResume,
     job: parsedJob,
     score: scoring,
-    ruleWarnings: ruleResult.warnings
+    ruleWarnings: ruleResult.warnings,
+    config: resolvedConfig
   });
   let suggestions = suggestionResult.suggestions;
   const llmWarnings = [];
@@ -1592,6 +2080,11 @@ function analyzeResume(input) {
     matchedKeywords: scoring.matchedKeywords,
     missingKeywords: scoring.missingKeywords,
     overusedKeywords: scoring.overusedKeywords,
+    keywordsByCategory: scoring.keywordsByCategory,
+    keywordWeights: scoring.keywordWeights,
+    achievementStrength: scoring.achievementStrength,
+    matchedLanguages: scoring.matchedLanguages,
+    missingLanguages: scoring.missingLanguages,
     experienceGap: scoring.experienceGap,
     detectedSections: parsedResume.detectedSections,
     parsedExperienceYears: parsedResume.totalExperienceYears,
@@ -1634,7 +2127,8 @@ async function analyzeResumeAsync(input) {
     resume: parsedResume,
     job: parsedJob,
     score: scoring,
-    ruleWarnings: ruleResult.warnings
+    ruleWarnings: ruleResult.warnings,
+    config: resolvedConfig
   });
   let suggestions = suggestionResult.suggestions;
   const llmWarnings = [];
@@ -1657,6 +2151,11 @@ async function analyzeResumeAsync(input) {
     matchedKeywords: scoring.matchedKeywords,
     missingKeywords: scoring.missingKeywords,
     overusedKeywords: scoring.overusedKeywords,
+    keywordsByCategory: scoring.keywordsByCategory,
+    keywordWeights: scoring.keywordWeights,
+    achievementStrength: scoring.achievementStrength,
+    matchedLanguages: scoring.matchedLanguages,
+    missingLanguages: scoring.missingLanguages,
     experienceGap: scoring.experienceGap,
     detectedSections: parsedResume.detectedSections,
     parsedExperienceYears: parsedResume.totalExperienceYears,
@@ -1712,10 +2211,11 @@ exports.adaptSuggestionEnhancementResponse = adaptSuggestionEnhancementResponse;
 exports.analyzeResume = analyzeResume;
 exports.analyzeResumeAsync = analyzeResumeAsync;
 exports.createPrompt = createPrompt;
+exports.defaultKeywordRegistry = defaultKeywordRegistry;
 exports.defaultProfiles = defaultProfiles;
 exports.defaultSkillAliases = defaultSkillAliases;
 exports.safeExtractArray = safeExtractArray;
 exports.safeExtractNumber = safeExtractNumber;
 exports.safeExtractString = safeExtractString;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map