@pranavraut033/ats-checker 1.2.0 → 1.3.0

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

@@ -185,20 +185,157 @@ 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
+};
+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 LANGUAGE_LEVEL_RE = new RegExp(
+  `\\b(${LANGUAGE_GROUP})\\b(?:\\s*[\\(:\\-]?\\s*(${LEVEL_GROUP}|[abc][12]))?`,
+  "gi"
+);
+var LEVEL_BEFORE_LANGUAGE_RE = new RegExp(`\\b(${LEVEL_GROUP})\\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
@@ -239,6 +376,18 @@ function extractMinExperience(text) {
   }
   return 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 surfaceForms;
+}
 function extractEducationRequirements(text) {
   const found = /* @__PURE__ */ new Set();
   for (const [pattern, canonical] of DEGREE_VARIANTS) {
@@ -277,7 +426,11 @@ function parseJobDescription(jobDescription, config) {
     roleKeywords,
     keywords,
     minExperienceYears: extractMinExperience(jobDescription),
-    educationRequirements: extractEducationRequirements(jobDescription)
+    educationRequirements: extractEducationRequirements(jobDescription),
+    keywordSurfaceForms: collectKeywordSurfaceForms(jobDescription, config.skillAliases),
+    // ponytail: any language mention in the JD is treated as a requirement — good enough until
+    // JDs that merely *reference* a language (not require it) show up as false positives.
+    requiredLanguages: parseLanguageMentions(jobDescription)
   };
 }
 
@@ -410,7 +563,7 @@ var SECTION_ALIASES = {
   projects: ["projects", "portfolio"],
   certifications: ["certifications", "licenses"]
 };
-var ACTION_VERBS = [
+var STRONG_VERBS = [
   "led",
   "managed",
   "built",
@@ -431,6 +584,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)) {
@@ -476,16 +644,20 @@ function parseSkills(sectionContent, 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) {
@@ -506,14 +678,16 @@ function parseExperience(sectionContent, referenceDate) {
       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 [];
@@ -563,11 +737,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 +826,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,32 +872,74 @@ 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) {
@@ -741,6 +968,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 +984,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 +1002,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 +1260,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 +1285,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 +1311,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 +1332,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 +1989,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 +2010,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 +2057,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 +2081,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 +2141,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