batchExtract.js

#!/usr/bin/env bun

import { readdirSync, statSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
import { join, extname, basename } from 'node:path';
import process from 'node:process';
import { execSync } from 'node:child_process';

/**
 * PDF Batch Extractor
 * Extrai links e texto de múltiplos arquivos PDF de uma pasta
 * 
 * Uso: bun batchExtract.js <caminho-da-pasta>
 * Exemplo: bun batchExtract.js ./pdfs/
 */

class PDFBatchExtractor {
  constructor(outputPath = null, preserveStructure = false) {
    this.urlRegex = /https?:\/\/(?:[-\w.])+(?:\:[0-9]+)?(?:\/(?:[\w\/_.])*(?:\?(?:[\w&=%.])*)?(?:\#(?:[\w.])*)?)?/gi;
    this.emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/gi;
    this.processedCount = 0;
    this.errorCount = 0;
    this.results = [];
    this.outputPath = outputPath;
    this.preserveStructure = preserveStructure;
    this.basePath = null;
  }

  async extractFromPDF(filePath) {
    try {
      console.log(`📄 Processando: ${basename(filePath)}`);
      
      // Método 1: Usar pdftotext primeiro (mais confiável)
      let text = '';
      let pages = 0;
      let metadata = {};
      
      try {
        const pdftotextResult = this.extractTextWithPdftotext(filePath);
        if (pdftotextResult.text && pdftotextResult.text.length > 50) {
          text = pdftotextResult.text;
          pages = pdftotextResult.pages;
          metadata = { extractor: 'pdftotext' };
          console.log(`✅ pdftotext extraiu ${text.length} caracteres de ${pages} páginas`);
        } else {
          throw new Error('pdftotext não retornou texto suficiente');
        }
      } catch (pdftotextError) {
        console.log('⚠️  pdftotext não disponível ou falhou, tentando pdf-parse...');
        
        // Método 2: Tentar pdf-parse como fallback
        const pdfParse = await import('pdf-parse');
        const pdfBuffer = readFileSync(filePath);
        
        let parseFunction = pdfParse.default;
        if (!parseFunction) {
          parseFunction = pdfParse;
        }
        
        const data = await parseFunction(pdfBuffer);
        text = data.text || '';
        pages = data.numpages || 0;
        metadata = data.info || {};
        
        console.log(`📊 Páginas encontradas: ${pages}`);
        console.log(`📝 Caracteres extraídos: ${text.length}`);
      }
      
      // Extrai hyperlinks
      const hyperlinks = await this.extractHyperlinks(filePath);
      
      // Extrai URLs do texto também (como fallback)
      const textUrls = this.extractURLs(text);
      const emails = this.extractEmails(text);
      
      // Combina hyperlinks clicáveis + URLs do texto
      const allUrls = [...hyperlinks, ...textUrls];
      const uniqueUrls = [...new Set(allUrls)];
      const uniqueEmails = [...new Set(emails)];
      
      // Referencia hyperlinks no texto
      const hyperlinkReferences = this.findHyperlinkReferences(text, hyperlinks);
      
      console.log(`🔗 Hyperlinks clicáveis encontrados: ${hyperlinks.length}`);
      console.log(`🔗 URLs no texto encontrados: ${textUrls.length}`);
      console.log(`🔗 Total de links únicos: ${uniqueUrls.length}`);
      console.log(`📍 Referências de hyperlinks encontradas: ${hyperlinkReferences.length}`);
      
      return {
        text,
        hyperlinks,
        textUrls,
        urls: uniqueUrls,
        emails: uniqueEmails,
        hyperlinkReferences,
        pages,
        metadata: { ...metadata, extractor: 'pdf-lib + pdf-parse' }
      };
      
    } catch (error) {
      throw new Error(`Erro ao processar PDF: ${error.message}`);
    }
  }

  async extractHyperlinks(filePath) {
    try {
      // Método 1: Usar pdf-lib (melhor para annotations)
      try {
        const { PDFDocument } = await import('pdf-lib');
        const pdfBuffer = readFileSync(filePath);
        const pdfDoc = await PDFDocument.load(pdfBuffer);
        
        const hyperlinks = [];
        const pages = pdfDoc.getPages();
        
        for (let pageIndex = 0; pageIndex < pages.length; pageIndex++) {
          const page = pages[pageIndex];
          const annotations = page.node.Annots;
          
          if (annotations) {
            const annotArray = pdfDoc.context.lookup(annotations);
            
            if (annotArray && annotArray.asArray) {
              for (const annotRef of annotArray.asArray()) {
                const annot = pdfDoc.context.lookup(annotRef);
                if (annot && annot.dict) {
                  const action = annot.dict.lookup('A');
                  if (action && action.dict) {
                    const uri = action.dict.lookup('URI');
                    if (uri && uri.asString) {
                      const url = uri.asString();
                      if (url.startsWith('http') || url.startsWith('www')) {
                        hyperlinks.push(url);
                      }
                    }
                  }
                }
              }
            }
          }
        }
        
        if (hyperlinks.length > 0) {
          console.log(`✅ pdf-lib encontrou ${hyperlinks.length} hyperlinks`);
          return hyperlinks;
        }
        
      } catch (_pdfLibError) {
        console.log('⚠️  pdf-lib falhou, tentando extração raw...');
      }
      
      // Método 2: Extração raw das annotations
      const pdfBuffer = readFileSync(filePath);
      const pdfString = pdfBuffer.toString('latin1');
      
      const hyperlinks = [];
      
      // Regex para encontrar URIs em annotations
      const uriRegex = /\/URI\s*\(([^)]+)\)/g;
      let match;
      
      while ((match = uriRegex.exec(pdfString)) !== null) {
        const uri = match[1];
        if (uri && (uri.startsWith('http') || uri.includes('www.'))) {
          hyperlinks.push(uri);
        }
      }
      
      // Também busca por padrão /A << /S /URI /URI (URL)
      const actionRegex = /\/A\s*<<[^>]*\/URI\s*\(([^)]+)\)/g;
      while ((match = actionRegex.exec(pdfString)) !== null) {
        const uri = match[1];
        if (uri && (uri.startsWith('http') || uri.includes('www.'))) {
          hyperlinks.push(uri);
        }
      }
      
      console.log(`✅ Extração raw encontrou ${hyperlinks.length} hyperlinks`);
      return hyperlinks;
      
    } catch (error) {
      console.log(`⚠️  Erro na extração de hyperlinks: ${error.message}`);
      return [];
    }
  }

  extractTextWithPdftotext(filePath) {
    try {
      // Verifica se pdftotext está disponível
      execSync('which pdftotext', { stdio: 'ignore' });
      
      // Executa pdftotext
      const result = execSync(`pdftotext "${filePath}" -`, { 
        encoding: 'utf8',
        maxBuffer: 1024 * 1024 * 10 // 10MB buffer
      });
      
      const text = result.toString().trim();
      
      // Tenta obter número de páginas
      let pages = 0;
      try {
        const pageResult = execSync(`pdfinfo "${filePath}" | grep Pages`, { 
          encoding: 'utf8',
          stdio: 'pipe'
        });
        const pageMatch = pageResult.toString().match(/Pages:\s*(\d+)/);
        if (pageMatch) {
          pages = parseInt(pageMatch[1]);
        }
      } catch (_error) {
        // Se pdfinfo falhar, estima baseado no texto
        pages = Math.max(1, Math.ceil(text.length / 2000));
      }
      
      return {
        text,
        pages,
        extractor: 'pdftotext'
      };
      
    } catch (error) {
      throw new Error(`pdftotext falhou: ${error.message}`);
    }
  }

  extractURLs(text) {
    const urls = text.match(this.urlRegex) || [];
    return urls.map(url => url.trim()).filter(url => url.length > 0);
  }

  extractEmails(text) {
    const emails = text.match(this.emailRegex) || [];
    return emails.map(email => email.trim()).filter(email => email.length > 0);
  }

  findHyperlinkReferences(text, hyperlinks) {
    const references = [];
    
    for (const hyperlink of hyperlinks) {
      // Busca por padrões de referência no texto
      const patterns = [
        // Padrão: [Texto](@URL)
        new RegExp(`\\[([^\\]]+)\\]\\(@${this.escapeRegex(hyperlink)}\\)`, 'gi'),
        // Padrão: [Texto](URL)
        new RegExp(`\\[([^\\]]+)\\]\\(${this.escapeRegex(hyperlink)}\\)`, 'gi'),
        // Padrão: "Texto" (URL)
        new RegExp(`"([^"]+)"\\s*\\(${this.escapeRegex(hyperlink)}\\)`, 'gi'),
        // Padrão: Texto (URL)
        new RegExp(`([^\\s]+)\\s*\\(${this.escapeRegex(hyperlink)}\\)`, 'gi')
      ];
      
      for (const pattern of patterns) {
        let match;
        while ((match = pattern.exec(text)) !== null) {
          const reference = {
            url: hyperlink,
            text: match[1] || match[0],
            context: match[0],
            position: match.index,
            line: text.substring(0, match.index).split('\n').length,
            type: 'explicit_reference'
          };
          
          // Evita duplicatas
          if (!references.some(ref => 
            ref.url === reference.url && 
            ref.position === reference.position
          )) {
            references.push(reference);
          }
        }
      }
      
      // Se não encontrou referências explícitas, busca por contexto próximo
      if (!references.some(ref => ref.url === hyperlink)) {
        // Busca por texto próximo ao hyperlink no texto
        const contextPattern = new RegExp(`([^\\n]{0,100})\\s*${this.escapeRegex(hyperlink)}\\s*([^\\n]{0,100})`, 'gi');
        let match;
        while ((match = contextPattern.exec(text)) !== null) {
          const beforeContext = match[1].trim();
          const afterContext = match[2].trim();
          
          // Extrai texto relevante do contexto
          const relevantText = this.extractRelevantTextFromContext(beforeContext, afterContext);
          
          if (relevantText) {
            const reference = {
              url: hyperlink,
              text: relevantText,
              context: match[0],
              position: match.index,
              line: text.substring(0, match.index).split('\n').length,
              type: 'contextual_reference'
            };
            
            references.push(reference);
            break; // Apenas uma referência contextual por URL
          }
        }
      }
      
      // Se ainda não encontrou, busca por texto relacionado baseado no conteúdo da URL
      if (!references.some(ref => ref.url === hyperlink)) {
        const relatedText = this.findRelatedTextForUrl(text, hyperlink);
        if (relatedText) {
          const reference = {
            url: hyperlink,
            text: relatedText.text,
            context: relatedText.context,
            position: relatedText.position,
            line: relatedText.line,
            type: 'related_text'
          };
          
          references.push(reference);
        }
      }
    }
    
    return references;
  }

  extractRelevantTextFromContext(beforeContext, afterContext) {
    // Tenta extrair texto relevante do contexto
    const beforeWords = beforeContext.split(/\s+/).filter(word => word.length > 2);
    const afterWords = afterContext.split(/\s+/).filter(word => word.length > 2);
    
    // Pega as últimas palavras do contexto anterior
    const relevantBefore = beforeWords.slice(-3).join(' ');
    
    // Pega as primeiras palavras do contexto posterior
    const relevantAfter = afterWords.slice(0, 3).join(' ');
    
    // Combina contexto relevante
    const relevantText = [relevantBefore, relevantAfter].filter(text => text.length > 0).join(' ');
    
    return relevantText || 'Contexto não identificado';
  }

  findRelatedTextForUrl(text, url) {
    // Extrai palavras-chave da URL para buscar texto relacionado
    const urlKeywords = this.extractKeywordsFromUrl(url);
    
    for (const keyword of urlKeywords) {
      // Busca por texto que contenha a palavra-chave
      const keywordPattern = new RegExp(`([^\\n]{0,50}\\b${this.escapeRegex(keyword)}\\b[^\\n]{0,50})`, 'gi');
      let match;
      
      while ((match = keywordPattern.exec(text)) !== null) {
        const context = match[1].trim();
        
        // Verifica se o contexto é relevante (não é apenas metadados)
        if (this.isRelevantContext(context)) {
          return {
            text: this.extractTitleFromContext(context),
            context: context,
            position: match.index,
            line: text.substring(0, match.index).split('\n').length
          };
        }
      }
    }
    
    return null;
  }

  extractKeywordsFromUrl(url) {
    // Extrai palavras-chave relevantes da URL
    const keywords = [];
    
    // Extrai domínio
    const domainMatch = url.match(/https?:\/\/([^\/]+)/);
    if (domainMatch) {
      const domain = domainMatch[1];
      const domainParts = domain.split('.');
      keywords.push(...domainParts.filter(part => part.length > 2));
    }
    
    // Extrai palavras do caminho
    const pathMatch = url.match(/https?:\/\/[^\/]+(.*)/);
    if (pathMatch) {
      const path = pathMatch[1];
      const pathWords = path.split(/[\/\-_]/).filter(word => 
        word.length > 2 && 
        !word.match(/^\d+$/) && // Não números puros
        !word.match(/^(form|view|file|d)$/i) // Palavras muito genéricas
      );
      keywords.push(...pathWords);
    }
    
    // Mapeia palavras-chave específicas
    const keywordMap = {
      'kabum': ['KaBuM', 'Kabum', 'kabum'],
      'movidesk': ['Movidesk', 'movidesk', 'formulário', 'formulario'],
      'form': ['formulário', 'formulario', 'form'],
      'drive': ['Drive', 'drive', 'Google Drive'],
      'google': ['Google', 'google'],
      'trello': ['Trello', 'trello']
    };
    
    for (const [key, values] of Object.entries(keywordMap)) {
      if (url.toLowerCase().includes(key)) {
        keywords.push(...values);
      }
    }
    
    return [...new Set(keywords)]; // Remove duplicatas
  }

  isRelevantContext(context) {
    // Verifica se o contexto é relevante (não metadados)
    const metadataWords = ['Mozilla', 'Skia', 'PDF', 'KHTML', 'Gecko', 'Linux', 'x86_64'];
    const contextLower = context.toLowerCase();
    
    for (const word of metadataWords) {
      if (contextLower.includes(word.toLowerCase())) {
        return false;
      }
    }
    
    return context.length > 10; // Contexto deve ter pelo menos 10 caracteres
  }

  extractTitleFromContext(context) {
    // Extrai um título relevante do contexto
    const lines = context.split('\n').filter(line => line.trim().length > 0);
    
    // Procura por linhas que parecem títulos (curtas, sem pontuação no final)
    for (const line of lines) {
      const trimmed = line.trim();
      if (trimmed.length > 5 && trimmed.length < 100 && !trimmed.endsWith('.')) {
        return trimmed;
      }
    }
    
    // Se não encontrou título, retorna as primeiras palavras do contexto
    const words = context.split(/\s+/).slice(0, 5).join(' ');
    return words || 'Texto relacionado';
  }

  escapeRegex(string) {
    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  }

  async saveResults(data, inputPath) {
    const baseName = basename(inputPath, extname(inputPath));
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
    
    // Determina o caminho de saída
    let outputDir = '.';
    let fileName = `${baseName}_data_${timestamp}.json`;
    
    if (this.outputPath) {
      outputDir = this.outputPath;
      
      // Se preserveStructure está ativo, mantém a estrutura de pastas
      if (this.preserveStructure && this.basePath) {
        const relativePath = inputPath.replace(this.basePath, '').replace(/^\//, '');
        const relativeDir = join(outputDir, relativePath.replace(basename(inputPath), ''));
        
        // Cria a estrutura de pastas se necessário
        try {
          const { mkdirSync } = await import('node:fs');
          mkdirSync(relativeDir, { recursive: true });
          outputDir = relativeDir;
        } catch (error) {
          console.log(`⚠️  Erro ao criar estrutura de pastas: ${error.message}`);
        }
      }
    }
    
    const jsonPath = join(outputDir, fileName);
    
    // Salva apenas JSON com todos os dados
    writeFileSync(jsonPath, JSON.stringify(data, null, 2), 'utf8');
    
    return {
      jsonPath
    };
  }

  async convertFolder(folderPath) {
    console.log(`🔄 Iniciando conversão em lote da pasta: ${folderPath}\n`);
    
    // Define o caminho base para preservação de estrutura
    this.basePath = folderPath;
    
    // Verifica se a pasta existe
    if (!existsSync(folderPath)) {
      console.error(`❌ Erro: Pasta não encontrada: ${folderPath}`);
      process.exit(1);
    }

    // Verifica se é uma pasta
    if (!statSync(folderPath).isDirectory()) {
      console.error(`❌ Erro: O caminho deve ser uma pasta: ${folderPath}`);
      process.exit(1);
    }

    // Mostra configurações de saída
    if (this.outputPath) {
      console.log(`📁 Pasta de saída: ${this.outputPath}`);
      if (this.preserveStructure) {
        console.log(`📂 Preservando estrutura de pastas: SIM`);
      } else {
        console.log(`📂 Preservando estrutura de pastas: NÃO`);
      }
      console.log('');
    }

    // Busca todos os arquivos PDF na pasta
    const pdfFiles = this.findPDFFiles(folderPath);
    
    if (pdfFiles.length === 0) {
      console.log('⚠️  Nenhum arquivo PDF encontrado na pasta.');
      return;
    }

    console.log(`📁 Encontrados ${pdfFiles.length} arquivos PDF:`);
    pdfFiles.forEach((file, index) => {
      console.log(`   ${index + 1}. ${basename(file)}`);
    });
    console.log('');

    // Processa cada arquivo PDF
    for (let i = 0; i < pdfFiles.length; i++) {
      const filePath = pdfFiles[i];
      const fileName = basename(filePath);
      
      console.log(`📄 [${i + 1}/${pdfFiles.length}] Processando: ${fileName}`);
      
      try {
        const startTime = Date.now();
        const data = await this.extractFromPDF(filePath);
        const endTime = Date.now();
        const processingTime = endTime - startTime;
        
        // Salva os resultados
        const paths = await this.saveResults(data, filePath);
        
        const result = {
          file: fileName,
          path: filePath,
          success: true,
          processingTime: processingTime,
          outputFile: paths.jsonPath,
          stats: {
            pages: data.pages,
            hyperlinks: data.hyperlinks?.length || 0,
            textUrls: data.textUrls?.length || 0,
            totalUrls: data.urls?.length || 0,
            emails: data.emails?.length || 0,
            hyperlinkReferences: data.hyperlinkReferences?.length || 0,
            textLength: data.text?.length || 0
          }
        };
        
        this.results.push(result);
        this.processedCount++;
        
        console.log(`✅ Concluído em ${processingTime}ms`);
        console.log(`   📊 Páginas: ${result.stats.pages}`);
        console.log(`   🔗 Hyperlinks: ${result.stats.hyperlinks}`);
        console.log(`   📧 Emails: ${result.stats.emails}`);
        console.log(`   📍 Referências: ${result.stats.hyperlinkReferences}`);
        console.log(`   💾 Salvo em: ${basename(paths.jsonPath)}\n`);
        
      } catch (error) {
        console.error(`❌ Erro ao processar ${fileName}: ${error.message}\n`);
        this.errorCount++;
        
        this.results.push({
          file: fileName,
          path: filePath,
          success: false,
          error: error.message
        });
      }
    }

    // Exibe resumo final
    this.showSummary();
  }

  findPDFFiles(folderPath) {
    const pdfFiles = [];
    
    try {
      const items = readdirSync(folderPath);
      
      for (const item of items) {
        const itemPath = join(folderPath, item);
        const stat = statSync(itemPath);
        
        if (stat.isFile() && extname(item).toLowerCase() === '.pdf') {
          pdfFiles.push(itemPath);
        } else if (stat.isDirectory()) {
          // Busca recursivamente em subpastas
          const subPdfs = this.findPDFFiles(itemPath);
          pdfFiles.push(...subPdfs);
        }
      }
    } catch (error) {
      console.error(`❌ Erro ao ler pasta ${folderPath}: ${error.message}`);
    }
    
    return pdfFiles;
  }

  showSummary() {
    console.log('='.repeat(60));
    console.log('📊 RESUMO DA CONVERSÃO EM LOTE');
    console.log('='.repeat(60));
    console.log(`✅ Arquivos processados com sucesso: ${this.processedCount}`);
    console.log(`❌ Arquivos com erro: ${this.errorCount}`);
    console.log(`📁 Total de arquivos: ${this.results.length}`);
    
    if (this.processedCount > 0) {
      const totalHyperlinks = this.results
        .filter(r => r.success)
        .reduce((sum, r) => sum + r.stats.hyperlinks, 0);
      const totalEmails = this.results
        .filter(r => r.success)
        .reduce((sum, r) => sum + r.stats.emails, 0);
      const totalReferences = this.results
        .filter(r => r.success)
        .reduce((sum, r) => sum + r.stats.hyperlinkReferences, 0);
      
      console.log(`🔗 Total de hyperlinks encontrados: ${totalHyperlinks}`);
      console.log(`📧 Total de emails encontrados: ${totalEmails}`);
      console.log(`📍 Total de referências encontradas: ${totalReferences}`);
    }
    
    if (this.errorCount > 0) {
      console.log('\n❌ Arquivos com erro:');
      this.results
        .filter(r => !r.success)
        .forEach(r => console.log(`   - ${r.file}: ${r.error}`));
    }
    
    console.log('\n🎉 Conversão em lote concluída!');
  }
}

// Função principal
async function main() {
  const args = process.argv.slice(2);
  
  if (args.length === 0) {
    console.log(`
🔄 PDF Batch Extractor

📁 USO: bun batchExtract.js <caminho-da-pasta> [opções]

📄 EXEMPLOS:
   bun batchExtract.js ./pdfs/
   bun batchExtract.js /caminho/para/pasta/pdf/
   bun batchExtract.js . --output ./resultados/
   bun batchExtract.js ./pdfs/ --output ./saida/ --preserve-structure

🚩 OPÇÕES:
   --output <pasta>        Pasta onde salvar os arquivos JSON
   --preserve-structure    Manter a mesma estrutura de pastas da origem

💡 FUNCIONALIDADES:
   - Processa todos os PDFs de uma pasta
   - Busca recursivamente em subpastas
   - Gera arquivo JSON para cada PDF
   - Exibe resumo detalhado
   - Tratamento de erros individual
   - Controle de pasta de saída
   - Preservação de estrutura de pastas

📋 PRÉ-REQUISITOS:
   - Bun instalado
   - Poppler Utils (pdftotext) instalado
   - Dependências: bun install
    `);
    process.exit(1);
  }

  // Processa argumentos
  let folderPath = null;
  let outputPath = null;
  let preserveStructure = false;
  
  for (let i = 0; i < args.length; i++) {
    const arg = args[i];
    
    if (arg === '--output' && i + 1 < args.length) {
      outputPath = args[i + 1];
      i++; // Pula o próximo argumento
    } else if (arg === '--preserve-structure') {
      preserveStructure = true;
    } else if (!folderPath && !arg.startsWith('--')) {
      folderPath = arg;
    }
  }
  
  if (!folderPath) {
    console.error('❌ Erro: Caminho da pasta é obrigatório');
    process.exit(1);
  }
  
  try {
    const converter = new PDFBatchExtractor(outputPath, preserveStructure);
    await converter.convertFolder(folderPath);
  } catch (error) {
    console.error(`❌ Erro fatal: ${error.message}`);
    process.exit(1);
  }
}

// Executa o script
main().catch(console.error);