@odda-ai/matching-core 1.0.2 → 1.0.4

package/dist/cjs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './src/ai/index.js';
+export * from './src/cv-parser/index.js';
+export * from './src/features/index.js';

package/dist/cjs/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/ai/index.js"), exports);
+__exportStar(require("./src/cv-parser/index.js"), exports);
+__exportStar(require("./src/features/index.js"), exports);

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/src/ai/AIProvider.d.ts

@@ -0,0 +1,36 @@
+import type { AIAdapter, BaseAIConfig, ChatMessage, AIResponse } from "./types.js";
+import { AI_ADAPTERS } from "./registry.js";
+/**
+ * Classe generica per interrogare qualsiasi provider AI
+ */
+export declare class AIProvider {
+    private config;
+    private client;
+    private adapter;
+    constructor(config: BaseAIConfig, adapter: AIAdapter | keyof typeof AI_ADAPTERS);
+    private createClient;
+    /**
+     * Invia una chat completion al provider AI
+     */
+    chat(messages: ChatMessage[]): Promise<AIResponse>;
+    /**
+     * Invia un singolo prompt al provider AI
+     */
+    prompt(prompt: string, systemMessage?: string): Promise<AIResponse>;
+    /**
+     * Aggiorna la configurazione del provider
+     */
+    updateConfig(config: Partial<BaseAIConfig>): void;
+    /**
+     * Ottiene la configurazione corrente
+     */
+    getConfig(): BaseAIConfig;
+    /**
+     * Ottiene l'adapter corrente
+     */
+    getAdapter(): AIAdapter;
+    /**
+     * Cambia l'adapter mantenendo la stessa configurazione
+     */
+    setAdapter(adapter: AIAdapter | keyof typeof AI_ADAPTERS): void;
+}

package/dist/cjs/src/ai/AIProvider.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIProvider = void 0;
+const axios_1 = __importDefault(require("axios"));
+const registry_js_1 = require("./registry.js");
+/**
+ * Classe generica per interrogare qualsiasi provider AI
+ */
+class AIProvider {
+    config;
+    client;
+    adapter;
+    constructor(config, adapter) {
+        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 = registry_js_1.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();
+    }
+    createClient() {
+        const headers = {
+            ...this.adapter.configureHeaders?.(this.config),
+            ...this.config.headers,
+        };
+        const axiosConfig = {
+            baseURL: this.config.baseURL,
+            headers,
+        };
+        if (this.config.timeout !== undefined) {
+            axiosConfig.timeout = this.config.timeout;
+        }
+        return axios_1.default.create(axiosConfig);
+    }
+    /**
+     * Invia una chat completion al provider AI
+     */
+    async chat(messages) {
+        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_1.default.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.status = error.response?.status;
+                axiosError.data = error.response?.data;
+                throw axiosError;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Invia un singolo prompt al provider AI
+     */
+    async prompt(prompt, systemMessage) {
+        const messages = [];
+        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) {
+        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() {
+        return { ...this.config };
+    }
+    /**
+     * Ottiene l'adapter corrente
+     */
+    getAdapter() {
+        return this.adapter;
+    }
+    /**
+     * Cambia l'adapter mantenendo la stessa configurazione
+     */
+    setAdapter(adapter) {
+        if (typeof adapter === "string") {
+            const registeredAdapter = registry_js_1.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();
+    }
+}
+exports.AIProvider = AIProvider;

package/dist/cjs/src/ai/adapters/AnthropicAdapter.d.ts

@@ -0,0 +1,12 @@
+import type { AIAdapter, ChatMessage, BaseAIConfig, AIResponse } from '../types.js';
+/**
+ * Adapter per Anthropic Claude
+ */
+export declare class AnthropicAdapter implements AIAdapter {
+    transformRequest(messages: ChatMessage[], config: BaseAIConfig): {
+        endpoint: string;
+        body: any;
+    };
+    transformResponse(response: any): AIResponse;
+    configureHeaders(config: BaseAIConfig): Record<string, string>;
+}

package/dist/cjs/src/ai/adapters/AnthropicAdapter.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicAdapter = void 0;
+/**
+ * Adapter per Anthropic Claude
+ */
+class AnthropicAdapter {
+    transformRequest(messages, config) {
+        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) {
+        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) {
+        return {
+            'Content-Type': 'application/json',
+            'x-api-key': config.apiKey || '',
+            'anthropic-version': '2023-06-01'
+        };
+    }
+}
+exports.AnthropicAdapter = AnthropicAdapter;

package/dist/cjs/src/ai/adapters/OllamaAdapter.d.ts

@@ -0,0 +1,17 @@
+import type { AIAdapter, ChatMessage, BaseAIConfig, AIResponse } from '../types.js';
+/**
+ * Adapter per Ollama
+ */
+export declare class OllamaAdapter implements AIAdapter {
+    transformRequest(messages: ChatMessage[], config: BaseAIConfig): {
+        endpoint: string;
+        body: {
+            model: string;
+            messages: ChatMessage[];
+            stream: boolean;
+            options: any;
+        };
+    };
+    transformResponse(response: any): AIResponse;
+    configureHeaders(): Record<string, string>;
+}

package/dist/cjs/src/ai/adapters/OllamaAdapter.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaAdapter = void 0;
+/**
+ * Adapter per Ollama
+ */
+class OllamaAdapter {
+    transformRequest(messages, config) {
+        return {
+            endpoint: '/chat',
+            body: {
+                model: config.model,
+                messages,
+                stream: false,
+                options: {
+                    temperature: config.temperature,
+                    num_predict: config.maxTokens,
+                    ...config.additionalParams
+                }
+            }
+        };
+    }
+    transformResponse(response) {
+        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() {
+        return {
+            'Content-Type': 'application/json'
+        };
+    }
+}
+exports.OllamaAdapter = OllamaAdapter;

package/dist/cjs/src/ai/adapters/OpenAIAdapter.d.ts

@@ -0,0 +1,12 @@
+import type { AIAdapter, ChatMessage, BaseAIConfig, AIResponse } from '../types.js';
+/**
+ * Adapter per OpenAI e provider compatibili (Azure OpenAI, ecc.)
+ */
+export declare class OpenAIAdapter implements AIAdapter {
+    transformRequest(messages: ChatMessage[], config: BaseAIConfig): {
+        endpoint: string;
+        body: any;
+    };
+    transformResponse(response: any): AIResponse;
+    configureHeaders(config: BaseAIConfig): Record<string, string>;
+}

package/dist/cjs/src/ai/adapters/OpenAIAdapter.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIAdapter = void 0;
+/**
+ * Adapter per OpenAI e provider compatibili (Azure OpenAI, ecc.)
+ */
+class OpenAIAdapter {
+    transformRequest(messages, config) {
+        const body = {
+            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) {
+        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) {
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        if (config.apiKey) {
+            headers['Authorization'] = `Bearer ${config.apiKey}`;
+        }
+        return headers;
+    }
+}
+exports.OpenAIAdapter = OpenAIAdapter;

package/dist/cjs/src/ai/adapters/index.d.ts

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

package/dist/cjs/src/ai/adapters/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicAdapter = exports.OllamaAdapter = exports.OpenAIAdapter = void 0;
+var OpenAIAdapter_js_1 = require("./OpenAIAdapter.js");
+Object.defineProperty(exports, "OpenAIAdapter", { enumerable: true, get: function () { return OpenAIAdapter_js_1.OpenAIAdapter; } });
+var OllamaAdapter_js_1 = require("./OllamaAdapter.js");
+Object.defineProperty(exports, "OllamaAdapter", { enumerable: true, get: function () { return OllamaAdapter_js_1.OllamaAdapter; } });
+var AnthropicAdapter_js_1 = require("./AnthropicAdapter.js");
+Object.defineProperty(exports, "AnthropicAdapter", { enumerable: true, get: function () { return AnthropicAdapter_js_1.AnthropicAdapter; } });

package/dist/cjs/src/ai/factory.d.ts

@@ -0,0 +1,12 @@
+import { AIProvider } from './AIProvider.js';
+import type { BaseAIConfig, AIAdapter } from './types.js';
+/**
+ * Factory helper per creare provider comuni
+ */
+export declare const createAIProvider: {
+    openai: (apiKey: string, model?: string, config?: Partial<BaseAIConfig>) => AIProvider;
+    ollama: (model?: string, baseURL?: string, config?: Partial<BaseAIConfig>) => AIProvider;
+    anthropic: (apiKey: string, model?: string, config?: Partial<BaseAIConfig>) => AIProvider;
+    azureOpenAI: (apiKey: string, endpoint: string, deployment: string, config?: Partial<BaseAIConfig>) => AIProvider;
+    custom: (baseURL: string, adapter: AIAdapter, config?: Partial<BaseAIConfig>) => AIProvider;
+};

package/dist/cjs/src/ai/factory.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAIProvider = void 0;
+const AIProvider_js_1 = require("./AIProvider.js");
+/**
+ * Factory helper per creare provider comuni
+ */
+exports.createAIProvider = {
+    openai: (apiKey, model = 'gpt-4', config) => new AIProvider_js_1.AIProvider({
+        baseURL: 'https://api.openai.com/v1',
+        apiKey,
+        model,
+        ...config
+    }, 'openai'),
+    ollama: (model = 'llama2', baseURL = 'http://localhost:11434/api', config) => new AIProvider_js_1.AIProvider({
+        baseURL,
+        model,
+        ...config
+    }, 'ollama'),
+    anthropic: (apiKey, model = 'claude-3-5-sonnet-20241022', config) => new AIProvider_js_1.AIProvider({
+        baseURL: 'https://api.anthropic.com',
+        apiKey,
+        model,
+        ...config
+    }, 'anthropic'),
+    azureOpenAI: (apiKey, endpoint, deployment, config) => new AIProvider_js_1.AIProvider({
+        baseURL: `${endpoint}/openai/deployments/${deployment}`,
+        apiKey,
+        model: deployment,
+        headers: {
+            'api-key': apiKey
+        },
+        ...config
+    }, 'azure'),
+    custom: (baseURL, adapter, config) => new AIProvider_js_1.AIProvider({
+        baseURL,
+        model: config?.model || 'default',
+        ...config
+    }, adapter)
+};

package/dist/cjs/src/ai/index.d.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/dist/cjs/src/ai/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI_ADAPTERS = exports.createAIProvider = exports.AIProvider = void 0;
+var AIProvider_js_1 = require("./AIProvider.js");
+Object.defineProperty(exports, "AIProvider", { enumerable: true, get: function () { return AIProvider_js_1.AIProvider; } });
+var factory_js_1 = require("./factory.js");
+Object.defineProperty(exports, "createAIProvider", { enumerable: true, get: function () { return factory_js_1.createAIProvider; } });
+var registry_js_1 = require("./registry.js");
+Object.defineProperty(exports, "AI_ADAPTERS", { enumerable: true, get: function () { return registry_js_1.AI_ADAPTERS; } });
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./adapters/index.js"), exports);

package/dist/cjs/src/ai/registry.d.ts

@@ -0,0 +1,13 @@
+import { OpenAIAdapter } from './adapters/OpenAIAdapter.js';
+import { OllamaAdapter } from './adapters/OllamaAdapter.js';
+import { AnthropicAdapter } from './adapters/AnthropicAdapter.js';
+/**
+ * Registry degli adapter disponibili
+ */
+export declare const AI_ADAPTERS: {
+    readonly openai: OpenAIAdapter;
+    readonly ollama: OllamaAdapter;
+    readonly anthropic: AnthropicAdapter;
+    readonly azure: OpenAIAdapter;
+    readonly 'azure-openai': OpenAIAdapter;
+};

package/dist/cjs/src/ai/registry.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI_ADAPTERS = void 0;
+const OpenAIAdapter_js_1 = require("./adapters/OpenAIAdapter.js");
+const OllamaAdapter_js_1 = require("./adapters/OllamaAdapter.js");
+const AnthropicAdapter_js_1 = require("./adapters/AnthropicAdapter.js");
+/**
+ * Registry degli adapter disponibili
+ */
+exports.AI_ADAPTERS = {
+    openai: new OpenAIAdapter_js_1.OpenAIAdapter(),
+    ollama: new OllamaAdapter_js_1.OllamaAdapter(),
+    anthropic: new AnthropicAdapter_js_1.AnthropicAdapter(),
+    // Alias per compatibilità
+    azure: new OpenAIAdapter_js_1.OpenAIAdapter(),
+    'azure-openai': new OpenAIAdapter_js_1.OpenAIAdapter()
+};

package/dist/cjs/src/ai/types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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/dist/cjs/src/ai/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/src/cv-parser/PDFParserService.d.ts

@@ -0,0 +1,41 @@
+import type { PDFExtractionOptions, PDFExtractionResult } from './types.js';
+/**
+ * Servizio per estrarre testo dai file PDF
+ */
+export declare class PDFParserService {
+    /**
+     * Estrae il testo da un file PDF
+     * @param pdfPath Percorso del file PDF o Buffer
+     * @param options Opzioni di estrazione
+     */
+    extractText(pdfPath: string | Buffer, options?: PDFExtractionOptions): Promise<PDFExtractionResult>;
+    /**
+     * Estrae il testo da più PDF contemporaneamente
+     * @param pdfPaths Array di percorsi PDF
+     * @param options Opzioni di estrazione
+     */
+    extractTextFromMultiple(pdfPaths: (string | Buffer)[], options?: PDFExtractionOptions): Promise<PDFExtractionResult[]>;
+    /**
+     * Verifica se un file è un PDF valido
+     * @param pdfPath Percorso del file PDF o Buffer
+     */
+    isValidPDF(pdfPath: string | Buffer): Promise<boolean>;
+    /**
+     * Crea un renderer personalizzato per le pagine
+     */
+    private createPageRenderer;
+    /**
+     * Estrae i metadati dal PDF
+     */
+    private extractMetadata;
+    /**
+     * Estrae solo testo da una specifica pagina
+     * @param pdfPath Percorso del file PDF o Buffer
+     * @param pageNumber Numero della pagina (1-based)
+     */
+    extractPageText(pdfPath: string | Buffer, pageNumber: number): Promise<string>;
+}
+/**
+ * Istanza singleton del parser
+ */
+export declare const pdfParser: PDFParserService;