@odda-ai/matching-core 1.0.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@odda-ai/matching-core",
+  "version": "1.0.0",
+  "description": "Core AI provider library with support for OpenAI, Ollama, and Anthropic",
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "files": [
+    "src",
+    "index.js",
+    "index.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.13.4",
+    "pdf-parse": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "@types/pdf-parse": "^1.1.4"
+  }
+}

package/src/ai/AIProvider.ts

@@ -0,0 +1,159 @@
+import axios, { AxiosError, type AxiosInstance } from "axios";
+import type {
+  AIAdapter,
+  BaseAIConfig,
+  ChatMessage,
+  AIResponse,
+} from "./types.js";
+import { AI_ADAPTERS } from "./registry.js";
+
+/**
+ * Classe generica per interrogare qualsiasi provider AI
+ */
+export class AIProvider {
+  private config: BaseAIConfig;
+  private client: AxiosInstance;
+  private adapter: AIAdapter;
+
+  constructor(
+    config: BaseAIConfig,
+    adapter: AIAdapter | keyof typeof AI_ADAPTERS,
+  ) {
+    this.config = {
+      temperature: 0.7,
+      maxTokens: 1000,
+      timeout: 300000,
+      ...config,
+    };
+
+    // Determina l'adapter da usare
+    if (!adapter) {
+      throw new Error("È necessario specificare un adapter");
+    }
+
+    if (typeof adapter === "string") {
+      const registeredAdapter = AI_ADAPTERS[adapter];
+      if (!registeredAdapter) {
+        throw new Error(`Adapter non trovato: ${adapter}`);
+      }
+      this.adapter = registeredAdapter;
+    } else {
+      this.adapter = adapter;
+    }
+
+    // Configura il client HTTP
+    this.client = this.createClient();
+  }
+
+  private createClient(): AxiosInstance {
+    const headers = {
+      ...this.adapter.configureHeaders?.(this.config),
+      ...this.config.headers,
+    };
+
+    const axiosConfig: any = {
+      baseURL: this.config.baseURL,
+      headers,
+    };
+
+    if (this.config.timeout !== undefined) {
+      axiosConfig.timeout = this.config.timeout;
+    }
+
+    return axios.create(axiosConfig);
+  }
+
+  /**
+   * Invia una chat completion al provider AI
+   */
+  async chat(messages: ChatMessage[]): Promise<AIResponse> {
+    try {
+      const { endpoint, body } = this.adapter.transformRequest(
+        messages,
+        this.config,
+      );
+      const response = await this.client.post(endpoint, body);
+
+      return this.adapter.transformResponse(response);
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        const errorMessage =
+          error.response?.data?.error?.message ||
+          error.response?.data?.message ||
+          error.message;
+
+         const axiosError = new Error(`Errore nella richiesta AI: ${errorMessage}`);
+         axiosError.name = "AIProviderError";
+         (axiosError as any).status = error.response?.status;
+         (axiosError as any).data = error.response?.data;
+         throw axiosError;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Invia un singolo prompt al provider AI
+   */
+  async prompt(prompt: string, systemMessage?: string): Promise<AIResponse> {
+    const messages: ChatMessage[] = [];
+
+    if (systemMessage) {
+      messages.push({
+        role: "system",
+        content: systemMessage,
+      });
+    }
+
+    messages.push({
+      role: "user",
+      content: prompt,
+    });
+
+    return this.chat(messages);
+  }
+
+  /**
+   * Aggiorna la configurazione del provider
+   */
+  updateConfig(config: Partial<BaseAIConfig>): void {
+    this.config = { ...this.config, ...config };
+
+    // Ricrea il client se la configurazione HTTP è cambiata
+    if (config.baseURL || config.apiKey || config.headers || config.timeout) {
+      this.client = this.createClient();
+    }
+  }
+
+  /**
+   * Ottiene la configurazione corrente
+   */
+  getConfig(): BaseAIConfig {
+    return { ...this.config };
+  }
+
+  /**
+   * Ottiene l'adapter corrente
+   */
+  getAdapter(): AIAdapter {
+    return this.adapter;
+  }
+
+  /**
+   * Cambia l'adapter mantenendo la stessa configurazione
+   */
+  setAdapter(adapter: AIAdapter | keyof typeof AI_ADAPTERS): void {
+    if (typeof adapter === "string") {
+      const registeredAdapter = AI_ADAPTERS[adapter];
+      if (!registeredAdapter) {
+        throw new Error(`Adapter non trovato: ${adapter}`);
+      }
+      this.adapter = registeredAdapter;
+    } else {
+      this.adapter = adapter;
+    }
+
+    // Ricrea il client con i nuovi header dell'adapter
+    this.client = this.createClient();
+  }
+}

package/src/ai/adapters/AnthropicAdapter.ts

@@ -0,0 +1,42 @@
+import type { AIAdapter, ChatMessage, BaseAIConfig, AIResponse } from '../types.js';
+
+/**
+ * Adapter per Anthropic Claude
+ */
+export class AnthropicAdapter implements AIAdapter {
+  transformRequest(messages: ChatMessage[], config: BaseAIConfig) {
+    return {
+      endpoint: '/v1/messages',
+      body: {
+        model: config.model,
+        messages: messages.filter(m => m.role !== 'system'),
+        system: messages.find(m => m.role === 'system')?.content,
+        max_tokens: config.maxTokens || 1024,
+        temperature: config.temperature,
+        ...config.additionalParams
+      }
+    };
+  }
+
+  transformResponse(response: any): AIResponse {
+    const data = response.data;
+    return {
+      content: data.content?.[0]?.text || '',
+      model: data.model,
+      usage: data.usage ? {
+        promptTokens: data.usage.input_tokens,
+        completionTokens: data.usage.output_tokens,
+        totalTokens: data.usage.input_tokens + data.usage.output_tokens
+      } : undefined,
+      raw: data
+    };
+  }
+
+  configureHeaders(config: BaseAIConfig): Record<string, string> {
+    return {
+      'Content-Type': 'application/json',
+      'x-api-key': config.apiKey || '',
+      'anthropic-version': '2023-06-01'
+    };
+  }
+}

package/src/ai/adapters/OllamaAdapter.ts

@@ -0,0 +1,42 @@
+import type { AIAdapter, ChatMessage, BaseAIConfig, AIResponse } from '../types.js';
+
+/**
+ * Adapter per Ollama
+ */
+export class OllamaAdapter implements AIAdapter {
+  transformRequest(messages: ChatMessage[], config: BaseAIConfig) {
+    return {
+      endpoint: '/chat',
+      body: {
+        model: config.model,
+        messages,
+        stream: false,
+        options: {
+          temperature: config.temperature,
+          num_predict: config.maxTokens,
+          ...config.additionalParams
+        }
+      }
+    };
+  }
+
+  transformResponse(response: any): AIResponse {
+    const data = response.data;
+    return {
+      content: data.message?.content || '',
+      model: data.model,
+      usage: data.prompt_eval_count && data.eval_count ? {
+        promptTokens: data.prompt_eval_count,
+        completionTokens: data.eval_count,
+        totalTokens: data.prompt_eval_count + data.eval_count
+      } : undefined,
+      raw: data
+    };
+  }
+
+  configureHeaders(): Record<string, string> {
+    return {
+      'Content-Type': 'application/json'
+    };
+  }
+}

package/src/ai/adapters/OpenAIAdapter.ts

@@ -0,0 +1,53 @@
+import type { AIAdapter, ChatMessage, BaseAIConfig, AIResponse } from '../types.js';
+
+/**
+ * Adapter per OpenAI e provider compatibili (Azure OpenAI, ecc.)
+ */
+export class OpenAIAdapter implements AIAdapter {
+  transformRequest(messages: ChatMessage[], config: BaseAIConfig) {
+    const body: any = {
+      model: config.model,
+      messages,
+      // temperature: config.temperature,
+      // ...config.additionalParams
+    };
+
+    // Usa max_completion_tokens per i nuovi modelli, max_tokens per i vecchi
+    // if (config.maxTokens) {
+    //   if (config.model?.includes('gpt-4') || config.model?.includes('gpt-5')) {
+    //     body.max_completion_tokens = config.maxTokens;
+    //   } else {
+    //     body.max_tokens = config.maxTokens;
+    //   }
+    // }
+
+    return {
+      endpoint: '/chat/completions',
+      body
+    };
+  }
+
+  transformResponse(response: any): AIResponse {
+    const data = response.data;
+    return {
+      content: data.choices?.[0]?.message?.content || '',
+      model: data.model,
+      usage: data.usage ? {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens
+      } : undefined,
+      raw: data
+    };
+  }
+
+  configureHeaders(config: BaseAIConfig): Record<string, string> {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json'
+    };
+    if (config.apiKey) {
+      headers['Authorization'] = `Bearer ${config.apiKey}`;
+    }
+    return headers;
+  }
+}

package/src/ai/adapters/index.ts

@@ -0,0 +1,3 @@
+export { OpenAIAdapter } from './OpenAIAdapter.js';
+export { OllamaAdapter } from './OllamaAdapter.js';
+export { AnthropicAdapter } from './AnthropicAdapter.js';

package/src/ai/factory.ts

@@ -0,0 +1,48 @@
+import { AIProvider } from './AIProvider.js';
+import type { BaseAIConfig, AIAdapter } from './types.js';
+
+/**
+ * Factory helper per creare provider comuni
+ */
+export const createAIProvider = {
+  openai: (apiKey: string, model = 'gpt-4', config?: Partial<BaseAIConfig>) =>
+    new AIProvider({
+      baseURL: 'https://api.openai.com/v1',
+      apiKey,
+      model,
+      ...config
+    }, 'openai'),
+
+  ollama: (model = 'llama2', baseURL = 'http://localhost:11434/api', config?: Partial<BaseAIConfig>) =>
+    new AIProvider({
+      baseURL,
+      model,
+      ...config
+    }, 'ollama'),
+
+  anthropic: (apiKey: string, model = 'claude-3-5-sonnet-20241022', config?: Partial<BaseAIConfig>) =>
+    new AIProvider({
+      baseURL: 'https://api.anthropic.com',
+      apiKey,
+      model,
+      ...config
+    }, 'anthropic'),
+
+  azureOpenAI: (apiKey: string, endpoint: string, deployment: string, config?: Partial<BaseAIConfig>) =>
+    new AIProvider({
+      baseURL: `${endpoint}/openai/deployments/${deployment}`,
+      apiKey,
+      model: deployment,
+      headers: {
+        'api-key': apiKey
+      },
+      ...config
+    }, 'azure'),
+
+  custom: (baseURL: string, adapter: AIAdapter, config?: Partial<BaseAIConfig>) =>
+    new AIProvider({
+      baseURL,
+      model: config?.model || 'default',
+      ...config
+    }, adapter)
+};

package/src/ai/index.ts

@@ -0,0 +1,5 @@
+export { AIProvider } from './AIProvider.js';
+export { createAIProvider } from './factory.js';
+export { AI_ADAPTERS } from './registry.js';
+export * from './types.js';
+export * from './adapters/index.js';

package/src/ai/registry.ts

@@ -0,0 +1,15 @@
+import { OpenAIAdapter } from './adapters/OpenAIAdapter.js';
+import { OllamaAdapter } from './adapters/OllamaAdapter.js';
+import { AnthropicAdapter } from './adapters/AnthropicAdapter.js';
+
+/**
+ * Registry degli adapter disponibili
+ */
+export const AI_ADAPTERS = {
+  openai: new OpenAIAdapter(),
+  ollama: new OllamaAdapter(),
+  anthropic: new AnthropicAdapter(),
+  // Alias per compatibilità
+  azure: new OpenAIAdapter(),
+  'azure-openai': new OpenAIAdapter()
+} as const;

package/src/ai/types.ts

@@ -0,0 +1,59 @@
+/**
+ * Messaggio nel formato chat
+ */
+export interface ChatMessage {
+  role: string;
+  content: string;
+  name?: string;
+}
+
+/**
+ * Risposta dall'AI
+ */
+export interface AIResponse {
+  content: string;
+  model?: string;
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  } | undefined;
+  raw?: any;
+}
+
+/**
+ * Configurazione base per il provider AI
+ */
+export interface BaseAIConfig {
+  baseURL: string;
+  model: string;
+  apiKey?: string;
+  headers?: Record<string, string>;
+  temperature?: number;
+  maxTokens?: number;
+  timeout?: number;
+  [key: string]: any;
+}
+
+/**
+ * Adapter per trasformare richieste e risposte per provider specifici
+ */
+export interface AIAdapter {
+  /**
+   * Trasforma i messaggi nel formato richiesto dal provider
+   */
+  transformRequest(messages: ChatMessage[], config: BaseAIConfig): {
+    endpoint: string;
+    body: any;
+  };
+
+  /**
+   * Trasforma la risposta del provider nel formato standard
+   */
+  transformResponse(response: any): AIResponse;
+
+  /**
+   * Configura gli header HTTP specifici del provider
+   */
+  configureHeaders?(config: BaseAIConfig): Record<string, string>;
+}

package/src/cv-parser/PDFParserService.ts

@@ -0,0 +1,160 @@
+import * as fs from 'fs';
+import pdfParse from 'pdf-parse';
+import type { PDFExtractionOptions, PDFExtractionResult } from './types.js';
+
+/**
+ * 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: string | Buffer,
+    options: PDFExtractionOptions = {}
+  ): Promise<PDFExtractionResult> {
+    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: string[] = [];
+      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: (string | Buffer)[],
+    options: PDFExtractionOptions = {}
+  ): Promise<PDFExtractionResult[]> {
+    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: string | Buffer): Promise<boolean> {
+    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
+   */
+  private createPageRenderer(options: PDFExtractionOptions) {
+    if (!options.preserveFormatting) {
+      return undefined;
+    }
+
+    return (pageData: any) => {
+      return pageData.getTextContent().then((textContent: any) => {
+        let lastY: number | null = 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
+   */
+  private extractMetadata(info: any): PDFExtractionResult['metadata'] {
+    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: string | Buffer,
+    pageNumber: number
+  ): Promise<string> {
+    const result = await this.extractText(pdfPath, {
+      startPage: pageNumber,
+      endPage: pageNumber
+    });
+    return result.text;
+  }
+}
+
+/**
+ * Istanza singleton del parser
+ */
+export const pdfParser = new PDFParserService();

package/src/cv-parser/index.ts

@@ -0,0 +1,2 @@
+export { PDFParserService, pdfParser } from './PDFParserService.js';
+export type { PDFExtractionOptions, PDFExtractionResult } from './types.js';

package/src/cv-parser/types.ts

@@ -0,0 +1,58 @@
+/**
+ * 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;
+}