@pranavraut033/ats-checker 1.0.4 → 1.1.0

package/dist/index.js

@@ -37,13 +37,15 @@ function normalizeWhitespace(text) {
   return text.replace(/\r\n?/g, "\n").replace(/\s+/g, " ").trim();
 }
 function normalizeForComparison(text) {
-  return normalizeWhitespace(text).toLowerCase();
+  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) {
-  return normalizeForComparison(text).split(/[^a-z0-9+]+/i).map((word) => word.trim()).filter((word) => word.length > 1 && !STOP_WORDS.has(word));
+  const normalized = normalizeForComparison(text);
+  return (normalized.match(TECH_TOKEN_RE) ?? []).filter((t) => !STOP_WORDS.has(t));
 }
 function unique(values) {
   const seen = /* @__PURE__ */ new Set();
@@ -217,7 +219,7 @@ function monthsBetween(start, end) {
   const endMonth = end.month ?? 12;
   return (end.year - start.year) * 12 + (endMonth - startMonth + 1);
 }
-function parseDateRange(text) {
+function parseDateRange(text, referenceDate) {
   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) {
@@ -230,9 +232,10 @@ function parseDateRange(text) {
   if (!startToken) {
     return null;
   }
+  const ref = referenceDate ?? /* @__PURE__ */ new Date();
   const endTokenResolved = endToken ?? {
-    year: (/* @__PURE__ */ new Date()).getFullYear(),
-    month: (/* @__PURE__ */ new Date()).getMonth() + 1
+    year: ref.getFullYear(),
+    month: ref.getMonth() + 1
   };
   const durationInMonths = monthsBetween(startToken, endTokenResolved);
   return {
@@ -277,11 +280,15 @@ var ACTION_VERBS = [
   "reduced",
   "increased"
 ];
+function escapeRegExp(input) {
+  return input.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
+}
 function detectSection(line) {
-  const normalized = line.toLowerCase();
+  const normalized = line.trim().toLowerCase();
   for (const [section, aliases] of Object.entries(SECTION_ALIASES)) {
     for (const alias of aliases) {
-      const headerPattern = new RegExp(`^${alias}(s*:)?$`, "i");
+      const safeAlias = escapeRegExp(alias);
+      const headerPattern = new RegExp(`^${safeAlias}(\\s*:)?$`, "i");
       if (headerPattern.test(normalized)) {
         return section;
       }
@@ -323,7 +330,7 @@ function parseActionVerbs(text) {
   const words = tokenize(text);
   return ACTION_VERBS.filter((verb) => words.includes(verb));
 }
-function parseExperience(sectionContent) {
+function parseExperience(sectionContent, referenceDate) {
   if (!sectionContent) {
     return { entries: [], rangesInMonths: [], jobTitles: [] };
   }
@@ -332,7 +339,7 @@ function parseExperience(sectionContent) {
   const rangesInMonths = [];
   const jobTitles = [];
   for (const line of lines) {
-    const range = parseDateRange(line);
+    const range = parseDateRange(line, referenceDate);
     if (range) {
       const previous = entries[entries.length - 1];
       if (previous && !previous.dates) {
@@ -372,7 +379,7 @@ function parseResume(resumeText, config) {
   const { sections, detected } = extractSections(resumeText);
   const skills = parseSkills(sections.skills, config.skillAliases);
   const actionVerbs = parseActionVerbs(normalizedText);
-  const experienceData = parseExperience(sections.experience);
+  const experienceData = parseExperience(sections.experience, config.referenceDate);
   const educationEntries = parseEducation(sections.education);
   const totalExperienceYears = sumExperienceYears(
     experienceData.entries.map((entry) => entry.dates).filter((range) => Boolean(range))
@@ -496,8 +503,9 @@ function scoreSkills(resume, job, config) {
     0,
     100
   );
-  const missing = [...required].filter((skill) => !resumeSkills.has(skill));
-  return { score, missing };
+  const matched = [...required].filter((skill) => resumeSkills.has(skill)).sort();
+  const missing = [...required].filter((skill) => !resumeSkills.has(skill)).sort();
+  return { score, matched, missing };
 }
 function scoreExperience(resume, job, config) {
   const requiredYears = job.minExperienceYears ?? config.profile?.minExperience ?? 0;
@@ -515,11 +523,15 @@ function scoreExperience(resume, job, config) {
   return { score, missingYears: Number(missingYears.toFixed(2)) };
 }
 function scoreKeywords(resume, job, config) {
-  const jobKeywordSet = new Set(job.keywords.map((value) => value.toLowerCase()));
+  const jobKeywordSet = new Set(
+    job.keywords.map((k) => normalizeSkill(k, config.skillAliases))
+  );
   if (jobKeywordSet.size === 0) {
     return { score: 100, matchedKeywords: [], missingKeywords: [], overusedKeywords: [] };
   }
-  const resumeTokens = tokenize(resume.normalizedText);
+  const resumeTokens = tokenize(resume.normalizedText).map(
+    (t) => normalizeSkill(t, config.skillAliases)
+  );
   const resumeTokenSet = new Set(resumeTokens);
   const matchedKeywords = [...jobKeywordSet].filter((keyword) => resumeTokenSet.has(keyword));
   const missingKeywords = [...jobKeywordSet].filter((keyword) => !resumeTokenSet.has(keyword));
@@ -533,9 +545,9 @@ function scoreKeywords(resume, job, config) {
   });
   return {
     score,
-    matchedKeywords: unique(matchedKeywords),
-    missingKeywords: unique(missingKeywords),
-    overusedKeywords: unique(overusedKeywords)
+    matchedKeywords: unique(matchedKeywords).sort(),
+    missingKeywords: unique(missingKeywords).sort(),
+    overusedKeywords: unique(overusedKeywords).sort()
   };
 }
 function scoreEducation(resume, job) {
@@ -567,12 +579,17 @@ function calculateScore(resume, job, config) {
   return {
     score: clamp(Number(weightedScore.toFixed(2)), 0, 100),
     breakdown,
+    matchedSkills: skillsResult.matched,
+    missingSkills: skillsResult.missing,
     matchedKeywords: keywordResult.matchedKeywords,
     missingKeywords: keywordResult.missingKeywords,
     overusedKeywords: keywordResult.overusedKeywords,
     suggestions: [],
     warnings: [],
-    missingSkills: skillsResult.missing,
+    // detectedSections / parsedExperienceYears / experienceGap: filled by index.ts
+    experienceGap: experienceResult.missingYears,
+    detectedSections: [],
+    parsedExperienceYears: 0,
     missingExperienceYears: experienceResult.missingYears,
     educationScore
   };
@@ -580,7 +597,9 @@ function calculateScore(resume, job, config) {
 
 // src/profiles/index.ts
 var defaultSkillAliases = {
-  javascript: ["js", "node", "node.js", "nodejs"],
+  // ponytail: "node" split from javascript — Node.js runtime !== JS language
+  javascript: ["js"],
+  node: ["node.js", "nodejs"],
   typescript: ["ts"],
   react: ["reactjs", "react.js"],
   "c++": ["cpp"],
@@ -641,7 +660,14 @@ var DEFAULT_SECTION_PENALTIES = {
 function normalizeWeights(weights) {
   const total = weights.skills + weights.experience + weights.keywords + weights.education;
   if (total === 0) {
-    return { ...weights, normalizedTotal: 1 };
+    const equal = 1 / 4;
+    return {
+      skills: equal,
+      experience: equal,
+      keywords: equal,
+      education: equal,
+      normalizedTotal: 1
+    };
   }
   return {
     skills: weights.skills / total,
@@ -668,7 +694,8 @@ function resolveConfig(config = {}) {
       ...DEFAULT_SECTION_PENALTIES,
       ...config.sectionPenalties ?? {}
     },
-    allowPartialMatches: config.allowPartialMatches ?? true
+    allowPartialMatches: config.allowPartialMatches ?? true,
+    referenceDate: config.referenceDate ? new Date(config.referenceDate) : void 0
   };
   return resolved;
 }
@@ -780,6 +807,53 @@ var LLMBudgetManager = class {
   }
 };
 
+// src/llm/validation.ts
+function validateJsonSchema(data, schema) {
+  if (schema.type !== "object" || typeof data !== "object" || data === null) return false;
+  const obj = data;
+  if (schema.required) {
+    for (const r of schema.required) {
+      if (!(r in obj)) return false;
+    }
+  }
+  if (schema.properties && typeof schema.properties === "object") {
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+      const value = obj[key];
+      if (value === void 0) continue;
+      if (propSchema == null) continue;
+      const expectedType = propSchema.type;
+      if (!expectedType) continue;
+      switch (expectedType) {
+        case "string":
+          if (typeof value !== "string") return false;
+          break;
+        case "number":
+          if (typeof value !== "number") return false;
+          break;
+        case "boolean":
+          if (typeof value !== "boolean") return false;
+          break;
+        case "array":
+          if (!Array.isArray(value)) return false;
+          const items = propSchema.items;
+          if (items && items.type && Array.isArray(value)) {
+            const itemType = items.type;
+            for (const item of value) {
+              if (itemType === "string" && typeof item !== "string") return false;
+              if (itemType === "number" && typeof item !== "number") return false;
+              if (itemType === "object" && (typeof item !== "object" || item === null)) return false;
+            }
+          }
+          break;
+        case "object":
+          if (typeof value !== "object" || value === null) return false;
+          break;
+      }
+    }
+  }
+  return true;
+}
+
 // src/llm/llm.manager.ts
 var LLMManager = class {
   constructor(config) {
@@ -793,6 +867,11 @@ var LLMManager = class {
    * Structured call to LLM with timeout and budget protection
    */
   async callLLM(systemPrompt, userPrompt, schema, options = {}) {
+    const onUnhandled = (reason) => {
+      this.warnings.push(`Unhandled rejection during LLM call: ${String(reason)}`);
+    };
+    process.on("unhandledRejection", onUnhandled);
+    let clientPromise = void 0;
     try {
       const estimatedTokens = this.estimateTokens(systemPrompt, userPrompt, options.requestedTokens);
       try {
@@ -800,30 +879,46 @@ var LLMManager = class {
       } catch (e) {
         const msg = `LLM budget exhausted: ${e.message}`;
         this.warnings.push(msg);
+        globalThis.setTimeout(() => process.removeListener("unhandledRejection", onUnhandled), 100);
         return { success: false, fallback: true, error: msg };
       }
       if (!this.isValidJsonSchema(schema)) {
         const msg = "Invalid JSON schema provided";
         this.warnings.push(msg);
+        globalThis.setTimeout(() => process.removeListener("unhandledRejection", onUnhandled), 100);
         return { success: false, fallback: true, error: msg };
       }
       const strictUserPrompt = `${userPrompt}
 
 Return ONLY valid JSON matching the schema below.
 No explanations. No markdown. No additional text.`;
-      const response = await Promise.race([
-        this.client.createCompletion({
-          model: options.useThinking ? this.config.models?.thinking || this.config.models?.default || "gpt-4o" : this.config.models?.default || "gpt-4o",
-          messages: [
-            { role: "system", content: systemPrompt },
-            { role: "user", content: strictUserPrompt }
-          ],
-          max_tokens: options.requestedTokens || 2e3,
-          response_format: schema
-        }),
-        this.createTimeout(this.timeoutMs)
-      ]);
+      clientPromise = this.client.createCompletion({
+        model: options.useThinking ? this.config.models?.thinking || this.config.models?.default || "gpt-4o" : this.config.models?.default || "gpt-4o",
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: strictUserPrompt }
+        ],
+        max_tokens: options.requestedTokens || 2e3,
+        response_format: schema
+      });
+      void clientPromise.catch(() => {
+      });
+      const timeoutPromise = new Promise((_, reject) => {
+        const id = globalThis.setTimeout(() => reject(new Error(`LLM call timeout after ${this.timeoutMs}ms`)), this.timeoutMs);
+        void clientPromise.finally(() => globalThis.clearTimeout(id));
+      });
+      void timeoutPromise.catch(() => {
+      });
+      const response = await Promise.race([clientPromise, timeoutPromise]);
       if (!response || !response.content) {
+        const graceMs = Math.min(Math.max(this.timeoutMs * 2, 100), 500);
+        try {
+          await Promise.race([clientPromise.catch(() => {
+          }), new Promise((r) => setTimeout(r, graceMs))]);
+        } catch (e) {
+        } finally {
+          process.removeListener("unhandledRejection", onUnhandled);
+        }
         return { success: false, fallback: true, error: "Empty response from LLM" };
       }
       let parsedContent;
@@ -836,15 +931,32 @@ No explanations. No markdown. No additional text.`;
       } catch (e) {
         const msg = `Invalid JSON in LLM response: ${e.message}`;
         this.warnings.push(msg);
+        const graceMs = Math.min(Math.max(this.timeoutMs * 2, 100), 500);
+        try {
+          await Promise.race([clientPromise.catch(() => {
+          }), new Promise((r) => setTimeout(r, graceMs))]);
+        } catch (e2) {
+        } finally {
+          process.removeListener("unhandledRejection", onUnhandled);
+        }
         return { success: false, fallback: true, error: msg };
       }
       if (!this.validateAgainstSchema(parsedContent, schema)) {
         const msg = "LLM response does not match schema";
         this.warnings.push(msg);
+        const graceMs = Math.min(Math.max(this.timeoutMs * 2, 100), 500);
+        try {
+          await Promise.race([clientPromise.catch(() => {
+          }), new Promise((r) => setTimeout(r, graceMs))]);
+        } catch (e) {
+        } finally {
+          process.removeListener("unhandledRejection", onUnhandled);
+        }
         return { success: false, fallback: true, error: msg };
       }
       const tokensUsed = response.usage?.total_tokens || estimatedTokens;
       this.budgetManager.recordUsage(tokensUsed);
+      process.removeListener("unhandledRejection", onUnhandled);
       return {
         success: true,
         fallback: false,
@@ -854,6 +966,14 @@ No explanations. No markdown. No additional text.`;
     } catch (e) {
       const msg = `LLM call failed: ${e.message}`;
       this.warnings.push(msg);
+      const graceMs = Math.min(Math.max(this.timeoutMs * 2, 100), 500);
+      try {
+        await Promise.race([clientPromise.catch(() => {
+        }), new Promise((r) => setTimeout(r, graceMs))]);
+      } catch (e2) {
+      } finally {
+        process.removeListener("unhandledRejection", onUnhandled);
+      }
       return { success: false, fallback: true, error: msg };
     }
   }
@@ -876,14 +996,6 @@ No explanations. No markdown. No additional text.`;
     return this.config.enable?.[feature] === true;
   }
   // ============ Private helpers ============
-  /**
-   * Create a timeout promise
-   */
-  createTimeout(ms) {
-    return new Promise((_, reject) => {
-      globalThis.setTimeout(() => reject(new Error(`LLM call timeout after ${ms}ms`)), ms);
-    });
-  }
   /**
    * Estimate tokens for a call (rough approximation)
    * 1 token ≈ 4 characters average
@@ -906,18 +1018,22 @@ No explanations. No markdown. No additional text.`;
    * Simple schema validation - check required fields exist
    */
   validateAgainstSchema(data, schema) {
-    if (typeof data !== "object" || data === null) {
-      return false;
-    }
-    const obj = data;
-    if (schema.required) {
-      for (const field of schema.required) {
-        if (!(field in obj)) {
-          return false;
+    try {
+      return validateJsonSchema(data, schema);
+    } catch (e) {
+      if (typeof data !== "object" || data === null) {
+        return false;
+      }
+      const obj = data;
+      if (schema.required) {
+        for (const field of schema.required) {
+          if (!(field in obj)) {
+            return false;
+          }
         }
       }
+      return true;
     }
-    return true;
   }
 };
 
@@ -1276,9 +1392,14 @@ function analyzeResume(input) {
   return {
     score: finalScore,
     breakdown: scoring.breakdown,
+    matchedSkills: scoring.matchedSkills,
+    missingSkills: scoring.missingSkills,
     matchedKeywords: scoring.matchedKeywords,
     missingKeywords: scoring.missingKeywords,
     overusedKeywords: scoring.overusedKeywords,
+    experienceGap: scoring.experienceGap,
+    detectedSections: parsedResume.detectedSections,
+    parsedExperienceYears: parsedResume.totalExperienceYears,
     suggestions,
     warnings: [...suggestionResult.warnings, ...llmWarnings]
   };
@@ -1335,9 +1456,14 @@ async function analyzeResumeAsync(input) {
   return {
     score: finalScore,
     breakdown: scoring.breakdown,
+    matchedSkills: scoring.matchedSkills,
+    missingSkills: scoring.missingSkills,
     matchedKeywords: scoring.matchedKeywords,
     missingKeywords: scoring.missingKeywords,
     overusedKeywords: scoring.overusedKeywords,
+    experienceGap: scoring.experienceGap,
+    detectedSections: parsedResume.detectedSections,
+    parsedExperienceYears: parsedResume.totalExperienceYears,
     suggestions,
     warnings: [...suggestionResult.warnings, ...llmWarnings]
   };