@odda-ai/matching-core 1.0.0 → 1.0.2

package/dist/src/cv-parser/PDFParserService.js

@@ -0,0 +1,136 @@
+import * as fs from 'fs';
+import pdfParse from 'pdf-parse';
+/**
+ * Servizio per estrarre testo dai file PDF
+ */
+export class PDFParserService {
+    /**
+     * Estrae il testo da un file PDF
+     * @param pdfPath Percorso del file PDF o Buffer
+     * @param options Opzioni di estrazione
+     */
+    async extractText(pdfPath, options = {}) {
+        try {
+            // Leggi il file se è un percorso
+            const dataBuffer = typeof pdfPath === 'string'
+                ? await fs.promises.readFile(pdfPath)
+                : pdfPath;
+            // Estrai il testo usando pdf-parse
+            const pdfData = await pdfParse(dataBuffer, {
+                max: options.endPage,
+                pagerender: this.createPageRenderer(options)
+            });
+            // Estrai testo per pagina se richiesto
+            const pageTexts = [];
+            if (options.startPage || options.endPage) {
+                const start = options.startPage || 1;
+                const end = options.endPage || pdfData.numpages;
+                for (let i = start; i <= end && i <= pdfData.numpages; i++) {
+                    const pageData = await pdfParse(dataBuffer, {
+                        max: i,
+                        pagerender: this.createPageRenderer(options)
+                    });
+                    pageTexts.push(pageData.text);
+                }
+            }
+            // Applica il range di pagine se specificato
+            let text = pdfData.text;
+            if (options.startPage || options.endPage) {
+                const lines = text.split('\n');
+                const start = options.startPage ? (options.startPage - 1) : 0;
+                const end = options.endPage;
+                text = lines.slice(start, end).join(options.pageSeparator || '\n');
+            }
+            return {
+                text: text.trim(),
+                totalPages: pdfData.numpages,
+                pageTexts: pageTexts.length > 0 ? pageTexts : undefined,
+                metadata: this.extractMetadata(pdfData.info)
+            };
+        }
+        catch (error) {
+            throw new Error(`Errore nell'estrazione del testo dal PDF: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Estrae il testo da più PDF contemporaneamente
+     * @param pdfPaths Array di percorsi PDF
+     * @param options Opzioni di estrazione
+     */
+    async extractTextFromMultiple(pdfPaths, options = {}) {
+        const promises = pdfPaths.map(path => this.extractText(path, options));
+        return Promise.all(promises);
+    }
+    /**
+     * Verifica se un file è un PDF valido
+     * @param pdfPath Percorso del file PDF o Buffer
+     */
+    async isValidPDF(pdfPath) {
+        try {
+            const dataBuffer = typeof pdfPath === 'string'
+                ? await fs.promises.readFile(pdfPath)
+                : pdfPath;
+            // Verifica il magic number del PDF (%PDF)
+            const header = dataBuffer.slice(0, 5).toString();
+            return header === '%PDF-';
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Crea un renderer personalizzato per le pagine
+     */
+    createPageRenderer(options) {
+        if (!options.preserveFormatting) {
+            return undefined;
+        }
+        return (pageData) => {
+            return pageData.getTextContent().then((textContent) => {
+                let lastY = null;
+                let text = '';
+                for (const item of textContent.items) {
+                    if (lastY !== null && lastY !== item.transform[5]) {
+                        text += '\n';
+                    }
+                    text += item.str;
+                    lastY = item.transform[5];
+                }
+                return text;
+            });
+        };
+    }
+    /**
+     * Estrae i metadati dal PDF
+     */
+    extractMetadata(info) {
+        if (!info)
+            return undefined;
+        return {
+            title: info.Title,
+            author: info.Author,
+            subject: info.Subject,
+            keywords: info.Keywords,
+            creator: info.Creator,
+            producer: info.Producer,
+            creationDate: info.CreationDate ? new Date(info.CreationDate) : undefined,
+            modificationDate: info.ModDate ? new Date(info.ModDate) : undefined
+        };
+    }
+    /**
+     * Estrae solo testo da una specifica pagina
+     * @param pdfPath Percorso del file PDF o Buffer
+     * @param pageNumber Numero della pagina (1-based)
+     */
+    async extractPageText(pdfPath, pageNumber) {
+        const result = await this.extractText(pdfPath, {
+            startPage: pageNumber,
+            endPage: pageNumber
+        });
+        return result.text;
+    }
+}
+/**
+ * Istanza singleton del parser
+ */
+export const pdfParser = new PDFParserService();

package/dist/src/cv-parser/index.js

@@ -0,0 +1 @@
+export { PDFParserService, pdfParser } from './PDFParserService.js';

package/dist/src/cv-parser/types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Opzioni per l'estrazione del testo dal PDF
+ */
+export interface PDFExtractionOptions {
+    /**
+     * Numero di pagina da cui iniziare l'estrazione (1-based)
+     */
+    startPage?: number;
+    /**
+     * Numero di pagina fino a cui estrarre (1-based)
+     */
+    endPage?: number;
+    /**
+     * Se true, preserva la formattazione e gli spazi
+     */
+    preserveFormatting?: boolean;
+    /**
+     * Separatore tra le pagine
+     */
+    pageSeparator?: string;
+}
+/**
+ * Risultato dell'estrazione del testo
+ */
+export interface PDFExtractionResult {
+    /**
+     * Testo estratto dal PDF
+     */
+    text: string;
+    /**
+     * Numero totale di pagine nel documento
+     */
+    totalPages: number;
+    /**
+     * Testo estratto per ogni pagina
+     */
+    pageTexts?: string[] | undefined;
+    /**
+     * Metadati del PDF (se disponibili)
+     */
+    metadata?: {
+        title?: string;
+        author?: string;
+        subject?: string;
+        keywords?: string;
+        creator?: string;
+        producer?: string;
+        creationDate?: Date | undefined;
+        modificationDate?: Date | undefined;
+    } | undefined;
+}

package/dist/src/cv-parser/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/features/ai-cv-resume.service.d.ts

@@ -0,0 +1,14 @@
+import { AIProvider } from "../ai/index.js";
+import { type PDFExtractionOptions } from "../cv-parser/index.js";
+import { type CvAnalysisResponse } from "./types.js";
+export type AnalyzeResumeOptions = {
+    pdfoptions?: PDFExtractionOptions;
+};
+export declare class AiCvResumeService {
+    private pdfParser;
+    private ai;
+    constructor(ai: AIProvider);
+    analyzeResume(pdfBuffer: Buffer, options?: AnalyzeResumeOptions): Promise<CvAnalysisResponse>;
+    private parseAiResponse;
+    private validateSeniority;
+}

package/dist/src/features/ai-cv-resume.service.js

@@ -0,0 +1,78 @@
+import { AIProvider } from "../ai/index.js";
+import { pdfParser, } from "../cv-parser/index.js";
+import { prompts } from "./prompts.js";
+import { systemMessages } from "./system-messages.js";
+import { Seniority } from "./types.js";
+export class AiCvResumeService {
+    pdfParser = pdfParser;
+    ai;
+    constructor(ai) {
+        this.ai = ai;
+    }
+    async analyzeResume(pdfBuffer, options) {
+        const pdftext = await this.pdfParser.extractText(pdfBuffer, options?.pdfoptions);
+        const result = await this.ai.prompt(prompts.cvAnalysis(pdftext.text), systemMessages.analyzeResume());
+        return this.parseAiResponse(result.content);
+    }
+    parseAiResponse(aiResponse) {
+        try {
+            // Remove markdown code blocks if present
+            let jsonStr = aiResponse.trim();
+            // Try to extract JSON from markdown
+            const jsonMatch = jsonStr.match(/```json\s*([\s\S]*?)```/);
+            if (jsonMatch && jsonMatch[1]) {
+                jsonStr = jsonMatch[1];
+            }
+            // Remove any leading/trailing non-JSON content
+            const jsonStart = jsonStr.indexOf("{");
+            const jsonEnd = jsonStr.lastIndexOf("}");
+            if (jsonStart === -1 || jsonEnd === -1) {
+                throw new Error("No valid JSON object found in AI response");
+            }
+            jsonStr = jsonStr.substring(jsonStart, jsonEnd + 1);
+            // Parse JSON
+            const parsed = JSON.parse(jsonStr);
+            // Map to DTO structure
+            const analysis = {
+                personalInfo: {
+                    firstName: parsed.personalInfo?.firstName || "N/A",
+                    lastName: parsed.personalInfo?.lastName || "N/A",
+                    email: parsed.personalInfo?.email || undefined,
+                    phone: parsed.personalInfo?.phone || undefined,
+                    address: parsed.personalInfo?.address || undefined,
+                    dateOfBirth: parsed.personalInfo?.dateOfBirth || undefined,
+                    nationality: parsed.personalInfo?.nationality || undefined,
+                    linkedIn: parsed.personalInfo?.linkedIn || undefined,
+                    github: parsed.personalInfo?.github || undefined,
+                    website: parsed.personalInfo?.website || undefined,
+                },
+                description: parsed.description || "",
+                technicalSkills: (parsed.technicalSkills || []).map((skill) => ({
+                    name: skill.name,
+                    proficiency: Number(skill.proficiency),
+                    isInferred: Boolean(skill.isInferred),
+                    seniority: this.validateSeniority(skill.seniority),
+                })),
+                workExperienceSummary: parsed.workExperienceSummary || "",
+                certifications: (parsed.certifications || []).map((cert) => ({
+                    name: cert.name,
+                    issuer: cert.issuer || undefined,
+                    year: cert.year ? Number(cert.year) : undefined,
+                })),
+                overallSeniority: this.validateSeniority(parsed.overallSeniority),
+                yearsOfExperience: Number(parsed.yearsOfExperience) || 0,
+            };
+            return analysis;
+        }
+        catch (error) {
+            throw new Error(`Failed to parse AI response into structured format: ${error.message}`);
+        }
+    }
+    validateSeniority(value) {
+        const upperValue = value?.toUpperCase();
+        if (Object.values(Seniority).includes(upperValue)) {
+            return upperValue;
+        }
+        return Seniority.MID;
+    }
+}

package/dist/src/features/ai-talent.service.d.ts

@@ -0,0 +1,18 @@
+import { AIProvider } from "../ai/index.js";
+import { type AnalyzeResumeOptions } from "./ai-cv-resume.service.js";
+import { type ChunkingOptions } from "./cv-chunking.service.js";
+import type { CvAnalysisResponse } from "./types.js";
+export declare class AiTalentService {
+    private ai;
+    private aiCvResumeService;
+    private cvChunkingService;
+    private jobMatcherService;
+    constructor(ai: AIProvider);
+    cv: {
+        analyzeCvResume: (pdf: Buffer, options?: AnalyzeResumeOptions) => Promise<CvAnalysisResponse>;
+        chunkCvAnalysis: (cvAnalysis: CvAnalysisResponse, options?: ChunkingOptions) => Promise<import("./cv-chunking.service.js").ChunkingResult>;
+    };
+    jobs: {
+        getSkillsFromJobDescription: (jobDescription: string, skillsList: string[]) => Promise<import("./job-matcher.service.js").SkillMatch[]>;
+    };
+}

package/dist/src/features/ai-talent.service.js

@@ -0,0 +1,29 @@
+import { AIProvider } from "../ai/index.js";
+import { AiCvResumeService, } from "./ai-cv-resume.service.js";
+import { CvChunkingService, } from "./cv-chunking.service.js";
+import { JobMatcherService } from "./job-matcher.service.js";
+export class AiTalentService {
+    ai;
+    aiCvResumeService;
+    cvChunkingService;
+    jobMatcherService;
+    constructor(ai) {
+        this.ai = ai;
+        this.aiCvResumeService = new AiCvResumeService(this.ai);
+        this.cvChunkingService = new CvChunkingService();
+        this.jobMatcherService = new JobMatcherService(this.ai);
+    }
+    cv = {
+        analyzeCvResume: async (pdf, options) => {
+            return this.aiCvResumeService.analyzeResume(pdf, options);
+        },
+        chunkCvAnalysis: async (cvAnalysis, options) => {
+            return this.cvChunkingService.chunkCvAnalysis(cvAnalysis, options);
+        },
+    };
+    jobs = {
+        getSkillsFromJobDescription: async (jobDescription, skillsList) => {
+            return this.jobMatcherService.getJobSkillsFromDescription(jobDescription, skillsList);
+        },
+    };
+}

package/dist/src/features/cv-chunking.service.d.ts

@@ -0,0 +1,140 @@
+import type { CvAnalysisResponse } from './types.js';
+/**
+ * Opzioni per il chunking del CV
+ */
+export interface ChunkingOptions {
+    /**
+     * Dimensione massima di ciascun chunk in caratteri
+     * Default: 500
+     */
+    maxChunkSize?: number;
+    /**
+     * Sovrapposizione tra chunk in caratteri per mantenere il contesto
+     * Default: 50
+     */
+    overlap?: number;
+    /**
+     * Se true, include metadati nel chunk
+     * Default: true
+     */
+    includeMetadata?: boolean;
+    /**
+     * Formato del chunk
+     * Default: 'text'
+     */
+    format?: 'text' | 'json' | 'markdown';
+}
+/**
+ * Rappresenta un singolo chunk di testo con metadati
+ */
+export interface CvChunk {
+    /**
+     * ID univoco del chunk
+     */
+    id: string;
+    /**
+     * Contenuto testuale del chunk
+     */
+    content: string;
+    /**
+     * Tipo di sezione del CV
+     */
+    section: 'personal' | 'description' | 'skills' | 'experience' | 'certifications' | 'summary';
+    /**
+     * Metadati del chunk per facilitare il retrieval
+     */
+    metadata: {
+        /**
+         * Indice del chunk nella sequenza
+         */
+        index: number;
+        /**
+         * Numero totale di chunk
+         */
+        totalChunks: number;
+        /**
+         * Parole chiave estratte dal chunk
+         */
+        keywords: string[];
+        /**
+         * Seniority associata (se applicabile)
+         */
+        seniority?: string;
+        /**
+         * Anni di esperienza (se applicabile)
+         */
+        yearsOfExperience?: number;
+    };
+}
+/**
+ * Risultato del processo di chunking
+ */
+export interface ChunkingResult {
+    /**
+     * Array di chunk generati
+     */
+    chunks: CvChunk[];
+    /**
+     * Statistiche sul chunking
+     */
+    stats: {
+        totalChunks: number;
+        averageChunkSize: number;
+        totalCharacters: number;
+    };
+}
+/**
+ * Servizio per convertire CvAnalysisResponse in chunk di testo
+ * ottimizzati per embedding e retrieval
+ */
+export declare class CvChunkingService {
+    private defaultOptions;
+    /**
+     * Converte un CvAnalysisResponse in chunk ottimizzati per embedding
+     */
+    chunkCvAnalysis(cvAnalysis: CvAnalysisResponse, options?: ChunkingOptions): Promise<ChunkingResult>;
+    /**
+     * Crea un chunk con le informazioni personali
+     */
+    private createPersonalInfoChunk;
+    /**
+     * Crea chunk per le skill tecniche
+     */
+    private chunkSkills;
+    /**
+     * Crea chunk per le certificazioni
+     */
+    private chunkCertifications;
+    /**
+     * Crea un chunk di summary generale
+     */
+    private createSummaryChunk;
+    /**
+     * Suddivide un testo lungo in chunk con overlap
+     */
+    private chunkText;
+    /**
+     * Estrae parole chiave da un testo
+     */
+    private extractKeywords;
+    /**
+     * Calcola statistiche sui chunk generati
+     */
+    private calculateStats;
+    /**
+     * Converte i chunk in formato JSON per embedding
+     */
+    toEmbeddingFormat(chunks: CvChunk[]): Array<{
+        id: string;
+        text: string;
+        metadata: any;
+    }>;
+    /**
+     * Cerca chunk rilevanti per una query
+     */
+    searchChunks(chunks: CvChunk[], query: string, limit?: number): CvChunk[];
+}
+/**
+ * Istanza singleton del servizio
+ */
+export declare const cvChunkingService: CvChunkingService;