Update prompt and scoring logic

Author: HerobrineXia

hire-shark/prompts/data_connectors_and_models.md

@@ -41,16 +41,12 @@ This reference summarizes every external connector and model configuration that
 
 ## 3. JD Skill Extraction Flow
 - **Used for:** Building the JD skill list that powers match scoring (`hire-shark/src/lib/skillExtractor.ts`).
-- **Inputs:** Job title, sanitized Adzuna description (up to ~2.5k chars) and any keywords returned by the API.
-- **LLM layer (optional):**
+- **Inputs:** Job title, sanitized Adzuna description (up to ~3.5k chars) and any keywords returned by the API.
+- **LLM layer (required when enabled):**
   - Model: `gemini-2.5-flash` via `@google/generative-ai`.
   - Generation config: `temperature=0`, `topK=1`, `topP=0.1` for deterministic output.
-  - Prompt: see `prompts.md` ("JD Skill Extraction").
-- **Heuristic fallback (always runs first):**
-  - Keyword seeding + dictionary lookup (`COMMON_SKILL_CANDIDATES`).
-  - Bullet/phrase parsing with strict sanitization (stop-word filtering, descriptive suffix ban, short-token whitelist).
-  - Signals (uppercase, special characters, domain vocabulary) must be present for single-word skills.
+  - Prompt: see `prompts.md` ("JD Skill Extraction"). Asks for inferred skills (implied by responsibilities), excludes location/schedule/pay/benefits, outputs JSON array of 1–4 word skill phrases.
+- **Fallback when LLM unavailable:** returns provided keywords only (no heuristic phrase parsing).
 - **Post-processing:**
-  - Merge LLM output with heuristic skills (dedupe + sanitization) only when new items pass validation.
-  - Stable ordering by first appearance in the JD text, then alphabetically.
+  - Sanitization + deduping of LLM output; stable ordering by first appearance in the JD text, then alphabetically.
   - In-memory cache keyed by title/description/keywords/limit so repeated matches reuse the same list.

hire-shark/prompts/prompts.md

@@ -64,10 +64,10 @@ ${JSON.stringify(editedResume.parsed, null, 2)}
 
 ## JD Skill Extraction (hire-shark/src/lib/skillExtractor.ts)
 ```
-You are identifying the most important skills required for a job posting.
-- Read the provided job title and description.
-- Return ONLY a JSON array (no additional commentary) listing up to ${limit} unique skill phrases.
-- Each skill should be 1-4 words, concrete, and deduplicated (e.g., "React", "Stakeholder Management", "AWS Cloud").
+You extract the most important skills a candidate needs for this job. Infer required skills even if only implied by responsibilities.
+- Focus on technologies, tools, frameworks, domain skills, certifications, and relevant soft skills.
+- Exclude locations, schedules (hours/week), pay/benefits, employment type, headcount, and generic nouns.
+- Return ONLY a JSON array (no commentary) of up to ${limit} unique skill phrases, each 1-4 words, title-cased when appropriate.
 
 Job Title: ${title || "(missing)"}
 
@@ -78,4 +78,4 @@ Existing keywords: ${keywords.length ? keywords.join(", ") : "none"}
 ```
 Notes:
 - Called with `temperature: 0`, `topK: 1`, `topP: 0.1` for deterministic output.
-- Response is merged with the heuristic fallback list only when new skills are returned.
+- LLM-only: no heuristic fallback; if Gemini unavailable, it falls back to provided keywords.

hire-shark/src/lib/gemini_parser.ts

@@ -197,11 +197,14 @@ export async function parseResumeWithGemini(file: File): Promise<ResumeParsed> {
           }
         }
         
-        Important: Extract all education entries including degrees, certifications, and educational qualifications. 
-        Include the degree type (e.g., Bachelor's, Master's, PhD), field of study, institution name, location, dates, GPA (if available), and any honors or distinctions.
-        If you cannot find any information for a field, leave it as an empty string or an empty array.
-        If the uploaded file is not a resume, try your best and you should still return a JSON object.
-        When nothing is found for a section, The confidence for that section should be low.
+        Important:
+        - Skills must be exhaustive: include hard skills, tools, frameworks, domains, certifications, and relevant soft skills.
+        - Infer skills from projects/responsibilities even if not in a "Skills" section.
+        - Include common aliases where helpful (e.g., ["C++", "C Plus Plus"]), keep items 1-4 words, deduplicated and normalized.
+        - Extract all education entries including degrees, certifications, and educational qualifications with degree, field, institution, location, dates, GPA (if available), and honors.
+        - If you cannot find any information for a field, leave it as an empty string or an empty array.
+        - If the uploaded file is not a resume, try your best and you should still return a JSON object.
+        - When nothing is found for a section, the confidence for that section should be low.
       `;
 
     const generativePart = await buildGenerativePart(file);

hire-shark/src/lib/jobMatcher.ts

@@ -2,7 +2,7 @@ import type { ResumeParsed, MatchResult, JobPreferences } from "../types";
 import { fetchAdzunaJobs } from "./adzunaApi";
 import { extractJobSkills } from "./skillExtractor";
 
-const MATCH_THRESHOLD = 0.75;
+const MATCH_THRESHOLD = 0.5;
 const MAX_SKILL_BADGES = 10;
 
 type SkillVector = {
@@ -57,7 +57,7 @@ export async function matchJobs(resume: ResumeParsed, preferences: JobPreference
   const embeddingEngine = skillCorpus.length ? await buildSkillEmbeddingEngine(skillCorpus) : null;
   const vectorCache = new Map<string, number[]>();
   const getVector = (text: string): number[] => {
-    const key = text.toLowerCase();
+    const key = normalizeSkill(text);
     if (vectorCache.has(key)) {
       return vectorCache.get(key)!;
     }
@@ -84,12 +84,14 @@ export async function matchJobs(resume: ResumeParsed, preferences: JobPreference
 
     const matchedSkills: string[] = [];
     const missingSkills: string[] = [];
+    let coverageSum = 0;
 
     for (const jobSkill of jobSkillVectors) {
       if (!jobSkill.normalized) continue;
 
       if (resumeSkillMap.has(jobSkill.normalized)) {
         matchedSkills.push(jobSkill.raw);
+        coverageSum += 1;
         continue;
       }
 
@@ -104,17 +106,19 @@ export async function matchJobs(resume: ResumeParsed, preferences: JobPreference
         }
       }
 
+      const contribution = Math.max(0, Math.min(1, bestScore));
+      coverageSum += contribution;
       if (bestScore >= MATCH_THRESHOLD) {
         matchedSkills.push(jobSkill.raw);
-      } else {
+      } else if (contribution < 1) {
         missingSkills.push(jobSkill.raw);
       }
     }
 
     const totalRequired = jobSkills.length;
     const matchedCount = matchedSkills.length;
     const missingCount = missingSkills.length;
-    const coverage = totalRequired ? matchedCount / totalRequired : 0;
+    const coverage = totalRequired ? coverageSum / totalRequired : 0;
 
     return {
       jobId: job.id,
@@ -140,7 +144,26 @@ export async function matchJobs(resume: ResumeParsed, preferences: JobPreference
 }
 
 function normalizeSkill(value: string): string {
-  return value.toLowerCase().replace(/\s+/g, " ").trim();
+  const lowered = (value || "")
+    .toLowerCase()
+    .replace(/[^\w\s#+/./-]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  return stemSkill(lowered);
+}
+
+function stemSkill(value: string): string {
+  let result = value;
+  result = result.replace(/\b(development|developing)\b/g, "develop");
+  result = result.replace(/\b(engineering|engineer|engineers)\b/g, "engineer");
+  result = result.replace(/\b(programming|programmer|programmers)\b/g, "program");
+  result = result.replace(/\b(designer|designers|designing)\b/g, "design");
+  result = result.replace(/\b(optimization|optimisation|optimizing)\b/g, "optimize");
+  result = result.replace(/\b(maintenance|maintaining)\b/g, "maintain");
+  result = result.replace(/\b(problem solving|problem-solving)\b/g, "problem solving");
+  // Drop simple plurals.
+  result = result.replace(/\b(\w+?)s\b/g, "$1");
+  return result.trim();
 }
 
 function dedupeSkills(list: string[]): string[] {
@@ -165,7 +188,7 @@ async function buildSkillEmbeddingEngine(corpus: string[]): Promise<SkillEmbeddi
     const adapter = await getSkipGramAdapter(corpus);
     if (adapter) {
       return {
-        vectorize: (text: string) => adapter.vectorizeText(text),
+        vectorize: (text: string) => adapter.vectorizeText(normalizeSkill(text)),
         cosine: (a: number[], b: number[]) => adapter.cosineSimilarity(a, b),
       };
     }
@@ -174,9 +197,9 @@ async function buildSkillEmbeddingEngine(corpus: string[]): Promise<SkillEmbeddi
   }
 
   const { buildVectorizer, cosineSimilarity } = await import("./embeddings");
-  const vectorizer = buildVectorizer(corpus);
+  const vectorizer = buildVectorizer(corpus.map(normalizeSkill));
   return {
-    vectorize: (text: string) => vectorizer.vectorize(text),
+    vectorize: (text: string) => vectorizer.vectorize(normalizeSkill(text)),
     cosine: (a: number[], b: number[]) => cosineSimilarity(a, b),
   };
 }

hire-shark/src/lib/skillExtractor.ts

@@ -1,6 +1,6 @@
 import { hasGeminiApiKeyConfigured, runWithGeminiModel } from "./gemini_parser";
 
-const DEFAULT_SKILL_LIMIT = 12;
+const DEFAULT_SKILL_LIMIT = 10;
 const COMMON_SKILL_CANDIDATES = [
   "python",
   "java",
@@ -184,9 +184,8 @@ type ExtractJobSkillsInput = {
 
 /**
  * Extracts a concise set of skills required for a job posting.
- * 1. Deterministic fallback extraction (keyword + heuristic parsing).
- * 2. Optional Gemini enrichment with low-temperature settings.
- * 3. Stable ordering + caching guarded by a hash of the JD content.
+ * Uses Gemini (deterministic settings) only; no heuristic fallback parsing.
+ * Stable ordering + caching guarded by a hash of the JD content.
  */
 export async function extractJobSkills(input: ExtractJobSkillsInput): Promise<string[]> {
   const {
@@ -196,7 +195,7 @@ export async function extractJobSkills(input: ExtractJobSkillsInput): Promise<st
     limit = DEFAULT_SKILL_LIMIT,
   } = input;
 
-  const cleanDescription = stripHtml(description).slice(0, 2500);
+  const cleanDescription = stripHtml(description).slice(0, 3500);
   const keywordHints = keywords.filter(Boolean);
   if (!cleanDescription.trim() && !title.trim() && !keywordHints.length) {
     return [];
@@ -207,20 +206,13 @@ export async function extractJobSkills(input: ExtractJobSkillsInput): Promise<st
     return SKILL_CACHE.get(cacheKey)!;
   }
 
-  const fallbackSkills = fallbackSkillExtraction({
-    title,
-    description: cleanDescription,
-    keywords: keywordHints,
-    limit: Math.max(limit, DEFAULT_SKILL_LIMIT),
-  });
-
   const shouldUseGemini = !GEMINI_DISABLED && hasGeminiApiKeyConfigured();
-  let mergedSkills = fallbackSkills;
+  let rawSkills: string[] = [];
 
   if (shouldUseGemini) {
     try {
       const prompt = buildPrompt({ title, description: cleanDescription, keywords: keywordHints, limit });
-      const parsed = await runWithGeminiModel(
+      rawSkills = await runWithGeminiModel(
         async model => {
           const result = await model.generateContent(prompt);
           const response = await result.response;
@@ -236,27 +228,32 @@ export async function extractJobSkills(input: ExtractJobSkillsInput): Promise<st
           },
         },
       );
-
-      if (parsed.length) {
-        mergedSkills = mergeSkillLists(fallbackSkills, parsed);
-      }
     } catch (error) {
-      console.warn("Gemini skill extraction failed, using fallback skills.", error);
+      console.warn("Gemini skill extraction failed, returning keywords only.", error);
+      rawSkills = [];
     }
+  } else {
+    console.warn("Gemini disabled or not configured; returning keywords only.");
   }
 
-  const finalSkills = finalizeSkillList(mergedSkills, cleanDescription, limit);
+  // If LLM unavailable or empty, at least return any provided keywords.
+  if (!rawSkills.length && keywordHints.length) {
+    rawSkills = keywordHints;
+  }
+
+  const finalSkills = finalizeSkillList(rawSkills, cleanDescription, limit);
   SKILL_CACHE.set(cacheKey, finalSkills);
   return finalSkills;
 }
 
 function buildPrompt(args: { title: string; description: string; keywords: string[]; limit: number }): string {
   const { title, description, keywords, limit } = args;
   return `
-You are identifying the most important skills required for a job posting.
-- Read the provided job title and description.
-- Return ONLY a JSON array (no additional commentary) listing up to ${limit} unique skill phrases.
-- Each skill should be 1-4 words, concrete, and deduplicated (e.g., "React", "Stakeholder Management", "AWS Cloud").
+You extract the most important skills a candidate needs for this job. Infer required skills even if only implied by responsibilities.
+- Focus on technologies, tools, frameworks, domain skills, certifications, and relevant soft skills.
+- Exclude locations, schedules (hours/week), pay/benefits, employment type, headcount, and generic nouns.
+- Return ONLY a JSON array (no commentary) of up to ${limit} unique skill phrases, each 1-4 words, title-cased when appropriate.
+- Prioritize the top ${limit} most critical skills; avoid long tail/overly specific variants.
 
 Job Title: ${title || "(missing)"}
 
@@ -282,67 +279,11 @@ function parseSkillArray(payload: string): string[] {
   return [];
 }
 
-function fallbackSkillExtraction(args: { title: string; description: string; keywords: string[]; limit: number }): string[] {
-  const { title, description, keywords, limit } = args;
-  const haystack = `${title}\n${description}`.toLowerCase();
-
-  const addSkill = (acc: string[], value?: string) => {
-    const sanitized = sanitizeSkill(value);
-    if (!sanitized) return;
-    if (acc.some(skill => skill.toLowerCase() === sanitized.toLowerCase())) return;
-    acc.push(sanitized);
-  };
-
-  const collected: string[] = [];
-  for (const keyword of keywords) {
-    if (collected.length >= limit) break;
-    addSkill(collected, keyword);
-  }
-
-  for (const candidate of COMMON_SKILL_CANDIDATES) {
-    if (collected.length >= limit) break;
-    if (haystack.includes(candidate)) {
-      addSkill(collected, candidate);
-    }
-  }
-
-  if (collected.length < limit) {
-    const quickPhrases = description
-      .split(/[\n,;•\.]/)
-      .map(chunk => chunk.trim())
-      .filter(chunk => chunk && chunk.length <= 40 && chunk.split(/\s+/).length <= 4);
-    for (const phrase of quickPhrases) {
-      if (collected.length >= limit) break;
-      addSkill(collected, phrase);
-    }
-  }
-
-  if (!collected.length && title) {
-    addSkill(collected, title);
-  }
-
-  return collected.slice(0, limit);
-}
-
 function stripHtml(value?: string): string {
   if (!value) return "";
   return value.replace(/<[^>]+>/g, " ");
 }
 
-function mergeSkillLists(base: string[], extras: string[]): string[] {
-  const seen = new Set(base.map(s => s.toLowerCase()));
-  const result = [...base];
-  for (const skill of extras) {
-    const sanitized = sanitizeSkill(skill);
-    if (!sanitized) continue;
-    const normalized = sanitized.toLowerCase();
-    if (seen.has(normalized)) continue;
-    seen.add(normalized);
-    result.push(sanitized);
-  }
-  return result;
-}
-
 function finalizeSkillList(skills: string[], description: string, limit: number): string[] {
   const deduped = dedupeSkills(skills);
   const loweredDescription = description.toLowerCase();