@pranavraut033/ats-checker 1.2.0 → 1.3.2

package/dist/index.mjs

@@ -1,209 +1,143 @@
-// src/utils/text.ts
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  // articles / prepositions / conjunctions
-  "the",
-  "and",
-  "or",
-  "a",
-  "an",
-  "of",
-  "for",
-  "to",
-  "with",
-  "in",
-  "on",
-  "at",
-  "by",
-  "from",
-  "as",
-  "into",
-  "onto",
-  "upon",
-  "via",
-  "per",
-  "plus",
-  // verbs / modals
-  "is",
-  "are",
-  "be",
-  "was",
-  "were",
-  "will",
-  "can",
-  "should",
-  "must",
-  "have",
-  "has",
-  "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).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) {
-  const normalized = normalizeForComparison(text);
-  return (normalized.match(TECH_TOKEN_RE) ?? []).filter(
-    (t) => /[a-z]/.test(t) && !STOP_WORDS.has(t)
-  );
+import { clamp, mergeKeywordRegistries, defaultKeywordRegistry, softwareEngineerProfile, buildCategoryIndex, deriveSkillAliases, normalizeWhitespace, splitLines, normalizeSkills, tokenize, unique, containsTableLikeStructure, normalizeForComparison, STOP_WORDS, normalizeSkill, countFrequencies, escapeRegExp } from './chunk-ZJ5E4H7Z.mjs';
+export { defaultKeywordRegistry, defaultProfiles, defaultSkillAliases } from './chunk-ZJ5E4H7Z.mjs';
+
+// 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 escapeRegExp(input) {
-  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+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 unique(values) {
-  const seen = /* @__PURE__ */ new Set();
-  const output = [];
-  for (const value of values) {
-    const lower = value.toLowerCase();
-    if (!seen.has(lower)) {
-      seen.add(lower);
-      output.push(value);
+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);
     }
   }
-  return output;
-}
-function clamp(value, min, max) {
-  return Math.min(Math.max(value, min), max);
-}
-function countFrequencies(values) {
-  const counts = {};
-  for (const value of values) {
-    counts[value] = (counts[value] ?? 0) + 1;
-  }
-  return counts;
-}
-function containsTableLikeStructure(text) {
-  const lines = splitLines(text);
-  let tableLines = 0;
-  for (const line of lines) {
-    const hasPipeColumns = line.includes("|") && line.split("|").length >= 3;
-    const hasTabColumns = /\t.+\t/.test(line);
-    const hasAlignedSpaces = /( {3,})(\S+)( {3,}\S+)/.test(line);
-    if (hasPipeColumns || hasTabColumns || hasAlignedSpaces) {
-      tableLines += 1;
+  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 tableLines >= 2;
+  return [...found.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
-
-// src/utils/skills.ts
-function normalizeSkill(skill, aliases) {
-  const normalized = skill.trim().toLowerCase();
-  for (const [canonical, aliasList] of Object.entries(aliases)) {
-    if (canonical.toLowerCase() === normalized) {
-      return canonical.toLowerCase();
-    }
-    if (aliasList.some((alias) => alias.toLowerCase() === normalized)) {
-      return canonical.toLowerCase();
+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 normalized;
-}
-function normalizeSkills(skills, aliases) {
-  return unique(skills.map((skill) => normalizeSkill(skill, aliases)));
+  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"]
 ];
@@ -226,18 +160,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;
 }
-function extractEducationRequirements(text) {
+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 extractDegreeLevels(text) {
   const found = /* @__PURE__ */ new Set();
   for (const [pattern, canonical] of DEGREE_VARIANTS) {
     if (pattern.test(text)) found.add(canonical);
@@ -275,7 +229,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)
+    )
   };
 }
 
@@ -304,11 +264,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);
@@ -340,14 +326,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;
@@ -401,14 +387,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",
@@ -429,6 +424,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)) {
@@ -469,21 +479,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) {
@@ -498,20 +514,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 [];
@@ -534,7 +552,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"];
@@ -561,11 +580,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
   };
 }
@@ -647,6 +669,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 ?? [];
@@ -685,42 +715,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;
@@ -739,6 +810,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,
@@ -747,6 +826,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
@@ -759,74 +843,6 @@ function calculateScore(resume, job, config) {
   };
 }
 
-// src/profiles/index.ts
-var defaultSkillAliases = {
-  // 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: []
-};
-var softwareEngineerProfile = {
-  name: "software-engineer",
-  mandatorySkills: ["javascript", "typescript", "react", "node"],
-  optionalSkills: ["graphql", "sql", "docker"],
-  minExperience: 3
-};
-var dataScientistProfile = {
-  name: "data-scientist",
-  mandatorySkills: ["python", "sql", "statistics"],
-  optionalSkills: ["pandas", "numpy", "pytorch", "tensorflow"],
-  minExperience: 2
-};
-var productManagerProfile = {
-  name: "product-manager",
-  mandatorySkills: ["roadmap", "stakeholder management", "prioritization"],
-  optionalSkills: ["a/b testing", "analytics", "sql"],
-  minExperience: 3
-};
-var defaultProfiles = [
-  softwareEngineerProfile,
-  dataScientistProfile,
-  productManagerProfile
-];
-
 // src/core/scoring/weights.ts
 var DEFAULT_WEIGHTS = {
   skills: 0.3,
@@ -872,9 +888,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,
@@ -894,6 +913,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 = [];
@@ -908,6 +939,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)}`
@@ -928,6 +960,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."
@@ -1570,7 +1617,8 @@ function analyzeResume(input) {
     resume: parsedResume,
     job: parsedJob,
     score: scoring,
-    ruleWarnings: ruleResult.warnings
+    ruleWarnings: ruleResult.warnings,
+    config: resolvedConfig
   });
   let suggestions = suggestionResult.suggestions;
   const llmWarnings = [];
@@ -1590,6 +1638,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,
@@ -1632,7 +1685,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 = [];
@@ -1655,6 +1709,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,
@@ -1699,6 +1758,6 @@ async function enhanceSuggestionsWithLLMAsync(config, suggestions) {
   }
 }
 
-export { LLMBudgetManager, LLMManager, LLMPrompts, LLMSchemas, adaptJdClarificationResponse, adaptSectionClassificationResponse, adaptSkillNormalizationResponse, adaptSuggestionEnhancementResponse, analyzeResume, analyzeResumeAsync, createPrompt, defaultProfiles, defaultSkillAliases, safeExtractArray, safeExtractNumber, safeExtractString };
+export { LLMBudgetManager, LLMManager, LLMPrompts, LLMSchemas, adaptJdClarificationResponse, adaptSectionClassificationResponse, adaptSkillNormalizationResponse, adaptSuggestionEnhancementResponse, analyzeResume, analyzeResumeAsync, createPrompt, safeExtractArray, safeExtractNumber, safeExtractString };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map