@pranavraut033/ats-checker 1.2.0 → 1.3.0

package/dist/index.mjs

@@ -1,202 +1,113 @@
-// 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
+};
+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 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
@@ -237,6 +148,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) {
@@ -275,7 +198,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)
   };
 }
 
@@ -408,7 +335,7 @@ var SECTION_ALIASES = {
   projects: ["projects", "portfolio"],
   certifications: ["certifications", "licenses"]
 };
-var ACTION_VERBS = [
+var STRONG_VERBS = [
   "led",
   "managed",
   "built",
@@ -429,6 +356,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)) {
@@ -474,16 +416,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) {
@@ -504,14 +450,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 [];
@@ -561,11 +509,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 +598,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,32 +644,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) {
@@ -739,6 +740,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 +756,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 +773,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 +818,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 +843,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 +869,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 +890,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 +1547,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 +1568,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 +1615,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 +1639,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 +1688,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