@pranavraut033/ats-checker 1.2.0 → 1.3.2

package/dist/scoring-BCShrnki.d.ts

@@ -0,0 +1,319 @@
+type ResumeSection = "summary" | "experience" | "skills" | "education" | "projects" | "certifications";
+interface ParsedDateRange {
+    raw?: string;
+    start?: string;
+    end?: string;
+    durationInMonths?: number;
+    /** Numeric year/month of the start and end, for overlap-aware summing. */
+    startYear?: number;
+    startMonth?: number;
+    endYear?: number;
+    endMonth?: number;
+}
+interface ParsedExperienceEntry {
+    title?: string;
+    company?: string;
+    location?: string;
+    dates?: ParsedDateRange;
+    description?: string;
+}
+interface ParsedAchievement {
+    text: string;
+    strength: "strong" | "weak";
+    reason: string;
+}
+interface ParsedLanguage {
+    /** Canonical lowercase language name, e.g. "german". */
+    name: string;
+    /** Raw level as written/normalized, e.g. "c1", "fluent", "native". */
+    level?: string;
+    /** CEFR-aligned rank 1 (A1/basic) – 6 (C2/native), for comparing proficiency. */
+    levelRank?: number;
+}
+interface ParsedResume {
+    raw: string;
+    normalizedText: string;
+    detectedSections: ResumeSection[];
+    sectionContent: Partial<Record<ResumeSection, string>>;
+    skills: string[];
+    jobTitles: string[];
+    actionVerbs: string[];
+    /** Weak verbs (helped, worked, performed, ...) found in the resume text. */
+    weakVerbs: string[];
+    /** Experience bullets classified as strong/weak achievement statements. */
+    achievements: ParsedAchievement[];
+    educationEntries: string[];
+    experience: ParsedExperienceEntry[];
+    totalExperienceYears: number;
+    keywords: string[];
+    languages: ParsedLanguage[];
+    warnings: string[];
+}
+interface ParsedJobDescription {
+    raw: string;
+    normalizedText: string;
+    requiredSkills: string[];
+    preferredSkills: string[];
+    roleKeywords: string[];
+    keywords: string[];
+    minExperienceYears?: number;
+    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[];
+}
+
+/**
+ * LLM v2 Support Types - Optional, Backward Compatible
+ */
+
+/**
+ * JSON Schema for response validation
+ */
+interface JSONSchema {
+    type: string;
+    properties?: Record<string, unknown>;
+    required?: string[];
+    items?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * LLM Client abstraction - user provides their own implementation
+ * This allows flexibility with different LLM providers without direct dependencies
+ */
+interface LLMClient {
+    /**
+     * Create a structured completion from the LLM
+     * Must validate and return only valid JSON matching the schema
+     */
+    createCompletion(input: {
+        model: string;
+        messages: {
+            role: "system" | "user";
+            content: string;
+        }[];
+        max_tokens: number;
+        response_format: JSONSchema;
+    }): Promise<{
+        content: unknown;
+        usage?: {
+            prompt_tokens?: number;
+            completion_tokens?: number;
+            total_tokens?: number;
+        };
+    }>;
+}
+/**
+ * LLM budget configuration - prevents runaway spending
+ */
+interface LLMBudget {
+    maxCalls: number;
+    maxTokensPerCall: number;
+    maxTotalTokens: number;
+}
+/**
+ * Feature toggles for LLM capabilities
+ */
+interface LLMFeatures {
+    skillNormalization?: boolean;
+    sectionClassification?: boolean;
+    suggestions?: boolean;
+}
+/**
+ * Complete LLM configuration
+ */
+interface LLMConfig {
+    /** User-provided LLM client (e.g., OpenAI wrapper) */
+    client: LLMClient;
+    /** Model identifiers */
+    models?: {
+        /** Default model for fast, structured output (e.g., "gpt-4o-mini") */
+        default: string;
+        /** Optional thinking model for complex reasoning (e.g., "o4-mini") */
+        thinking?: string;
+    };
+    /** Budget constraints */
+    limits: LLMBudget;
+    /** Which LLM features to enable */
+    enable?: LLMFeatures;
+    /** Request timeout in milliseconds */
+    timeoutMs?: number;
+}
+/**
+ * Updated AnalyzeResumeInput with optional LLM support
+ */
+interface AnalyzeResumeInputV2 {
+    resumeText: string;
+    jobDescription: string;
+    config?: ATSConfig;
+    llm?: LLMConfig;
+}
+/**
+ * LLM usage tracking for debugging
+ */
+interface LLMUsageStats {
+    totalCalls: number;
+    totalTokensUsed: number;
+    callsRemaining: number;
+    tokensRemaining: number;
+    features: Partial<Record<keyof LLMFeatures, boolean>>;
+}
+/**
+ * Result of an LLM operation (with fallback info)
+ */
+interface LLMResult<T> {
+    success: boolean;
+    data?: T;
+    fallback: boolean;
+    error?: string;
+    tokensUsed?: number;
+}
+
+interface ATSBreakdown {
+    skills: number;
+    experience: number;
+    keywords: number;
+    education: number;
+}
+interface AnalyzeResumeInput {
+    resumeText: string;
+    jobDescription: string;
+    config?: ATSConfig;
+    llm?: LLMConfig;
+}
+interface KeywordWeight {
+    term: string;
+    category: KeywordCategory;
+    /** Importance of this term in the job description (location + frequency based). */
+    jdWeight: number;
+    /** How often this term appears in the resume. */
+    resumeWeight: number;
+    /** Alias of jdWeight — how much this term matters for the role. */
+    importance: number;
+}
+interface ATSAnalysisResult {
+    score: number;
+    breakdown: ATSBreakdown;
+    /** Skills found in the resume that satisfy JD + profile requirements. */
+    matchedSkills: string[];
+    /** Required skills absent from the resume. */
+    missingSkills: string[];
+    matchedKeywords: string[];
+    missingKeywords: string[];
+    overusedKeywords: string[];
+    /** Matched/missing keywords grouped by category (technical, tool, concept, soft, marketing, domain). */
+    keywordsByCategory: Record<KeywordCategory, {
+        matched: string[];
+        missing: string[];
+    }>;
+    /** Per-keyword JD importance and resume usage, for callers who want the raw numbers. */
+    keywordWeights: KeywordWeight[];
+    /** Count of resume achievement bullets classified as strong vs weak. */
+    achievementStrength: {
+        strong: number;
+        weak: number;
+    };
+    /** JD-required languages the resume meets or exceeds in proficiency. */
+    matchedLanguages: ParsedLanguage[];
+    /** JD-required languages absent from the resume, or below the required proficiency. */
+    missingLanguages: ParsedLanguage[];
+    suggestions: string[];
+    warnings: string[];
+    /** Years below the JD's minimum experience requirement; 0 when the requirement is met. */
+    experienceGap: number;
+    /** Resume sections the parser successfully detected (e.g. "summary", "skills"). */
+    detectedSections: string[];
+    /** Total years of experience parsed from the resume's date ranges. */
+    parsedExperienceYears: number;
+    /** Parsed experience entries from the resume, with titles and date ranges. */
+    experienceEntries: ParsedExperienceEntry[];
+}
+
+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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pranavraut033/ats-checker",
-  "version": "1.2.0",
+  "version": "1.3.2",
   "description": "Deterministic, configurable ATS (Applicant Tracking System) compatibility checker with no external dependencies. Analyze resumes, generate scores, and get actionable suggestions.",
   "license": "MIT",
   "author": {
@@ -40,6 +40,18 @@
       "import": "./dist/pdf/index.mjs",
       "require": "./dist/pdf/index.cjs",
       "default": "./dist/pdf/index.mjs"
+    },
+    "./en": {
+      "types": "./dist/lang/en/index.d.ts",
+      "import": "./dist/lang/en/index.mjs",
+      "require": "./dist/lang/en/index.cjs",
+      "default": "./dist/lang/en/index.mjs"
+    },
+    "./de": {
+      "types": "./dist/lang/de/index.d.ts",
+      "import": "./dist/lang/de/index.mjs",
+      "require": "./dist/lang/de/index.cjs",
+      "default": "./dist/lang/de/index.mjs"
     }
   },
   "peerDependencies": {