@quantyapp/quanty-mcp-server 1.0.11 → 1.2.6

package/dist/core/matchingService.js

@@ -0,0 +1,437 @@
+import { supabase } from './supabase.js';
+// ================ TEXT NORMALIZATION ================
+/**
+ * Normaliza texto removendo acentos e convertendo para minúsculas
+ */
+function normalizeText(text) {
+    if (!text)
+        return '';
+    return text
+        .toLowerCase()
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '') // Remove acentos
+        .replace(/[^\w\s]/g, ' ') // Remove pontuação
+        .replace(/\s+/g, ' ') // Colapsa espaços múltiplos
+        .trim();
+}
+/**
+ * Dicionário de sinônimos e abreviações comuns em orçamentação
+ */
+const SYNONYMS = {
+    'concreto': ['conc', 'concr', 'cto'],
+    'argamassa': ['arg', 'argam'],
+    'metro': ['m', 'mt', 'mts'],
+    'centimetro': ['cm', 'cent'],
+    'milimetro': ['mm', 'milim'],
+    'quilograma': ['kg', 'quilo', 'kilo'],
+    'tonelada': ['t', 'ton'],
+    'litro': ['l', 'lt', 'lts'],
+    'unidade': ['un', 'und', 'unid', 'peca', 'pc', 'pç'],
+    'verba': ['vb', 'vrb'],
+    'conjunto': ['cj', 'conj'],
+    'hora': ['h', 'hr', 'hs'],
+    'dia': ['d'],
+    'mes': ['m', 'meses'],
+    'equipamento': ['equip', 'eqp', 'eq'],
+    'material': ['mat', 'mater'],
+    'servico': ['serv', 'svc'],
+    'maodeobra': ['mo', 'mao de obra', 'mão de obra'],
+    'transporte': ['transp', 'trans'],
+    'instalacao': ['inst', 'instal'],
+    'eletrico': ['eletr', 'elet', 'elétrico'],
+    'hidraulico': ['hidr', 'hidra', 'hidráulico'],
+    'tubo': ['tb', 'tub'],
+    'conexao': ['cnx', 'conex', 'conexão'],
+    'fundacao': ['fund', 'fundação'],
+    'estrutura': ['estr', 'estrut'],
+    'alvenaria': ['alv', 'alven'],
+    'revestimento': ['revest', 'rev'],
+    'pintura': ['pint', 'pin'],
+    'impermeabilizacao': ['imper', 'impermeabilização'],
+    'esquadria': ['esq', 'esquad'],
+    'cobertura': ['cob', 'cobert'],
+    'administracao': ['adm', 'admin', 'administração'],
+    'canteiro': ['cant'],
+    'mobilizacao': ['mob', 'mobil', 'mobilização'],
+    'desmobilizacao': ['desmob', 'desmobil', 'desmobilização'],
+};
+/**
+ * Expande sinônimos e abreviações no texto
+ */
+function expandSynonyms(text) {
+    let normalized = normalizeText(text);
+    // Substitui abreviações pelos termos completos
+    for (const [fullTerm, abbreviations] of Object.entries(SYNONYMS)) {
+        for (const abbrev of abbreviations) {
+            // Substitui apenas palavras inteiras
+            const regex = new RegExp(`\\b${abbrev}\\b`, 'gi');
+            normalized = normalized.replace(regex, fullTerm);
+        }
+    }
+    return normalized;
+}
+/**
+ * Extrai features de uma descrição de item
+ */
+function extractFeatures(description) {
+    const normalized = expandSynonyms(description);
+    const words = normalized.split(' ').filter(w => w.length > 2);
+    // Extrai dimensões (ex: 20x15, 10cm, 2.5m)
+    const dimensionPattern = /(\d+(?:[.,]\d+)?)\s*x\s*(\d+(?:[.,]\d+)?)|(\d+(?:[.,]\d+)?)\s*(cm|mm|m|pol)/gi;
+    const dimensions = [];
+    let match;
+    while ((match = dimensionPattern.exec(description)) !== null) {
+        dimensions.push(match[0]);
+    }
+    // Extrai números isolados
+    const numberPattern = /\b(\d+(?:[.,]\d+)?)\b/g;
+    const numbers = [];
+    while ((match = numberPattern.exec(normalized)) !== null) {
+        numbers.push(parseFloat(match[1].replace(',', '.')));
+    }
+    // Identifica materiais comuns
+    const materialKeywords = [
+        'concreto', 'aco', 'ferro', 'argamassa', 'cimento', 'areia', 'brita',
+        'madeira', 'vidro', 'aluminio', 'pvc', 'cobre', 'ceramica', 'porcelanato',
+        'granito', 'marmore', 'gesso', 'drywall', 'tijolo', 'bloco'
+    ];
+    const materials = words.filter(w => materialKeywords.includes(w));
+    // Identifica categoria
+    const categoryKeywords = {
+        'fundacao': ['fundacao', 'estaca', 'radier', 'sapata', 'tubulao'],
+        'estrutura': ['estrutura', 'pilar', 'viga', 'laje', 'concreto armado'],
+        'alvenaria': ['alvenaria', 'parede', 'tijolo', 'bloco'],
+        'revestimento': ['revestimento', 'reboco', 'chapisco', 'ceramica', 'piso'],
+        'pintura': ['pintura', 'tinta', 'latex', 'acrilica', 'massa corrida'],
+        'instalacao_eletrica': ['eletrico', 'fio', 'cabo', 'tomada', 'interruptor', 'disjuntor'],
+        'instalacao_hidraulica': ['hidraulico', 'tubo', 'conexao', 'registro', 'valvula'],
+        'impermeabilizacao': ['impermeabilizacao', 'manta', 'asfaltica'],
+        'esquadria': ['esquadria', 'porta', 'janela', 'vidro'],
+        'cobertura': ['cobertura', 'telha', 'calha', 'rufo'],
+        'administracao': ['administracao', 'canteiro', 'mobilizacao', 'desmobilizacao', 'engenheiro']
+    };
+    let category = 'outros';
+    for (const [cat, keywords] of Object.entries(categoryKeywords)) {
+        if (keywords.some(kw => normalized.includes(kw))) {
+            category = cat;
+            break;
+        }
+    }
+    // Keywords são palavras significativas (não stop words)
+    const stopWords = ['de', 'da', 'do', 'para', 'com', 'em', 'por', 'uma', 'um', 'que', 'e', 'ou'];
+    const keywords = words.filter(w => !stopWords.includes(w) && w.length > 2);
+    return { keywords, dimensions, numbers, materials, category };
+}
+// ================ SIMILARITY METRICS ================
+/**
+ * Calcula distância de Levenshtein entre duas strings
+ */
+function levenshteinDistance(a, b) {
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++) {
+        matrix[i] = [i];
+    }
+    for (let j = 0; j <= a.length; j++) {
+        matrix[0][j] = j;
+    }
+    for (let i = 1; i <= b.length; i++) {
+        for (let j = 1; j <= a.length; j++) {
+            if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            }
+            else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+            }
+        }
+    }
+    return matrix[b.length][a.length];
+}
+/**
+ * Calcula similaridade fuzzy (baseada em Levenshtein)
+ */
+function fuzzySimilarity(a, b) {
+    const normA = expandSynonyms(a);
+    const normB = expandSynonyms(b);
+    if (normA === normB)
+        return 100;
+    const maxLen = Math.max(normA.length, normB.length);
+    if (maxLen === 0)
+        return 100;
+    const distance = levenshteinDistance(normA, normB);
+    return Math.round((1 - distance / maxLen) * 100);
+}
+/**
+ * Calcula similaridade baseada em palavras-chave (Jaccard)
+ */
+function keywordSimilarity(a, b) {
+    const featuresA = extractFeatures(a);
+    const featuresB = extractFeatures(b);
+    const setA = new Set(featuresA.keywords);
+    const setB = new Set(featuresB.keywords);
+    const intersection = new Set([...setA].filter(x => setB.has(x)));
+    const union = new Set([...setA, ...setB]);
+    if (union.size === 0)
+        return 0;
+    return Math.round((intersection.size / union.size) * 100);
+}
+/**
+ * Calcula similaridade TF-IDF simplificada
+ */
+function tfidfSimilarity(a, b) {
+    const wordsA = expandSynonyms(a).split(' ').filter(w => w.length > 2);
+    const wordsB = expandSynonyms(b).split(' ').filter(w => w.length > 2);
+    // Conta frequência de palavras
+    const freqA = {};
+    const freqB = {};
+    for (const w of wordsA)
+        freqA[w] = (freqA[w] || 0) + 1;
+    for (const w of wordsB)
+        freqB[w] = (freqB[w] || 0) + 1;
+    // Calcula produto escalar normalizado (cosine similarity)
+    const allWords = new Set([...Object.keys(freqA), ...Object.keys(freqB)]);
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (const word of allWords) {
+        const vA = freqA[word] || 0;
+        const vB = freqB[word] || 0;
+        dotProduct += vA * vB;
+        normA += vA * vA;
+        normB += vB * vB;
+    }
+    if (normA === 0 || normB === 0)
+        return 0;
+    return Math.round((dotProduct / (Math.sqrt(normA) * Math.sqrt(normB))) * 100);
+}
+/**
+ * Calcula similaridade combinada (ensemble)
+ */
+export function calculateSimilarity(a, b) {
+    const fuzzy = fuzzySimilarity(a, b);
+    const keyword = keywordSimilarity(a, b);
+    const tfidf = tfidfSimilarity(a, b);
+    const featuresA = extractFeatures(a);
+    const featuresB = extractFeatures(b);
+    const categoryMatch = featuresA.category === featuresB.category;
+    // Pesos ajustados
+    const weights = { fuzzy: 0.3, keyword: 0.4, tfidf: 0.3 };
+    // Bonus por categoria igual
+    const categoryBonus = categoryMatch ? 10 : 0;
+    const overall = Math.min(100, Math.round(fuzzy * weights.fuzzy +
+        keyword * weights.keyword +
+        tfidf * weights.tfidf +
+        categoryBonus));
+    return {
+        overall,
+        fuzzy,
+        keyword,
+        tfidf,
+        category: {
+            a: featuresA.category,
+            b: featuresB.category,
+            match: categoryMatch
+        }
+    };
+}
+/**
+ * Busca itens similares em outros orçamentos
+ */
+export async function findSimilarInBudgets(auth, description, excludeBudgetId, limit = 10, minSimilarity = 50) {
+    // Busca orçamentos do tenant/usuário
+    const { data: budgets, error } = await supabase
+        .from('budgets')
+        .select('id, title, data')
+        .or(`tenant_id.eq.${auth.tenantId},user_id.eq.${auth.userId}`)
+        .eq('deleted', false)
+        .limit(50); // Limita para performance
+    if (error || !budgets)
+        return [];
+    const results = [];
+    for (const budget of budgets) {
+        if (budget.id === excludeBudgetId)
+            continue;
+        const rows = budget.data?.rows || [];
+        for (const row of rows) {
+            if (!row.description)
+                continue;
+            const sim = calculateSimilarity(description, row.description);
+            if (sim.overall >= minSimilarity) {
+                results.push({
+                    id: row.id,
+                    code: row.code || '',
+                    description: row.description,
+                    unit: row.unit || '',
+                    unitCost: row.unitCost || 0,
+                    source: 'budget',
+                    sourceId: budget.id,
+                    sourceName: budget.title,
+                    similarity: sim.overall,
+                    similarityDetails: {
+                        fuzzy: sim.fuzzy,
+                        keyword: sim.keyword,
+                        tfidf: sim.tfidf
+                    }
+                });
+            }
+        }
+    }
+    // Ordena por similaridade e limita
+    return results
+        .sort((a, b) => b.similarity - a.similarity)
+        .slice(0, limit);
+}
+/**
+ * Busca itens similares em bancos de composições
+ */
+export async function findSimilarInBanks(auth, description, bankIds, limit = 10, minSimilarity = 50) {
+    // Busca bancos disponíveis
+    let query = supabase
+        .from('composition_banks')
+        .select('id, title, data, visibility');
+    if (bankIds && bankIds.length > 0) {
+        query = query.in('id', bankIds);
+    }
+    else {
+        // Busca bancos públicos ou do tenant/usuário
+        query = query.or(`visibility.eq.public,tenant_id.eq.${auth.tenantId},user_id.eq.${auth.userId}`);
+    }
+    const { data: banks, error } = await query.limit(20);
+    if (error || !banks)
+        return [];
+    const results = [];
+    for (const bank of banks) {
+        const categories = bank.data?.categories || [];
+        // Função recursiva para extrair itens
+        const extractItems = (nodes) => {
+            const items = [];
+            for (const node of nodes) {
+                if (node.items) {
+                    items.push(...node.items);
+                }
+                if (node.children) {
+                    items.push(...extractItems(node.children));
+                }
+            }
+            return items;
+        };
+        const items = extractItems(categories);
+        for (const item of items) {
+            const itemDesc = item.description || item.name || item.title || '';
+            if (!itemDesc)
+                continue;
+            const sim = calculateSimilarity(description, itemDesc);
+            if (sim.overall >= minSimilarity) {
+                results.push({
+                    id: item.id,
+                    code: item.code || '',
+                    description: itemDesc,
+                    unit: item.unit || item.unidade || '',
+                    unitCost: item.unitCost || item.unit_cost || item.custoUnitario || 0,
+                    source: 'bank',
+                    sourceId: bank.id,
+                    sourceName: bank.title,
+                    similarity: sim.overall,
+                    similarityDetails: {
+                        fuzzy: sim.fuzzy,
+                        keyword: sim.keyword,
+                        tfidf: sim.tfidf
+                    }
+                });
+            }
+        }
+    }
+    // Ordena por similaridade e limita
+    return results
+        .sort((a, b) => b.similarity - a.similarity)
+        .slice(0, limit);
+}
+/**
+ * Busca unificada em orçamentos e bancos
+ */
+export async function findSimilarItems(auth, description, options = {}) {
+    const { searchBudgets = true, searchBanks = true, excludeBudgetId, bankIds, limit = 10, minSimilarity = 50 } = options;
+    const [budgetResults, bankResults] = await Promise.all([
+        searchBudgets ? findSimilarInBudgets(auth, description, excludeBudgetId, limit, minSimilarity) : [],
+        searchBanks ? findSimilarInBanks(auth, description, bankIds, limit, minSimilarity) : []
+    ]);
+    // Combina e ordena os top matches
+    const allResults = [...budgetResults, ...bankResults];
+    const topMatches = allResults
+        .sort((a, b) => b.similarity - a.similarity)
+        .slice(0, limit);
+    return {
+        budgetResults,
+        bankResults,
+        topMatches
+    };
+}
+/**
+ * Compara preços de itens similares
+ */
+export async function comparePrices(auth, description, currentPrice, options = {}) {
+    const { topMatches } = await findSimilarItems(auth, description, {
+        searchBudgets: true,
+        searchBanks: true,
+        excludeBudgetId: options.excludeBudgetId,
+        limit: options.limit || 20,
+        minSimilarity: options.minSimilarity || 60
+    });
+    // Filtra itens com preço válido
+    const withPrice = topMatches.filter(m => m.unitCost > 0);
+    if (withPrice.length === 0) {
+        return {
+            currentPrice,
+            matches: [],
+            statistics: {
+                minPrice: 0,
+                maxPrice: 0,
+                avgPrice: 0,
+                medianPrice: 0,
+                recommendation: 'Não foram encontrados itens similares com preço para comparação.'
+            }
+        };
+    }
+    // Calcula diferença de preço para cada match
+    const matchesWithDiff = withPrice.map(m => ({
+        ...m,
+        priceDiff: m.unitCost - currentPrice,
+        priceDiffPercent: currentPrice > 0 ? Math.round(((m.unitCost - currentPrice) / currentPrice) * 100) : 0
+    }));
+    // Estatísticas
+    const prices = withPrice.map(m => m.unitCost).sort((a, b) => a - b);
+    const minPrice = prices[0];
+    const maxPrice = prices[prices.length - 1];
+    const avgPrice = prices.reduce((a, b) => a + b, 0) / prices.length;
+    const medianPrice = prices.length % 2 === 0
+        ? (prices[prices.length / 2 - 1] + prices[prices.length / 2]) / 2
+        : prices[Math.floor(prices.length / 2)];
+    // Recomendação
+    let recommendation = '';
+    const diffFromAvg = ((currentPrice - avgPrice) / avgPrice) * 100;
+    if (currentPrice < minPrice * 0.8) {
+        recommendation = `⚠️ Preço muito abaixo do mercado (${Math.abs(Math.round(diffFromAvg))}% abaixo da média). Verifique se está correto.`;
+    }
+    else if (currentPrice > maxPrice * 1.2) {
+        recommendation = `⚠️ Preço muito acima do mercado (${Math.round(diffFromAvg)}% acima da média). Considere revisar.`;
+    }
+    else if (Math.abs(diffFromAvg) <= 10) {
+        recommendation = `✅ Preço dentro da média de mercado.`;
+    }
+    else if (diffFromAvg > 0) {
+        recommendation = `📊 Preço ${Math.round(diffFromAvg)}% acima da média, mas dentro da faixa de mercado.`;
+    }
+    else {
+        recommendation = `📊 Preço ${Math.abs(Math.round(diffFromAvg))}% abaixo da média, mas dentro da faixa de mercado.`;
+    }
+    return {
+        currentPrice,
+        matches: matchesWithDiff,
+        statistics: {
+            minPrice: Math.round(minPrice * 100) / 100,
+            maxPrice: Math.round(maxPrice * 100) / 100,
+            avgPrice: Math.round(avgPrice * 100) / 100,
+            medianPrice: Math.round(medianPrice * 100) / 100,
+            recommendation
+        }
+    };
+}