parsepdf.js

#!/usr/bin/env node
/**
 * PDF to Text parser - mimics ATS (Applicant Tracking System) text extraction.
 * Uses three different PDF parsing libraries for comparison.
 */

import { readFile, writeFile } from 'fs/promises';
import { existsSync } from 'fs';
import { basename, dirname, join } from 'path';
import { createRequire } from 'module';

// pdf-parse
import pdfParse from 'pdf-parse/lib/pdf-parse.js';

// pdfjs-dist
import { getDocument } from 'pdfjs-dist/legacy/build/pdf.mjs';

// pdf2json
const require = createRequire(import.meta.url);
const PDFParser = require('pdf2json');

function getOutputPath(inputPath, library) {
  const dir = dirname(inputPath);
  const name = basename(inputPath, '.pdf');
  return join(dir, `${name}.${library}.txt`);
}

async function parseWithPdfParse(pdfPath) {
  const dataBuffer = await readFile(pdfPath);
  const data = await pdfParse(dataBuffer, {
    normalizeWhitespace: false,
    disableCombineTextItems: false,
  });
  return data.text;
}

async function parseWithPdfjs(pdfPath) {
  const dataBuffer = await readFile(pdfPath);
  const uint8Array = new Uint8Array(dataBuffer);
  const doc = await getDocument({ data: uint8Array }).promise;

  const textParts = [];
  for (let i = 1; i <= doc.numPages; i++) {
    const page = await doc.getPage(i);
    const textContent = await page.getTextContent();
    const pageText = textContent.items
      .map(item => item.str)
      .join(' ');
    textParts.push(pageText);
  }

  return textParts.join('\n');
}

async function parseWithPdf2json(pdfPath) {
  return new Promise((resolve, reject) => {
    const pdfParser = new PDFParser(null, 1); // 1 = don't combine text items

    pdfParser.on('pdfParser_dataError', err => reject(err.parserError));
    pdfParser.on('pdfParser_dataReady', pdfData => {
      // Extract text from all pages
      const textParts = [];
      if (pdfData.Pages) {
        for (const page of pdfData.Pages) {
          if (page.Texts) {
            for (const textItem of page.Texts) {
              if (textItem.R) {
                for (const r of textItem.R) {
                  if (r.T) {
                    textParts.push(decodeURIComponent(r.T));
                  }
                }
              }
            }
          }
          textParts.push('\n');
        }
      }
      resolve(textParts.join(' '));
    });

    pdfParser.loadPDF(pdfPath);
  });
}

async function main() {
  const args = process.argv.slice(2);

  if (args.length === 0 || args.includes('-h') || args.includes('--help')) {
    console.log('Usage: node parsepdf.js <pdf_file>');
    console.log('Output: Creates three files:');
    console.log('  <filename>.pdfparse.txt');
    console.log('  <filename>.pdfjs.txt');
    console.log('  <filename>.pdf2json.txt');
    process.exit(args.length === 0 ? 1 : 0);
  }

  const pdfPath = args[0];

  if (!existsSync(pdfPath)) {
    console.error(`Error: File not found: ${pdfPath}`);
    process.exit(1);
  }

  const parsers = [
    { name: 'pdfparse', fn: parseWithPdfParse },
    { name: 'pdfjs', fn: parseWithPdfjs },
    { name: 'pdf2json', fn: parseWithPdf2json },
  ];

  for (const { name, fn } of parsers) {
    try {
      const text = await fn(pdfPath);
      const outputPath = getOutputPath(pdfPath, name);
      await writeFile(outputPath, text, 'utf-8');
      console.log(`Output written to: ${outputPath}`);
    } catch (err) {
      console.error(`Error with ${name}: ${err.message}`);
    }
  }
}

main();