@pranavraut033/ats-checker 0.1.0

package/dist/index.js

@@ -0,0 +1,757 @@
+'use strict';
+
+// src/utils/text.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "or",
+  "a",
+  "an",
+  "of",
+  "for",
+  "to",
+  "with",
+  "in",
+  "on",
+  "at",
+  "by",
+  "from",
+  "as",
+  "is",
+  "are",
+  "be",
+  "this",
+  "that",
+  "it",
+  "was",
+  "were",
+  "will",
+  "can",
+  "should",
+  "must",
+  "have",
+  "has",
+  "had"
+]);
+function normalizeWhitespace(text) {
+  return text.replace(/\r\n?/g, "\n").replace(/\s+/g, " ").trim();
+}
+function normalizeForComparison(text) {
+  return normalizeWhitespace(text).toLowerCase();
+}
+function splitLines(text) {
+  return text.replace(/\r\n?/g, "\n").split("\n").map((line) => line.trim()).filter(Boolean);
+}
+function tokenize(text) {
+  return normalizeForComparison(text).split(/[^a-z0-9+]+/i).map((word) => word.trim()).filter((word) => word.length > 1 && !STOP_WORDS.has(word));
+}
+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);
+    }
+  }
+  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;
+    }
+  }
+  return tableLines >= 2;
+}
+
+// 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();
+    }
+  }
+  return normalized;
+}
+function normalizeSkills(skills, aliases) {
+  return unique(skills.map((skill) => normalizeSkill(skill, aliases)));
+}
+
+// src/core/parser/jd.parser.ts
+var DEGREE_KEYWORDS = [
+  "bachelor",
+  "b.s",
+  "bs",
+  "bsc",
+  "master",
+  "m.s",
+  "ms",
+  "msc",
+  "phd",
+  "doctorate",
+  "mba",
+  "associate"
+];
+function extractRequiredSkills(lines) {
+  const required = [];
+  for (const line of lines) {
+    if (/must|require|required|need/i.test(line)) {
+      required.push(...line.split(/[,.;•-]/));
+    }
+  }
+  return required.map((value) => value.trim()).filter(Boolean);
+}
+function extractPreferredSkills(lines) {
+  const preferred = [];
+  for (const line of lines) {
+    if (/preferred|nice to have|plus/i.test(line)) {
+      preferred.push(...line.split(/[,.;•-]/));
+    }
+  }
+  return preferred.map((value) => value.trim()).filter(Boolean);
+}
+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] || ""));
+}
+function extractMinExperience(text) {
+  const match = text.match(/(\d{1,2})\+?\s+(?:years|yrs)/i);
+  if (match) {
+    return Number.parseInt(match[1], 10);
+  }
+  return void 0;
+}
+function extractEducationRequirements(text) {
+  const normalized = normalizeForComparison(text);
+  return DEGREE_KEYWORDS.filter((degree) => normalized.includes(degree));
+}
+function parseJobDescription(jobDescription, config) {
+  const normalizedText = normalizeWhitespace(jobDescription);
+  const lines = splitLines(jobDescription);
+  const requiredSkillsRaw = extractRequiredSkills(lines);
+  const preferredSkillsRaw = extractPreferredSkills(lines);
+  const requiredSkills = normalizeSkills(requiredSkillsRaw, config.skillAliases);
+  const preferredSkills = normalizeSkills(preferredSkillsRaw, config.skillAliases);
+  const keywords = unique([...requiredSkills, ...preferredSkills, ...tokenize(normalizedText)]);
+  return {
+    raw: jobDescription,
+    normalizedText,
+    requiredSkills,
+    preferredSkills,
+    roleKeywords: extractRoleKeywords(jobDescription),
+    keywords,
+    minExperienceYears: extractMinExperience(jobDescription),
+    educationRequirements: extractEducationRequirements(jobDescription)
+  };
+}
+
+// src/utils/dates.ts
+var MONTHS = {
+  jan: 1,
+  january: 1,
+  feb: 2,
+  february: 2,
+  mar: 3,
+  march: 3,
+  apr: 4,
+  april: 4,
+  may: 5,
+  jun: 6,
+  june: 6,
+  jul: 7,
+  july: 7,
+  aug: 8,
+  august: 8,
+  sep: 9,
+  sept: 9,
+  september: 9,
+  oct: 10,
+  october: 10,
+  nov: 11,
+  november: 11,
+  dec: 12,
+  december: 12
+};
+function parseDateToken(raw) {
+  const cleaned = raw.trim().toLowerCase();
+  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);
+    const month = MONTHS[monthName];
+    if (!Number.isNaN(year)) {
+      return { year, month };
+    }
+  }
+  const yearMatch = cleaned.match(/(20\d{2}|19\d{2})/);
+  if (yearMatch) {
+    const year = Number.parseInt(yearMatch[1], 10);
+    return { year };
+  }
+  return null;
+}
+function monthsBetween(start, end) {
+  const startMonth = start.month ?? 1;
+  const endMonth = end.month ?? 12;
+  return (end.year - start.year) * 12 + (endMonth - startMonth + 1);
+}
+function parseDateRange(text) {
+  const normalized = text.trim();
+  const rangeMatch = normalized.match(/([A-Za-z]{3,9}\s+\d{4}|\d{4})\s*(?:-|to|–|—)\s*(Present|Current|Now|[A-Za-z]{3,9}\s+\d{4}|\d{4})/i);
+  if (!rangeMatch) {
+    return null;
+  }
+  const startToken = parseDateToken(rangeMatch[1]);
+  const endRaw = rangeMatch[2];
+  const isPresent = /present|current|now/i.test(endRaw);
+  const endToken = isPresent ? void 0 : parseDateToken(endRaw);
+  if (!startToken) {
+    return null;
+  }
+  const endTokenResolved = endToken ?? {
+    year: (/* @__PURE__ */ new Date()).getFullYear(),
+    month: (/* @__PURE__ */ new Date()).getMonth() + 1
+  };
+  const durationInMonths = monthsBetween(startToken, endTokenResolved);
+  return {
+    raw: normalized,
+    start: rangeMatch[1],
+    end: isPresent ? "present" : rangeMatch[2],
+    durationInMonths: durationInMonths > 0 ? durationInMonths : void 0
+  };
+}
+function sumExperienceYears(ranges) {
+  const months = ranges.map((range) => range.durationInMonths ?? 0).reduce((total, value) => total + value, 0);
+  return Number((months / 12).toFixed(2));
+}
+
+// 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"]
+};
+var ACTION_VERBS = [
+  "led",
+  "managed",
+  "built",
+  "designed",
+  "implemented",
+  "developed",
+  "created",
+  "improved",
+  "optimized",
+  "launched",
+  "architected",
+  "delivered",
+  "shipped",
+  "collaborated",
+  "automated",
+  "mentored",
+  "modernized",
+  "reduced",
+  "increased"
+];
+function detectSection(line) {
+  const normalized = line.toLowerCase();
+  for (const [section, aliases] of Object.entries(SECTION_ALIASES)) {
+    for (const alias of aliases) {
+      const headerPattern = new RegExp(`^${alias}(s*:)?$`, "i");
+      if (headerPattern.test(normalized)) {
+        return section;
+      }
+    }
+  }
+  return null;
+}
+function extractSections(text) {
+  const lines = splitLines(text);
+  const sections = {};
+  const detected = [];
+  let current = null;
+  const buffer = [];
+  const flush = () => {
+    if (current) {
+      sections[current] = buffer.join("\n").trim();
+      buffer.length = 0;
+    }
+  };
+  for (const line of lines) {
+    const maybeSection = detectSection(line);
+    if (maybeSection) {
+      flush();
+      current = maybeSection;
+      detected.push(maybeSection);
+      continue;
+    }
+    buffer.push(line);
+  }
+  flush();
+  return { sections, detected: unique(detected) };
+}
+function parseSkills(sectionContent, aliases) {
+  if (!sectionContent) return [];
+  const raw = sectionContent.split(/[,;\n]/).map((skill) => skill.trim()).filter(Boolean);
+  return normalizeSkills(raw, aliases);
+}
+function parseActionVerbs(text) {
+  const words = tokenize(text);
+  return ACTION_VERBS.filter((verb) => words.includes(verb));
+}
+function parseExperience(sectionContent) {
+  if (!sectionContent) {
+    return { entries: [], rangesInMonths: [], jobTitles: [] };
+  }
+  const lines = splitLines(sectionContent);
+  const entries = [];
+  const rangesInMonths = [];
+  const jobTitles = [];
+  for (const line of lines) {
+    const range = parseDateRange(line);
+    if (range) {
+      const previous = entries[entries.length - 1];
+      if (previous && !previous.dates) {
+        previous.dates = range;
+      } else {
+        entries.push({ dates: range });
+      }
+      if (range.durationInMonths) {
+        rangesInMonths.push(range.durationInMonths);
+      }
+      continue;
+    }
+    const titleMatch = line.match(/^(Senior|Lead|Principal|Staff|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);
+      continue;
+    }
+    if (entries.length > 0) {
+      const current = entries[entries.length - 1];
+      current.description = [current.description, line].filter(Boolean).join(" ").trim();
+    }
+  }
+  return { entries, rangesInMonths, jobTitles: unique(jobTitles) };
+}
+function parseEducation(sectionContent) {
+  if (!sectionContent) return [];
+  return splitLines(sectionContent).map((line) => normalizeForComparison(line));
+}
+function collectKeywords(text) {
+  return unique(tokenize(text));
+}
+function parseResume(resumeText, config) {
+  const normalizedText = normalizeWhitespace(resumeText);
+  const { sections, detected } = extractSections(resumeText);
+  const skills = parseSkills(sections.skills, config.skillAliases);
+  const actionVerbs = parseActionVerbs(normalizedText);
+  const experienceData = parseExperience(sections.experience);
+  const educationEntries = parseEducation(sections.education);
+  const totalExperienceYears = sumExperienceYears(
+    experienceData.entries.map((entry) => entry.dates).filter((range) => Boolean(range))
+  );
+  const requiredSections = ["summary", "experience", "skills", "education"];
+  const warnings = [];
+  for (const section of requiredSections) {
+    if (!detected.includes(section)) {
+      warnings.push(`${section} section not detected`);
+    }
+  }
+  return {
+    raw: resumeText,
+    normalizedText,
+    detectedSections: detected,
+    sectionContent: sections,
+    skills,
+    jobTitles: experienceData.jobTitles,
+    actionVerbs,
+    educationEntries,
+    experience: experienceData.entries,
+    totalExperienceYears,
+    keywords: collectKeywords(normalizedText),
+    warnings
+  };
+}
+
+// src/core/rules/rule.engine.ts
+var RuleEngine = class {
+  constructor(config) {
+    this.config = config;
+  }
+  applySectionPenalties(resume) {
+    const requiredSections = ["summary", "experience", "skills", "education"];
+    let totalPenalty = 0;
+    const warnings = [];
+    const penaltyBySection = {
+      summary: this.config.sectionPenalties.missingSummary,
+      experience: this.config.sectionPenalties.missingExperience,
+      skills: this.config.sectionPenalties.missingSkills,
+      education: this.config.sectionPenalties.missingEducation,
+      projects: 0,
+      certifications: 0
+    };
+    for (const section of requiredSections) {
+      if (!resume.detectedSections.includes(section)) {
+        const penalty = penaltyBySection[section] ?? 0;
+        totalPenalty += penalty;
+        warnings.push(`${section} section missing (penalty ${penalty})`);
+      }
+    }
+    return { totalPenalty, warnings };
+  }
+  applyDefaultRules(input) {
+    let totalPenalty = 0;
+    const warnings = [];
+    const sectionResult = this.applySectionPenalties(input.resume);
+    totalPenalty += sectionResult.totalPenalty;
+    warnings.push(...sectionResult.warnings);
+    if (containsTableLikeStructure(input.resume.raw)) {
+      totalPenalty += 8;
+      warnings.push("Detected table-like or columnar formatting (penalty 8)");
+    }
+    if (input.overusedKeywords && input.overusedKeywords.length > 0) {
+      const penalty = input.overusedKeywords.length * this.config.keywordDensity.overusePenalty;
+      totalPenalty += penalty;
+      warnings.push(`Keyword stuffing detected for: ${input.overusedKeywords.join(", ")} (penalty ${penalty})`);
+    }
+    if (input.resume.detectedSections.length < 3) {
+      totalPenalty += 5;
+      warnings.push("Few recognizable sections found (penalty 5)");
+    }
+    return { totalPenalty, warnings };
+  }
+  evaluate(input) {
+    const defaultResult = this.applyDefaultRules(input);
+    let totalPenalty = defaultResult.totalPenalty;
+    const warnings = [...defaultResult.warnings];
+    for (const rule of this.config.rules) {
+      const context = {
+        resume: input.resume,
+        job: input.job,
+        weights: this.config.weights,
+        keywordDensity: this.config.keywordDensity,
+        breakdown: input.breakdown,
+        matchedKeywords: input.matchedKeywords,
+        overusedKeywords: input.overusedKeywords
+      };
+      if (rule.condition(context)) {
+        totalPenalty += rule.penalty;
+        if (rule.warning) {
+          warnings.push(rule.warning);
+        }
+      }
+    }
+    return { totalPenalty, warnings };
+  }
+};
+
+// src/core/scoring/scorer.ts
+var REQUIRED_SKILL_WEIGHT = 0.7;
+var OPTIONAL_SKILL_WEIGHT = 0.3;
+var EXPERIENCE_YEARS_WEIGHT = 0.75;
+var EXPERIENCE_ROLE_WEIGHT = 0.25;
+function scoreSkills(resume, job, config) {
+  const profileRequired = config.profile?.mandatorySkills ?? [];
+  const profileOptional = config.profile?.optionalSkills ?? [];
+  const required = new Set(
+    normalizeSkills([...job.requiredSkills, ...profileRequired], config.skillAliases)
+  );
+  const optional = new Set(
+    normalizeSkills([...job.preferredSkills, ...profileOptional], config.skillAliases)
+  );
+  const resumeSkills = new Set(normalizeSkills(resume.skills, config.skillAliases));
+  const matchedRequired = [...required].filter((skill) => resumeSkills.has(skill));
+  const matchedOptional = [...optional].filter((skill) => resumeSkills.has(skill));
+  const requiredCoverage = required.size === 0 ? 1 : matchedRequired.length / required.size;
+  const optionalCoverage = optional.size === 0 ? 1 : matchedOptional.length / optional.size;
+  const score = clamp(
+    (requiredCoverage * REQUIRED_SKILL_WEIGHT + optionalCoverage * OPTIONAL_SKILL_WEIGHT) * 100,
+    0,
+    100
+  );
+  const missing = [...required].filter((skill) => !resumeSkills.has(skill));
+  return { score, missing };
+}
+function scoreExperience(resume, job, config) {
+  const requiredYears = job.minExperienceYears ?? config.profile?.minExperience ?? 0;
+  if (!requiredYears) {
+    return { score: 100, missingYears: 0 };
+  }
+  const yearCoverage = clamp(resume.totalExperienceYears / requiredYears, 0, 2);
+  const yearsComponent = clamp(yearCoverage, 0, 1) * EXPERIENCE_YEARS_WEIGHT;
+  const jobRoleSet = new Set(job.roleKeywords.map((value) => value.toLowerCase()));
+  const titleMatches = resume.jobTitles.filter((title) => jobRoleSet.has(title.toLowerCase()));
+  const titleCoverage = jobRoleSet.size === 0 ? 1 : titleMatches.length / jobRoleSet.size;
+  const roleComponent = clamp(titleCoverage, 0, 1) * EXPERIENCE_ROLE_WEIGHT;
+  const score = clamp((yearsComponent + roleComponent) * 100, 0, 100);
+  const missingYears = Math.max(requiredYears - resume.totalExperienceYears, 0);
+  return { score, missingYears: Number(missingYears.toFixed(2)) };
+}
+function scoreKeywords(resume, job, config) {
+  const jobKeywordSet = new Set(job.keywords.map((value) => value.toLowerCase()));
+  if (jobKeywordSet.size === 0) {
+    return { score: 100, matchedKeywords: [], missingKeywords: [], overusedKeywords: [] };
+  }
+  const resumeTokens = tokenize(resume.normalizedText);
+  const resumeTokenSet = new Set(resumeTokens);
+  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 totalTokens = resumeTokens.length || 1;
+  const overusedKeywords = matchedKeywords.filter((keyword) => {
+    const density = (frequencies[keyword] ?? 0) / totalTokens;
+    return density > config.keywordDensity.max;
+  });
+  return {
+    score,
+    matchedKeywords: unique(matchedKeywords),
+    missingKeywords: unique(missingKeywords),
+    overusedKeywords: unique(overusedKeywords)
+  };
+}
+function scoreEducation(resume, job) {
+  if (job.educationRequirements.length === 0) {
+    return 100;
+  }
+  const resumeEducationText = resume.educationEntries.join(" ");
+  const normalizedEducation = resumeEducationText.toLowerCase();
+  const matched = job.educationRequirements.filter(
+    (requirement) => normalizedEducation.includes(requirement.toLowerCase())
+  );
+  if (matched.length === 0) {
+    return 0;
+  }
+  return clamp(matched.length / job.educationRequirements.length * 100, 0, 100);
+}
+function calculateScore(resume, job, config) {
+  const skillsResult = scoreSkills(resume, job, config);
+  const experienceResult = scoreExperience(resume, job, config);
+  const keywordResult = scoreKeywords(resume, job, config);
+  const educationScore = scoreEducation(resume, job);
+  const breakdown = {
+    skills: skillsResult.score,
+    experience: experienceResult.score,
+    keywords: keywordResult.score,
+    education: educationScore
+  };
+  const weightedScore = breakdown.skills * config.weights.skills + breakdown.experience * config.weights.experience + breakdown.keywords * config.weights.keywords + breakdown.education * config.weights.education;
+  return {
+    score: clamp(Number(weightedScore.toFixed(2)), 0, 100),
+    breakdown,
+    matchedKeywords: keywordResult.matchedKeywords,
+    missingKeywords: keywordResult.missingKeywords,
+    overusedKeywords: keywordResult.overusedKeywords,
+    suggestions: [],
+    warnings: [],
+    missingSkills: skillsResult.missing,
+    missingExperienceYears: experienceResult.missingYears,
+    educationScore
+  };
+}
+
+// src/profiles/index.ts
+var defaultSkillAliases = {
+  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"]
+};
+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,
+  experience: 0.3,
+  keywords: 0.25,
+  education: 0.15
+};
+var DEFAULT_KEYWORD_DENSITY = {
+  min: 25e-4,
+  max: 0.04,
+  overusePenalty: 5
+};
+var DEFAULT_SECTION_PENALTIES = {
+  missingSummary: 4,
+  missingExperience: 10,
+  missingSkills: 8,
+  missingEducation: 6
+};
+function normalizeWeights(weights) {
+  const total = weights.skills + weights.experience + weights.keywords + weights.education;
+  if (total === 0) {
+    return { ...weights, normalizedTotal: 1 };
+  }
+  return {
+    skills: weights.skills / total,
+    experience: weights.experience / total,
+    keywords: weights.keywords / total,
+    education: weights.education / total,
+    normalizedTotal: 1
+  };
+}
+function resolveConfig(config = {}) {
+  const weights = {
+    skills: config.weights?.skills ?? DEFAULT_WEIGHTS.skills,
+    experience: config.weights?.experience ?? DEFAULT_WEIGHTS.experience,
+    keywords: config.weights?.keywords ?? DEFAULT_WEIGHTS.keywords,
+    education: config.weights?.education ?? DEFAULT_WEIGHTS.education
+  };
+  const resolved = {
+    weights: normalizeWeights(weights),
+    skillAliases: { ...defaultSkillAliases, ...config.skillAliases ?? {} },
+    profile: config.profile ?? softwareEngineerProfile,
+    rules: config.rules ?? [],
+    keywordDensity: config.keywordDensity ?? DEFAULT_KEYWORD_DENSITY,
+    sectionPenalties: {
+      ...DEFAULT_SECTION_PENALTIES,
+      ...config.sectionPenalties ?? {}
+    },
+    allowPartialMatches: config.allowPartialMatches ?? true
+  };
+  return resolved;
+}
+
+// src/core/suggestions/suggestion.engine.ts
+function formatList(values, max = 6) {
+  const uniqueValues = Array.from(new Set(values));
+  const trimmed = uniqueValues.slice(0, max);
+  return trimmed.join(", ") + (uniqueValues.length > max ? "..." : "");
+}
+var SuggestionEngine = class {
+  generate(input) {
+    const suggestions = [];
+    const warnings = [...input.ruleWarnings, ...input.resume.warnings];
+    if (input.score.missingSkills.length > 0) {
+      suggestions.push(
+        `Highlight these required skills: ${formatList(input.score.missingSkills)}`
+      );
+    }
+    if (input.score.missingKeywords.length > 0) {
+      suggestions.push(
+        `Incorporate job-specific keywords: ${formatList(input.score.missingKeywords)}`
+      );
+    }
+    if (input.score.overusedKeywords.length > 0) {
+      suggestions.push(
+        `Avoid keyword stuffing for: ${formatList(input.score.overusedKeywords)}`
+      );
+    }
+    if (input.score.missingExperienceYears > 0) {
+      suggestions.push(
+        `Clarify at least ${input.job.minExperienceYears ?? input.score.missingExperienceYears} years of relevant experience with quantified achievements.`
+      );
+    }
+    if (input.job.educationRequirements.length > 0 && input.score.educationScore === 0) {
+      suggestions.push(
+        `State your education credentials matching: ${formatList(input.job.educationRequirements)}`
+      );
+    }
+    if (input.resume.actionVerbs.length < 3) {
+      suggestions.push(
+        "Strengthen bullet points with impact verbs (led, built, improved, delivered)."
+      );
+    }
+    return { suggestions, warnings };
+  }
+};
+
+// src/index.ts
+function analyzeResume(input) {
+  const resolvedConfig = resolveConfig(input.config ?? {});
+  const parsedResume = parseResume(input.resumeText, resolvedConfig);
+  const parsedJob = parseJobDescription(input.jobDescription, resolvedConfig);
+  const scoring = calculateScore(parsedResume, parsedJob, resolvedConfig);
+  const ruleEngine = new RuleEngine(resolvedConfig);
+  const ruleResult = ruleEngine.evaluate({
+    resume: parsedResume,
+    job: parsedJob,
+    breakdown: scoring.breakdown,
+    matchedKeywords: scoring.matchedKeywords,
+    overusedKeywords: scoring.overusedKeywords
+  });
+  const suggestionEngine = new SuggestionEngine();
+  const suggestionResult = suggestionEngine.generate({
+    resume: parsedResume,
+    job: parsedJob,
+    score: scoring,
+    ruleWarnings: ruleResult.warnings
+  });
+  const finalScore = clamp(scoring.score - ruleResult.totalPenalty, 0, 100);
+  return {
+    score: finalScore,
+    breakdown: scoring.breakdown,
+    matchedKeywords: scoring.matchedKeywords,
+    missingKeywords: scoring.missingKeywords,
+    overusedKeywords: scoring.overusedKeywords,
+    suggestions: suggestionResult.suggestions,
+    warnings: suggestionResult.warnings
+  };
+}
+
+exports.analyzeResume = analyzeResume;
+exports.defaultProfiles = defaultProfiles;
+exports.defaultSkillAliases = defaultSkillAliases;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map