noupload 1.0.0

package/src/commands/pdf/ocr.ts

@@ -0,0 +1,270 @@
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, rmdirSync, unlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import { defineCommand } from 'citty';
+import Tesseract from 'tesseract.js';
+import { detectMutool, detectTool, getInstallCommand } from '../../utils/detect';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import {
+  ensureDir,
+  generateOutputPath,
+  getBasename,
+  getExtension,
+  resolvePath,
+} from '../../utils/files';
+import { info, success, warn } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+// Convert PDF to images using available tools
+async function pdfToImages(pdfPath: string, outputDir: string): Promise<string[]> {
+  // Try mutool first
+  const mutool = await detectMutool();
+  if (mutool.available && mutool.path) {
+    return await convertWithMutool(mutool.path, pdfPath, outputDir);
+  }
+
+  // Try pdftocairo (poppler)
+  const pdftocairo = await detectTool('pdftocairo');
+  if (pdftocairo.available && pdftocairo.path) {
+    return await convertWithPdftocairo(pdftocairo.path, pdfPath, outputDir);
+  }
+
+  // Try pdftoppm (poppler alternative)
+  const pdftoppm = await detectTool('pdftoppm');
+  if (pdftoppm.available && pdftoppm.path) {
+    return await convertWithPdftoppm(pdftoppm.path, pdfPath, outputDir);
+  }
+
+  throw new Error(
+    'No PDF-to-image converter found.\n\n' +
+      'Install one of these:\n' +
+      '  • mupdf-tools: brew install mupdf-tools (macOS) | apt install mupdf-tools (Linux)\n' +
+      '  • poppler: brew install poppler (macOS) | apt install poppler-utils (Linux)'
+  );
+}
+
+async function convertWithMutool(
+  mutoolPath: string,
+  pdfPath: string,
+  outputDir: string
+): Promise<string[]> {
+  const outputPattern = join(outputDir, 'page-%d.png');
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(mutoolPath, ['draw', '-o', outputPattern, '-r', '300', pdfPath], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let stderr = '';
+    proc.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        const files = readdirSync(outputDir)
+          .filter((f) => f.startsWith('page-') && f.endsWith('.png'))
+          .sort((a, b) => {
+            const numA = Number.parseInt(a.match(/\d+/)?.[0] || '0', 10);
+            const numB = Number.parseInt(b.match(/\d+/)?.[0] || '0', 10);
+            return numA - numB;
+          })
+          .map((f) => join(outputDir, f));
+        resolve(files);
+      } else {
+        reject(new Error(`mutool failed: ${stderr}`));
+      }
+    });
+
+    proc.on('error', reject);
+  });
+}
+
+async function convertWithPdftocairo(
+  toolPath: string,
+  pdfPath: string,
+  outputDir: string
+): Promise<string[]> {
+  const outputPrefix = join(outputDir, 'page');
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(toolPath, ['-png', '-r', '300', pdfPath, outputPrefix], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let stderr = '';
+    proc.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        const files = readdirSync(outputDir)
+          .filter((f) => f.startsWith('page') && f.endsWith('.png'))
+          .sort()
+          .map((f) => join(outputDir, f));
+        resolve(files);
+      } else {
+        reject(new Error(`pdftocairo failed: ${stderr}`));
+      }
+    });
+
+    proc.on('error', reject);
+  });
+}
+
+async function convertWithPdftoppm(
+  toolPath: string,
+  pdfPath: string,
+  outputDir: string
+): Promise<string[]> {
+  const outputPrefix = join(outputDir, 'page');
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(toolPath, ['-png', '-r', '300', pdfPath, outputPrefix], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let stderr = '';
+    proc.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        const files = readdirSync(outputDir)
+          .filter((f) => f.startsWith('page') && f.endsWith('.png'))
+          .sort()
+          .map((f) => join(outputDir, f));
+        resolve(files);
+      } else {
+        reject(new Error(`pdftoppm failed: ${stderr}`));
+      }
+    });
+
+    proc.on('error', reject);
+  });
+}
+
+// Clean up temp directory
+function cleanupTempDir(dir: string) {
+  try {
+    const files = readdirSync(dir);
+    for (const file of files) {
+      unlinkSync(join(dir, file));
+    }
+    rmdirSync(dir);
+  } catch {
+    // Ignore cleanup errors
+  }
+}
+
+export const ocr = defineCommand({
+  meta: {
+    name: 'ocr',
+    description: 'Perform OCR on a PDF or image to extract text',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF or image file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output text file path',
+    },
+    lang: {
+      type: 'string',
+      alias: 'l',
+      description: 'Language(s) for OCR (e.g., "eng", "eng+fra")',
+      default: 'eng',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const ext = getExtension(inputPath).toLowerCase();
+      const lang = args.lang || 'eng';
+      const outputPath = generateOutputPath(inputPath, args.output, '-ocr', 'txt');
+      ensureDir(outputPath);
+
+      let imagePaths: string[] = [];
+      let tempDir: string | null = null;
+
+      // If PDF, convert to images first
+      if (ext === 'pdf') {
+        tempDir = join(tmpdir(), `noupload-ocr-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+
+        const tempDirPath = tempDir;
+        imagePaths = await withSpinner(
+          'Converting PDF to images...',
+          async () => await pdfToImages(inputPath, tempDirPath),
+          'PDF converted to images'
+        );
+
+        info(`Processing ${imagePaths.length} pages...`);
+      } else {
+        imagePaths = [inputPath];
+      }
+
+      info(`Starting OCR with language: ${lang}`);
+
+      const allText: string[] = [];
+      let totalWords = 0;
+      let avgConfidence = 0;
+
+      // Process each image
+      for (let i = 0; i < imagePaths.length; i++) {
+        const imagePath = imagePaths[i];
+        const pageNum = i + 1;
+
+        const result = await withSpinner(
+          `OCR page ${pageNum}/${imagePaths.length}...`,
+          async () => {
+            return await Tesseract.recognize(imagePath, lang);
+          },
+          `Page ${pageNum} complete`
+        );
+
+        allText.push(result.data.text);
+        totalWords += result.data.words.length;
+        avgConfidence += result.data.confidence;
+      }
+
+      avgConfidence = avgConfidence / imagePaths.length;
+
+      // Combine and save text
+      const combinedText = allText.join('\n\n--- Page Break ---\n\n');
+      await Bun.write(outputPath, combinedText);
+
+      // Cleanup temp files
+      if (tempDir) {
+        cleanupTempDir(tempDir);
+      }
+
+      console.log();
+      info(`Pages processed: ${imagePaths.length}`);
+      info(`Average confidence: ${avgConfidence.toFixed(1)}%`);
+      info(`Total words found: ${totalWords}`);
+
+      if (avgConfidence < 70) {
+        warn('Low confidence - the scan quality may be poor or try a different language.');
+      }
+
+      console.log();
+      success(`OCR complete. Text saved to: ${outputPath}`);
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/pdf/organize.ts

@@ -0,0 +1,88 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { PDFDocument } from 'pdf-lib';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, info, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const organize = defineCommand({
+  meta: {
+    name: 'organize',
+    description: 'Reorder pages in a PDF',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    order: {
+      type: 'string',
+      description: 'New page order (comma-separated, 1-indexed). e.g., "3,1,2,5,4"',
+      required: true,
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const order = requireArg(args.order, 'order');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-organized');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+
+      // Parse page order
+      const pageOrder = order.split(',').map((s) => Number.parseInt(s.trim(), 10) - 1);
+
+      await withSpinner(
+        'Reorganizing pages...',
+        async () => {
+          const pdfBytes = await Bun.file(inputPath).arrayBuffer();
+          const sourcePdf = await PDFDocument.load(pdfBytes);
+          const newPdf = await PDFDocument.create();
+
+          const totalPages = sourcePdf.getPageCount();
+
+          // Validate page numbers
+          for (const pageNum of pageOrder) {
+            if (pageNum < 0 || pageNum >= totalPages) {
+              throw new Error(`Invalid page number: ${pageNum + 1}. PDF has ${totalPages} pages.`);
+            }
+          }
+
+          // Copy pages in new order
+          const copiedPages = await newPdf.copyPages(sourcePdf, pageOrder);
+          for (const page of copiedPages) {
+            newPdf.addPage(page);
+          }
+
+          const organizedBytes = await newPdf.save();
+          await Bun.write(outputPath, organizedBytes);
+        },
+        'Pages reorganized successfully'
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      info(`New page order: ${order}`);
+      success('PDF pages reorganized');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/pdf/page-numbers.ts

@@ -0,0 +1,152 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { PDFDocument, StandardFonts, rgb } from 'pdf-lib';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+type PagePosition = 'top' | 'bottom';
+type HorizontalAlign = 'left' | 'center' | 'right';
+
+export const pageNumbers = defineCommand({
+  meta: {
+    name: 'page-numbers',
+    description: 'Add page numbers to a PDF',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    format: {
+      type: 'string',
+      alias: 'f',
+      description: 'Number format. Use {n} for current page, {total} for total pages',
+      default: 'Page {n} of {total}',
+    },
+    position: {
+      type: 'string',
+      alias: 'p',
+      description: 'Position: top, bottom',
+      default: 'bottom',
+    },
+    align: {
+      type: 'string',
+      alias: 'a',
+      description: 'Alignment: left, center, right',
+      default: 'center',
+    },
+    size: {
+      type: 'string',
+      alias: 's',
+      description: 'Font size',
+      default: '12',
+    },
+    start: {
+      type: 'string',
+      description: 'Starting page number',
+      default: '1',
+    },
+    x: {
+      type: 'string',
+      description: 'Custom X coordinate (overrides position/align)',
+    },
+    y: {
+      type: 'string',
+      description: 'Custom Y coordinate (overrides position)',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-numbered');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const format = args.format || 'Page {n} of {total}';
+      const position = (args.position || 'bottom') as PagePosition;
+      const align = (args.align || 'center') as HorizontalAlign;
+      const fontSize = Number.parseInt(args.size || '12', 10);
+      const startNumber = Number.parseInt(args.start || '1', 10);
+      const customX = args.x ? Number.parseInt(args.x, 10) : undefined;
+      const customY = args.y ? Number.parseInt(args.y, 10) : undefined;
+
+      await withSpinner(
+        'Adding page numbers...',
+        async () => {
+          const pdfBytes = await Bun.file(inputPath).arrayBuffer();
+          const pdf = await PDFDocument.load(pdfBytes);
+          const font = await pdf.embedFont(StandardFonts.Helvetica);
+          const pages = pdf.getPages();
+          const totalPages = pages.length;
+
+          for (let i = 0; i < pages.length; i++) {
+            const page = pages[i];
+            const { width, height } = page.getSize();
+            const pageNum = startNumber + i;
+
+            const text = format
+              .replace('{n}', String(pageNum))
+              .replace('{total}', String(totalPages + startNumber - 1));
+
+            const textWidth = font.widthOfTextAtSize(text, fontSize);
+
+            let x: number;
+            let y: number;
+
+            if (customX !== undefined && customY !== undefined) {
+              x = customX;
+              y = customY;
+            } else {
+              switch (align) {
+                case 'left':
+                  x = 50;
+                  break;
+                case 'right':
+                  x = width - textWidth - 50;
+                  break;
+                default:
+                  x = (width - textWidth) / 2;
+              }
+              y = position === 'top' ? height - 30 : 30;
+            }
+
+            page.drawText(text, {
+              x,
+              y,
+              size: fontSize,
+              font,
+              color: rgb(0, 0, 0),
+            });
+          }
+
+          const numberedBytes = await pdf.save();
+          await Bun.write(outputPath, numberedBytes);
+        },
+        'Page numbers added successfully'
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Added page numbers to PDF');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/pdf/reverse.ts

@@ -0,0 +1,71 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { PDFDocument } from 'pdf-lib';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const reverse = defineCommand({
+  meta: {
+    name: 'reverse',
+    description: 'Reverse the order of all pages in a PDF',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-reversed');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+
+      await withSpinner(
+        'Reversing page order...',
+        async () => {
+          const pdfBytes = await Bun.file(inputPath).arrayBuffer();
+          const sourcePdf = await PDFDocument.load(pdfBytes);
+          const newPdf = await PDFDocument.create();
+
+          const totalPages = sourcePdf.getPageCount();
+          const reversedOrder = Array.from({ length: totalPages }, (_, i) => totalPages - 1 - i);
+
+          const copiedPages = await newPdf.copyPages(sourcePdf, reversedOrder);
+          for (const page of copiedPages) {
+            newPdf.addPage(page);
+          }
+
+          const reversedBytes = await newPdf.save();
+          await Bun.write(outputPath, reversedBytes);
+        },
+        'Page order reversed successfully'
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('PDF page order reversed');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/pdf/rotate.ts

@@ -0,0 +1,116 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { PDFDocument, degrees } from 'pdf-lib';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureDir, generateOutputPath, getFileSize, resolvePath } from '../../utils/files';
+import { fileResult, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+function parsePages(pagesStr: string, totalPages: number): number[] {
+  if (!pagesStr) {
+    return Array.from({ length: totalPages }, (_, i) => i);
+  }
+
+  const pages: Set<number> = new Set();
+  const parts = pagesStr.split(',').map((s) => s.trim());
+
+  for (const part of parts) {
+    if (part.includes('-')) {
+      const [start, end] = part.split('-').map((s) => Number.parseInt(s.trim(), 10));
+      for (let i = Math.max(1, start); i <= Math.min(totalPages, end); i++) {
+        pages.add(i - 1);
+      }
+    } else {
+      const page = Number.parseInt(part, 10);
+      if (page >= 1 && page <= totalPages) {
+        pages.add(page - 1);
+      }
+    }
+  }
+
+  return Array.from(pages);
+}
+
+export const rotate = defineCommand({
+  meta: {
+    name: 'rotate',
+    description: 'Rotate pages in a PDF',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input PDF file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    angle: {
+      type: 'string',
+      alias: 'a',
+      description: 'Rotation angle: 90, 180, 270, -90',
+      required: true,
+    },
+    pages: {
+      type: 'string',
+      alias: 'p',
+      description: 'Pages to rotate (e.g., "1,3,5" or "1-5"). Default: all pages',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const angle = requireArg(args.angle, 'angle');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const rotationAngle = Number.parseInt(angle, 10);
+      if (![90, 180, 270, -90, -180, -270].includes(rotationAngle)) {
+        throw new Error('Rotation angle must be 90, 180, 270, or their negative values');
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-rotated');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+
+      await withSpinner(
+        `Rotating pages by ${rotationAngle}°...`,
+        async () => {
+          const pdfBytes = await Bun.file(inputPath).arrayBuffer();
+          const pdf = await PDFDocument.load(pdfBytes);
+          const totalPages = pdf.getPageCount();
+
+          const pagesToRotate = parsePages(args.pages || '', totalPages);
+          const allPages = pdf.getPages();
+
+          for (const pageIndex of pagesToRotate) {
+            const page = allPages[pageIndex];
+            if (page) {
+              const currentRotation = page.getRotation().angle;
+              page.setRotation(degrees(currentRotation + rotationAngle));
+            }
+          }
+
+          const rotatedBytes = await pdf.save();
+          await Bun.write(outputPath, rotatedBytes);
+        },
+        'PDF rotated successfully'
+      );
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success(`Rotated PDF pages by ${rotationAngle}°`);
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});