noupload 1.0.0

package/src/utils/pdf-tools.ts

@@ -0,0 +1,220 @@
+import { spawn } from 'node:child_process';
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { detectMutool, detectTool } from './detect';
+
+export interface ImageConversionOptions {
+  pdfPath: string;
+  outputDir: string;
+  dpi?: number;
+  format?: 'png' | 'jpg';
+  basename?: string;
+}
+
+export async function convertPdfToImages(options: ImageConversionOptions): Promise<string[]> {
+  const { pdfPath, outputDir, dpi = 300, format = 'png', basename = 'page' } = options;
+
+  // Try mutool first
+  const mutool = await detectMutool();
+  if (mutool.available && mutool.path) {
+    return await convertWithMutool(mutool.path, pdfPath, outputDir, dpi, format, basename);
+  }
+
+  // Try pdftocairo (poppler)
+  const pdftocairo = await detectTool('pdftocairo');
+  if (pdftocairo.available && pdftocairo.path) {
+    return await convertWithPdftocairo(pdftocairo.path, pdfPath, outputDir, dpi, format, basename);
+  }
+
+  // Try pdftoppm (poppler alternative)
+  const pdftoppm = await detectTool('pdftoppm');
+  if (pdftoppm.available && pdftoppm.path) {
+    return await convertWithPdftoppm(pdftoppm.path, pdfPath, outputDir, dpi, format, basename);
+  }
+
+  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)'
+  );
+}
+
+export async function extractPdfText(pdfPath: string, outputPath: string): Promise<void> {
+  // Try pdftotext (poppler)
+  const pdftotext = await detectTool('pdftotext');
+  if (pdftotext.available && pdftotext.path) {
+    const pdftotextPath = pdftotext.path;
+    return new Promise((resolve, reject) => {
+      const proc = spawn(pdftotextPath, ['-layout', pdfPath, outputPath], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      let stderr = '';
+      proc.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      proc.on('close', (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`pdftotext failed: ${stderr}`));
+      });
+
+      proc.on('error', reject);
+    });
+  }
+
+  // Try mutool (mupdf)
+  const mutool = await detectMutool();
+  if (mutool.available && mutool.path) {
+    const mutoolPath = mutool.path;
+    return new Promise((resolve, reject) => {
+      // mutool draw -F text -o output.txt input.pdf
+      const proc = spawn(mutoolPath, ['draw', '-F', 'text', '-o', outputPath, pdfPath], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      let stderr = '';
+      proc.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      proc.on('close', (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`mutool failed: ${stderr}`));
+      });
+
+      proc.on('error', reject);
+    });
+  }
+
+  throw new Error(
+    'No PDF-to-text converter found.\n\n' +
+      'Install one of these:\n' +
+      '  • poppler: brew install poppler (macOS) | apt install poppler-utils (Linux)\n' +
+      '  • mupdf-tools: brew install mupdf-tools (macOS) | apt install mupdf-tools (Linux)'
+  );
+}
+
+async function convertWithMutool(
+  mutoolPath: string,
+  pdfPath: string,
+  outputDir: string,
+  dpi: number,
+  format: 'png' | 'jpg',
+  basename: string
+): Promise<string[]> {
+  const outputPattern = join(outputDir, `${basename}-%d.${format}`);
+
+  return new Promise((resolve, reject) => {
+    const args = ['draw', '-o', outputPattern, '-r', dpi.toString(), pdfPath];
+    const proc = spawn(mutoolPath, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+
+    let stderr = '';
+    proc.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        try {
+          const files = readdirSync(outputDir)
+            .filter((f) => f.startsWith(basename) && f.endsWith(`.${format}`))
+            .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);
+        } catch (e) {
+          reject(e);
+        }
+      } else {
+        reject(new Error(`mutool failed: ${stderr}`));
+      }
+    });
+
+    proc.on('error', reject);
+  });
+}
+
+async function convertWithPdftocairo(
+  toolPath: string,
+  pdfPath: string,
+  outputDir: string,
+  dpi: number,
+  format: 'png' | 'jpg',
+  basename: string
+): Promise<string[]> {
+  const outputPrefix = join(outputDir, basename);
+  const fmtFlag = format === 'png' ? '-png' : '-jpeg';
+
+  return new Promise((resolve, reject) => {
+    const args = [fmtFlag, '-r', dpi.toString(), pdfPath, outputPrefix];
+    const proc = spawn(toolPath, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+
+    let stderr = '';
+    proc.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        try {
+          const files = readdirSync(outputDir)
+            .filter((f) => f.startsWith(basename) && f.endsWith(`.${format}`))
+            .sort()
+            .map((f) => join(outputDir, f));
+          resolve(files);
+        } catch (e) {
+          reject(e);
+        }
+      } else {
+        reject(new Error(`pdftocairo failed: ${stderr}`));
+      }
+    });
+
+    proc.on('error', reject);
+  });
+}
+
+async function convertWithPdftoppm(
+  toolPath: string,
+  pdfPath: string,
+  outputDir: string,
+  dpi: number,
+  format: 'png' | 'jpg',
+  basename: string
+): Promise<string[]> {
+  const outputPrefix = join(outputDir, basename);
+  const fmtFlag = format === 'png' ? '-png' : '-jpeg';
+
+  return new Promise((resolve, reject) => {
+    const args = [fmtFlag, '-r', dpi.toString(), pdfPath, outputPrefix];
+    const proc = spawn(toolPath, args, { stdio: ['pipe', 'pipe', 'pipe'] });
+
+    let stderr = '';
+    proc.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        try {
+          const files = readdirSync(outputDir)
+            .filter((f) => f.startsWith(basename) && f.endsWith(`.${format}`))
+            .sort()
+            .map((f) => join(outputDir, f));
+          resolve(files);
+        } catch (e) {
+          reject(e);
+        }
+      } else {
+        reject(new Error(`pdftoppm failed: ${stderr}`));
+      }
+    });
+
+    proc.on('error', reject);
+  });
+}

package/src/utils/progress.ts

@@ -0,0 +1,142 @@
+import cliProgress from 'cli-progress';
+import ora, { type Ora } from 'ora';
+import { c } from './style';
+
+const IS_TTY = process.stdout.isTTY && !process.env.CI;
+
+// Spinner for quick operations
+export function createSpinner(text: string): Ora {
+  return ora({
+    text,
+    spinner: 'dots',
+    color: 'yellow', // ora doesn't support custom hex, 'yellow' is closest to our orange theme
+    isEnabled: IS_TTY,
+  });
+}
+
+// Progress bar for long operations
+export function createProgressBar(format?: string): cliProgress.SingleBar {
+  return new cliProgress.SingleBar(
+    {
+      format:
+        format ||
+        `  ${c.active('{bar}')} ${c.dim('|')} {percentage}% ${c.dim('|')} {value}/{total} ${c.dim('|')} {task}`,
+      barCompleteChar: '█',
+      barIncompleteChar: '░',
+      hideCursor: true,
+      clearOnComplete: false,
+      stopOnComplete: true,
+      noTTYOutput: !IS_TTY,
+    },
+    cliProgress.Presets.shades_classic
+  );
+}
+
+// Multi-bar for parallel operations
+export function createMultiBar(): cliProgress.MultiBar {
+  return new cliProgress.MultiBar(
+    {
+      format: `  ${c.active('{bar}')} ${c.dim('|')} {percentage}% ${c.dim('|')} {filename}`,
+      barCompleteChar: '█',
+      barIncompleteChar: '░',
+      hideCursor: true,
+      clearOnComplete: false,
+      stopOnComplete: true,
+      noTTYOutput: !IS_TTY,
+    },
+    cliProgress.Presets.shades_classic
+  );
+}
+
+// Simple task runner with spinner
+export async function withSpinner<T>(
+  text: string,
+  task: () => Promise<T>,
+  successText?: string
+): Promise<T> {
+  // Non-TTY Fallback: Simple logging
+  if (!IS_TTY) {
+    console.log(`- ${text}`);
+    try {
+      const result = await task();
+      if (successText) console.log(`✔ ${successText}`);
+      return result;
+    } catch (err) {
+      console.error(`✖ ${text} failed`);
+      throw err;
+    }
+  }
+
+  const spinner = createSpinner(text);
+  spinner.start();
+
+  try {
+    const result = await task();
+    spinner.succeed(successText || text);
+    return result;
+  } catch (err) {
+    spinner.fail(text);
+    throw err;
+  }
+}
+
+// Progress wrapper for array operations
+export async function withProgress<T, R>(
+  items: T[],
+  taskName: string,
+  processor: (item: T, index: number) => Promise<R>
+): Promise<R[]> {
+  // Non-TTY Fallback
+  if (!IS_TTY) {
+    console.log(`- ${taskName} (${items.length} items)...`);
+    const results: R[] = [];
+    for (let i = 0; i < items.length; i++) {
+      results.push(await processor(items[i], i));
+    }
+    console.log(`✔ ${taskName} complete`);
+    return results;
+  }
+
+  const bar = createProgressBar();
+  bar.start(items.length, 0, { task: taskName });
+
+  const results: R[] = [];
+
+  for (let i = 0; i < items.length; i++) {
+    const result = await processor(items[i], i);
+    results.push(result);
+    bar.update(i + 1, { task: `${taskName} (${i + 1}/${items.length})` });
+  }
+
+  bar.stop();
+  return results;
+}
+
+// Progress bar wrapper for batch operations
+export async function withProgressBar<T>(
+  items: T[],
+  processor: (item: T, index: number) => Promise<void>,
+  options?: { label?: string }
+): Promise<void> {
+  const label = options?.label || 'Processing';
+
+  // Non-TTY Fallback
+  if (!IS_TTY) {
+    console.log(`- ${label} (${items.length} items)...`);
+    for (let i = 0; i < items.length; i++) {
+      await processor(items[i], i);
+    }
+    console.log(`✔ ${label} complete`);
+    return;
+  }
+
+  const bar = createProgressBar();
+  bar.start(items.length, 0, { task: label });
+
+  for (let i = 0; i < items.length; i++) {
+    await processor(items[i], i);
+    bar.update(i + 1, { task: `${label} (${i + 1}/${items.length})` });
+  }
+
+  bar.stop();
+}

package/src/utils/style.ts

@@ -0,0 +1,38 @@
+/**
+ * TUI Style Constants
+ * Colors and symbols for the terminal UI
+ */
+
+import { hex, whiteBright } from './colors';
+
+// Colors
+export const c = {
+  title: hex('#f59e0b'), // Amber/orange - title
+  active: hex('#f59e0b'), // Amber/orange - active step, selected item
+  done: hex('#22c55e'), // Green - completed step, selected value
+  dim: hex('#6b7280'), // Gray - hints, unselected items
+  white: whiteBright, // Primary text (bright white)
+  error: hex('#ef4444'), // Red - error
+  warn: hex('#eab308'), // Yellow - warning
+  info: hex('#3b82f6'), // Blue - info
+
+  // Specific
+  modelId: hex('#4b5563'), // Dark gray
+  tagKey: hex('#22c55e'), // Green
+  tagNeedsKey: hex('#f59e0b'), // Amber/orange
+};
+
+// Symbols
+export const sym = {
+  active: '■', // Current step indicator
+  done: '✓', // Completed step indicator
+  input: '◆', // Input step indicator
+  pointer: '>', // Selection cursor
+  selected: '●', // Selected item dot
+  unselected: '○', // Unselected item dot
+  cursor: '_', // Input cursor
+  mask: '•', // Password mask character
+  info: 'ℹ',
+  warn: '⚠',
+  error: '✖',
+};

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ESNext"],
+    "types": ["bun-types"],
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "declaration": true,
+    "declarationMap": true,
+    "baseUrl": ".",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}