@pranavraut033/ats-checker 1.3.3 → 2.0.0

package/dist/{scoring-BCShrnki.d.ts → config-CVmXtmvk.d.ts}

@@ -1,3 +1,27 @@
+interface EmploymentGap {
+    /** Title (or company/fallback label) of the role worked immediately before the gap. */
+    afterRole: string;
+    months: number;
+}
+
+/** ATS-relevant parseability signals extracted from a resume's raw text. */
+interface FormattingSignals {
+    /** Pipe/tab/aligned-space table structure (reuses containsTableLikeStructure). */
+    hasTables: boolean;
+    /** Very wide, inconsistent whitespace gaps suggesting a PDF-extracted multi-column layout. */
+    hasMultiColumn: boolean;
+    /** Control chars / private-use-area glyphs (icon fonts) / replacement chars from a bad extraction. */
+    hasSpecialChars: boolean;
+    /** Bullets other than the common -, *, •, o, numbered/lettered list markers. */
+    nonStandardBullets: boolean;
+    /** Text density/shape consistent with a scanned image (no embedded text layer) rather than real text. */
+    likelyScanned: boolean;
+    /** A plausible email address is present in the raw text (contact info is extractable). */
+    contactParseable: boolean;
+}
+
+type Seniority = "junior" | "mid" | "senior" | "lead" | "principal";
+
 type ResumeSection = "summary" | "experience" | "skills" | "education" | "projects" | "certifications";
 interface ParsedDateRange {
     raw?: string;
@@ -16,6 +40,8 @@ interface ParsedExperienceEntry {
     location?: string;
     dates?: ParsedDateRange;
     description?: string;
+    /** Skills mentioned within this role's bullets, resolved via the alias/fuzzy registry lookup. */
+    skills: string[];
 }
 interface ParsedAchievement {
     text: string;
@@ -47,8 +73,26 @@ interface ParsedResume {
     totalExperienceYears: number;
     keywords: string[];
     languages: ParsedLanguage[];
+    /** Contact details extracted via regex; absent fields mean detection failed, not that the resume lacks them. */
+    contact?: {
+        email?: string;
+        phone?: string;
+        linkedin?: string;
+        location?: string;
+    };
+    /** Inferred overall seniority (highest-ranked signal across job titles), or undefined if unknown. */
+    seniority?: Seniority;
+    /** Gaps of minGapMonths+ between consecutive (chronologically merged) roles. */
+    employmentGaps: EmploymentGap[];
+    /** ATS-relevant parseability/formatting signals extracted from the raw text. */
+    formatting: FormattingSignals;
     warnings: string[];
 }
+/** A JD's "N+ years of <skill>" requirement, e.g. { skill: "figma", years: 5 }. */
+interface SkillExperienceRequirement {
+    skill: string;
+    years: number;
+}
 interface ParsedJobDescription {
     raw: string;
     normalizedText: string;
@@ -57,97 +101,14 @@ interface ParsedJobDescription {
     roleKeywords: string[];
     keywords: string[];
     minExperienceYears?: number;
+    /** Per-skill year requirements parsed from the JD, e.g. "5+ years of Figma". */
+    skillExperienceRequirements: SkillExperienceRequirement[];
     educationRequirements: string[];
     /** canonical keyword -> the surface form (original casing/spelling) the JD used. */
     keywordSurfaceForms: Record<string, string>;
     requiredLanguages: ParsedLanguage[];
-}
-
-interface ATSWeights {
-    skills: number;
-    experience: number;
-    keywords: number;
-    education: number;
-}
-type SkillAliases = Record<string, string[]>;
-type KeywordCategory = "technical" | "tool" | "concept" | "soft" | "marketing" | "domain";
-interface KeywordEntry {
-    canonical: string;
-    aliases: string[];
-    category: KeywordCategory;
-}
-type KeywordRegistry = KeywordEntry[];
-interface ATSProfile {
-    name: string;
-    mandatorySkills: string[];
-    optionalSkills: string[];
-    minExperience?: number;
-}
-interface KeywordDensityConfig {
-    /** Minimum density before a keyword is considered underused (informational only). */
-    min: number;
-    /** Maximum density before a keyword is considered stuffed. */
-    max: number;
-    /** Penalty applied when density exceeds max. */
-    overusePenalty: number;
-}
-interface SectionPenaltyConfig {
-    missingSummary?: number;
-    missingExperience?: number;
-    missingSkills?: number;
-    missingEducation?: number;
-}
-interface ATSRule {
-    id: string;
-    description?: string;
-    penalty: number;
-    warning?: string;
-    condition: (context: RuleContext) => boolean;
-}
-interface ATSConfig {
-    weights?: Partial<ATSWeights>;
-    skillAliases?: SkillAliases;
-    /** Categorized keyword/alias entries (technical, tool, concept, soft, marketing, domain). Merges over the default registry by canonical term. */
-    keywordRegistry?: KeywordRegistry;
-    profile?: ATSProfile;
-    rules?: ATSRule[];
-    keywordDensity?: KeywordDensityConfig;
-    sectionPenalties?: SectionPenaltyConfig;
-    allowPartialMatches?: boolean;
-    /**
-     * ISO date string (e.g. "2024-06-01") used as the "today" reference when
-     * computing duration for open-ended date ranges ("Present"/"Current"/"Now").
-     * Omit to use the actual current date (live/production behaviour).
-     * Set to a fixed value in tests or batch processing to guarantee determinism.
-     */
-    referenceDate?: string;
-}
-interface NormalizedWeights extends ATSWeights {
-    /** Weights normalized so they sum to 1. */
-    normalizedTotal: number;
-}
-interface ResolvedATSConfig {
-    weights: NormalizedWeights;
-    skillAliases: SkillAliases;
-    keywordRegistry: KeywordRegistry;
-    /** canonical term -> category, derived once from keywordRegistry. */
-    categoryIndex: Map<string, KeywordCategory>;
-    profile?: ATSProfile;
-    rules: ATSRule[];
-    keywordDensity: KeywordDensityConfig;
-    sectionPenalties: Required<SectionPenaltyConfig>;
-    allowPartialMatches: boolean;
-    /** Resolved reference date for "Present" duration calculations. */
-    referenceDate?: Date;
-}
-interface RuleContext {
-    resume: ParsedResume;
-    job: ParsedJobDescription;
-    weights: NormalizedWeights;
-    keywordDensity: KeywordDensityConfig;
-    breakdown?: ATSBreakdown;
-    matchedKeywords?: string[];
-    overusedKeywords?: string[];
+    /** Inferred seniority cue from the JD's role/title text, or undefined if unknown. */
+    seniority?: Seniority;
 }
 
 /**
@@ -260,8 +221,32 @@ interface ATSBreakdown {
     skills: number;
     experience: number;
     keywords: number;
+    /** Real-ATS parseability score (0-100) — formatting, contact extractability, section coverage. */
+    parseability: number;
     education: number;
 }
+/** One point deduction applied while computing the parseability score. */
+interface ParseabilityDeduction {
+    reason: string;
+    points: number;
+}
+/** Detail behind `breakdown.parseability` — the formatting signals plus what was deducted and why. */
+interface ParseabilityReport extends FormattingSignals {
+    /** Number of standard resume sections the parser detected. */
+    detectedSectionCount: number;
+    /** Ordered list of deductions applied to get from 100 down to `breakdown.parseability`. */
+    deductions: ParseabilityDeduction[];
+}
+/** Comparison between the resume's inferred seniority and the JD's required seniority. */
+interface SeniorityMatch {
+    resume?: Seniority;
+    required?: Seniority;
+    /**
+     * True when the resume's seniority rank is >= the JD's required rank, or when either side
+     * is unknown (we never penalize on missing signal — only on a confirmed mismatch).
+     */
+    met: boolean;
+}
 interface AnalyzeResumeInput {
     resumeText: string;
     jobDescription: string;
@@ -314,6 +299,141 @@ interface ATSAnalysisResult {
     parsedExperienceYears: number;
     /** Parsed experience entries from the resume, with titles and date ranges. */
     experienceEntries: ParsedExperienceEntry[];
+    /**
+     * JD skills the resume has but whose overall experience falls short of the JD's per-skill
+     * year requirement (e.g. JD wants "5+ years Figma", resume has Figma but only 3 years total).
+     * Informational only — does not feed `score`/`breakdown`, same as language proficiency.
+     */
+    skillExperienceGaps: {
+        skill: string;
+        requiredYears: number;
+        resumeYears: number;
+    }[];
+    /** Detail behind `breakdown.parseability` — which formatting signals were detected and penalized. */
+    parseabilityReport: ParseabilityReport;
+    /** Gaps of 3+ months between consecutive (chronologically merged) roles. Informational only. */
+    employmentGaps: EmploymentGap[];
+    /** Resume vs JD-required seniority comparison. Informational only outside its modest, capped
+     *  contribution to `breakdown.experience` (see scorer.ts). */
+    seniorityMatch: SeniorityMatch;
+    /**
+     * Per-skill years of experience derived from per-role dating (sum of durations of roles whose
+     * bullets mention that skill), replacing the old "assume the skill spans the whole resume
+     * tenure" approximation. Informational only — does not feed `score`/`breakdown`.
+     */
+    perSkillExperience: {
+        skill: string;
+        years: number;
+    }[];
+}
+
+interface ATSWeights {
+    skills: number;
+    experience: number;
+    keywords: number;
+    /** How much the resume's real-ATS parseability (formatting/contact/sections) counts toward score. */
+    parseability: number;
+    education: number;
+}
+type SkillAliases = Record<string, string[]>;
+type KeywordCategory = "technical" | "tool" | "concept" | "soft" | "marketing" | "domain";
+interface KeywordEntry {
+    canonical: string;
+    aliases: string[];
+    category: KeywordCategory;
+}
+type KeywordRegistry = KeywordEntry[];
+interface ATSProfile {
+    name: string;
+    mandatorySkills: string[];
+    optionalSkills: string[];
+    minExperience?: number;
+}
+interface KeywordDensityConfig {
+    /** Minimum density before a keyword is considered underused (informational only). */
+    min: number;
+    /** Maximum density before a keyword is considered stuffed. */
+    max: number;
+    /** Penalty applied when density exceeds max. */
+    overusePenalty: number;
+}
+interface SectionPenaltyConfig {
+    missingSummary?: number;
+    missingExperience?: number;
+    missingSkills?: number;
+    missingEducation?: number;
+    /**
+     * Penalty when no parseable contact email is detected. Defaults to 12 — a real ATS treats
+     * unparseable contact info as a near-knockout (recruiters/automated outreach can't reach the
+     * candidate at all), so this is deliberately more than a token warning-only value.
+     */
+    missingContact?: number;
+}
+interface MatchingConfig {
+    /**
+     * Fall back to stemmed/fuzzy matching (typos, word-form variants like "developing" vs
+     * "develop", "ReactJS" vs "react") when an exact alias lookup misses. Default: true.
+     * Set to false to reproduce pre-v2 exact-match-only behavior.
+     */
+    fuzzy?: boolean;
+    /** Passed through to fuzzyEqual's bounded Levenshtein distance when fuzzy matching is enabled. */
+    threshold?: number;
+}
+interface ATSRule {
+    id: string;
+    description?: string;
+    penalty: number;
+    warning?: string;
+    condition: (context: RuleContext) => boolean;
+}
+interface ATSConfig {
+    weights?: Partial<ATSWeights>;
+    skillAliases?: SkillAliases;
+    /** Categorized keyword/alias entries (technical, tool, concept, soft, marketing, domain). Merges over the default registry by canonical term. */
+    keywordRegistry?: KeywordRegistry;
+    profile?: ATSProfile;
+    rules?: ATSRule[];
+    keywordDensity?: KeywordDensityConfig;
+    sectionPenalties?: SectionPenaltyConfig;
+    allowPartialMatches?: boolean;
+    /** Stemmed/fuzzy matching behavior for skills/keywords. Defaults to `{ fuzzy: true }`. */
+    matching?: MatchingConfig;
+    /**
+     * ISO date string (e.g. "2024-06-01") used as the "today" reference when
+     * computing duration for open-ended date ranges ("Present"/"Current"/"Now").
+     * Omit to use the actual current date (live/production behaviour).
+     * Set to a fixed value in tests or batch processing to guarantee determinism.
+     */
+    referenceDate?: string;
+}
+interface NormalizedWeights extends ATSWeights {
+    /** Weights normalized so they sum to 1. */
+    normalizedTotal: number;
+}
+interface ResolvedATSConfig {
+    weights: NormalizedWeights;
+    skillAliases: SkillAliases;
+    keywordRegistry: KeywordRegistry;
+    /** canonical term -> category, derived once from keywordRegistry. */
+    categoryIndex: Map<string, KeywordCategory>;
+    profile?: ATSProfile;
+    rules: ATSRule[];
+    keywordDensity: KeywordDensityConfig;
+    sectionPenalties: Required<SectionPenaltyConfig>;
+    allowPartialMatches: boolean;
+    /** Resolved matching behavior; `fuzzy` is always defined (defaults to true). */
+    matching: Required<Pick<MatchingConfig, "fuzzy">> & Pick<MatchingConfig, "threshold">;
+    /** Resolved reference date for "Present" duration calculations. */
+    referenceDate?: Date;
+}
+interface RuleContext {
+    resume: ParsedResume;
+    job: ParsedJobDescription;
+    weights: NormalizedWeights;
+    keywordDensity: KeywordDensityConfig;
+    breakdown?: ATSBreakdown;
+    matchedKeywords?: string[];
+    overusedKeywords?: string[];
 }
 
-export type { ATSProfile as A, JSONSchema as J, KeywordRegistry as K, LLMConfig as L, NormalizedWeights as N, ParsedDateRange as P, ResolvedATSConfig as R, SkillAliases as S, LLMResult as a, LLMBudget as b, AnalyzeResumeInput as c, ATSAnalysisResult as d, ATSWeights as e, KeywordCategory as f, KeywordEntry as g, KeywordDensityConfig as h, SectionPenaltyConfig as i, ATSRule as j, ATSConfig as k, RuleContext as l, ResumeSection as m, ParsedExperienceEntry as n, ParsedAchievement as o, ParsedLanguage as p, ParsedResume as q, ParsedJobDescription as r, ATSBreakdown as s, KeywordWeight as t, LLMClient as u, LLMFeatures as v, AnalyzeResumeInputV2 as w, LLMUsageStats as x };
+export type { ATSProfile as A, AnalyzeResumeInputV2 as B, LLMUsageStats as C, JSONSchema as J, KeywordRegistry as K, LLMConfig as L, MatchingConfig as M, NormalizedWeights as N, ParsedDateRange as P, ResolvedATSConfig as R, SkillAliases as S, LLMResult as a, LLMBudget as b, AnalyzeResumeInput as c, ATSAnalysisResult as d, ATSWeights as e, KeywordCategory as f, KeywordEntry as g, KeywordDensityConfig as h, SectionPenaltyConfig as i, ATSRule as j, ATSConfig as k, RuleContext as l, ResumeSection as m, ParsedExperienceEntry as n, ParsedAchievement as o, ParsedLanguage as p, ParsedResume as q, SkillExperienceRequirement as r, ParsedJobDescription as s, ATSBreakdown as t, ParseabilityDeduction as u, ParseabilityReport as v, SeniorityMatch as w, KeywordWeight as x, LLMClient as y, LLMFeatures as z };