noupload 1.0.0

package/src/utils/colors.ts

@@ -0,0 +1,41 @@
+/**
+ * Minimal ANSI color utilities
+ * Ported from claude-switch style
+ */
+
+// Check if colors should be disabled
+const NO_COLORS =
+  !process.stdout.isTTY || process.env.NO_COLOR !== undefined || process.env.TERM === 'dumb';
+
+// Pass-through if colors disabled
+const wrap = (code: string, reset = '0') =>
+  NO_COLORS ? (s: string) => s : (s: string) => `\x1b[${code}m${s}\x1b[${reset}m`;
+
+// RGB color (24-bit)
+const rgb = (r: number, g: number, b: number) => wrap(`38;2;${r};${g};${b}`);
+
+// Hex color
+export const hex = (h: string) => {
+  const r = Number.parseInt(h.slice(1, 3), 16);
+  const g = Number.parseInt(h.slice(3, 5), 16);
+  const b = Number.parseInt(h.slice(5, 7), 16);
+  return rgb(r, g, b);
+};
+
+// Basic colors
+export const red = wrap('31');
+export const green = wrap('32');
+export const yellow = wrap('33');
+export const blue = wrap('34');
+export const cyan = wrap('36');
+export const white = wrap('37');
+export const whiteBright = wrap('97');
+export const gray = wrap('90');
+
+// Modifiers
+export const bold = wrap('1');
+export const dim = wrap('2');
+export const underline = wrap('4');
+
+// Reset
+export const reset = '\x1b[0m';

package/src/utils/detect.ts

@@ -0,0 +1,222 @@
+import { toolFound, toolNotFound } from './logger';
+
+export interface ToolInfo {
+  available: boolean;
+  path?: string;
+  version?: string;
+}
+
+// Cache for detected tools
+const toolCache = new Map<string, ToolInfo>();
+
+// Detect if a tool is available on the system
+export async function detectTool(name: string): Promise<ToolInfo> {
+  // Check cache first
+  if (toolCache.has(name)) {
+    const cached = toolCache.get(name);
+    if (cached) return cached;
+  }
+
+  try {
+    const path = Bun.which(name);
+    if (path) {
+      const info: ToolInfo = { available: true, path };
+      toolCache.set(name, info);
+      return info;
+    }
+    throw new Error('Not found');
+  } catch {
+    const info: ToolInfo = { available: false };
+    toolCache.set(name, info);
+    return info;
+  }
+}
+
+// Detect FFmpeg
+export async function detectFFmpeg(): Promise<ToolInfo> {
+  return detectTool('ffmpeg');
+}
+
+// Detect Ghostscript
+export async function detectGhostscript(): Promise<ToolInfo> {
+  // Try different names based on platform
+  const names = ['gs', 'gswin64c', 'gswin32c'];
+
+  for (const name of names) {
+    const info = await detectTool(name);
+    if (info.available) {
+      return info;
+    }
+  }
+
+  return { available: false };
+}
+
+// Detect mutool (MuPDF)
+export async function detectMutool(): Promise<ToolInfo> {
+  return detectTool('mutool');
+}
+
+// Detect qpdf
+export async function detectQpdf(): Promise<ToolInfo> {
+  return detectTool('qpdf');
+}
+
+// Detect ImageMagick
+export async function detectImageMagick(): Promise<ToolInfo> {
+  const convert = await detectTool('convert');
+  if (convert.available) return convert;
+  return detectTool('magick');
+}
+
+// Get install command for a tool
+export function getInstallCommand(tool: string): string | undefined {
+  // Return a generic help string for error messages
+  const help = getPackageMap()[tool.toLowerCase()];
+  if (!help) return undefined;
+
+  return `brew install ${help.brew} (macOS) | apt install ${help.apt} (Linux) | winget install ${help.winget} (Windows)`;
+}
+
+export interface PackageMap {
+  brew: string;
+  apt: string;
+  dnf: string;
+  pacman: string;
+  apk: string;
+  winget: string;
+  choco?: string;
+}
+
+export function getPackageMap(): Record<string, PackageMap> {
+  return {
+    ffmpeg: {
+      brew: 'ffmpeg',
+      apt: 'ffmpeg',
+      dnf: 'ffmpeg',
+      pacman: 'ffmpeg',
+      apk: 'ffmpeg',
+      winget: 'FFmpeg',
+    },
+    gs: {
+      brew: 'ghostscript',
+      apt: 'ghostscript',
+      dnf: 'ghostscript',
+      pacman: 'ghostscript',
+      apk: 'ghostscript',
+      winget: 'Ghostscript',
+    },
+    ghostscript: {
+      brew: 'ghostscript',
+      apt: 'ghostscript',
+      dnf: 'ghostscript',
+      pacman: 'ghostscript',
+      apk: 'ghostscript',
+      winget: 'Ghostscript',
+    },
+    mutool: {
+      brew: 'mupdf-tools',
+      apt: 'mupdf-tools',
+      dnf: 'mupdf',
+      pacman: 'mupdf-tools',
+      apk: 'mupdf-tools',
+      winget: 'MuPDF',
+    },
+    mupdf: {
+      brew: 'mupdf-tools',
+      apt: 'mupdf-tools',
+      dnf: 'mupdf',
+      pacman: 'mupdf-tools',
+      apk: 'mupdf-tools',
+      winget: 'MuPDF',
+    },
+    qpdf: {
+      brew: 'qpdf',
+      apt: 'qpdf',
+      dnf: 'qpdf',
+      pacman: 'qpdf',
+      apk: 'qpdf',
+      winget: 'QPDF',
+    },
+    convert: {
+      brew: 'imagemagick',
+      apt: 'imagemagick',
+      dnf: 'imagemagick',
+      pacman: 'imagemagick',
+      apk: 'imagemagick',
+      winget: 'ImageMagick',
+    },
+    magick: {
+      brew: 'imagemagick',
+      apt: 'imagemagick',
+      dnf: 'imagemagick',
+      pacman: 'imagemagick',
+      apk: 'imagemagick',
+      winget: 'ImageMagick',
+    },
+    imagemagick: {
+      brew: 'imagemagick',
+      apt: 'imagemagick',
+      dnf: 'imagemagick',
+      pacman: 'imagemagick',
+      apk: 'imagemagick',
+      winget: 'ImageMagick',
+    },
+    tesseract: {
+      brew: 'tesseract',
+      apt: 'tesseract-ocr',
+      dnf: 'tesseract',
+      pacman: 'tesseract',
+      apk: 'tesseract-ocr',
+      winget: 'Tesseract-OCR',
+    },
+    pdftotext: {
+      brew: 'poppler',
+      apt: 'poppler-utils',
+      dnf: 'poppler-utils',
+      pacman: 'poppler',
+      apk: 'poppler-utils',
+      winget: 'Poppler',
+    },
+    poppler: {
+      brew: 'poppler',
+      apt: 'poppler-utils',
+      dnf: 'poppler-utils',
+      pacman: 'poppler',
+      apk: 'poppler-utils',
+      winget: 'Poppler',
+    },
+  };
+}
+
+// Check and report tool availability
+export async function checkTool(name: string, silent = false): Promise<boolean> {
+  const info = await detectTool(name);
+
+  if (!silent) {
+    if (info.available && info.path) {
+      toolFound(name, info.path);
+    } else {
+      toolNotFound(name, getInstallCommand(name));
+    }
+  }
+
+  return info.available;
+}
+
+// Get best available PDF compressor
+export async function getBestPdfCompressor(): Promise<'ghostscript' | 'mutool' | 'builtin'> {
+  const gs = await detectGhostscript();
+  if (gs.available) return 'ghostscript';
+
+  const mutool = await detectMutool();
+  if (mutool.available) return 'mutool';
+
+  return 'builtin';
+}
+
+// Get best available audio processor
+export async function getBestAudioProcessor(): Promise<'ffmpeg' | 'wasm'> {
+  const ffmpeg = await detectFFmpeg();
+  return ffmpeg.available ? 'ffmpeg' : 'wasm';
+}

package/src/utils/errors.ts

@@ -0,0 +1,89 @@
+import { error as logError } from './logger';
+import { c } from './style';
+
+export class NoUploadError extends Error {
+  constructor(
+    message: string,
+    public suggestion?: string,
+    public code?: string
+  ) {
+    super(message);
+    this.name = 'NoUploadError';
+  }
+}
+
+export class FileNotFoundError extends NoUploadError {
+  constructor(path: string) {
+    super(
+      `File not found: ${path}`,
+      'Check if the file path is correct and the file exists.',
+      'FILE_NOT_FOUND'
+    );
+  }
+}
+
+export class InvalidFileTypeError extends NoUploadError {
+  constructor(path: string, expected: string[]) {
+    super(
+      `Invalid file type: ${path}`,
+      `Expected file types: ${expected.join(', ')}`,
+      'INVALID_FILE_TYPE'
+    );
+  }
+}
+
+export class ToolNotFoundError extends NoUploadError {
+  constructor(tool: string, installCmd?: string) {
+    super(
+      `Required tool not found: ${tool}`,
+      installCmd ? `Install with: ${installCmd}` : undefined,
+      'TOOL_NOT_FOUND'
+    );
+  }
+}
+
+export class ProcessingError extends NoUploadError {
+  constructor(message: string, suggestion?: string) {
+    super(message, suggestion, 'PROCESSING_ERROR');
+  }
+}
+
+// Error handler for CLI
+export function handleError(err: unknown): never {
+  if (err instanceof NoUploadError) {
+    logError(err.message, err.suggestion);
+  } else if (err instanceof Error) {
+    logError(err.message);
+    if (process.env.DEBUG) {
+      console.error(c.dim(err.stack || ''));
+    }
+  } else {
+    logError(String(err));
+  }
+
+  process.exit(1);
+}
+
+// Wrap async function with error handling
+// biome-ignore lint/suspicious/noExplicitAny: generic function constraint
+export function withErrorHandling<T extends (...args: any[]) => Promise<any>>(fn: T): T {
+  return (async (...args: Parameters<T>) => {
+    try {
+      return await fn(...args);
+    } catch (err) {
+      handleError(err);
+    }
+  }) as T;
+}
+
+// Validate required arguments
+export function requireArg<T>(value: T | undefined, name: string, message?: string): T {
+  if (value === undefined || value === null || value === '') {
+    throw new NoUploadError(
+      message || `Missing required argument: ${name}`,
+      `Provide the ${name} argument.`,
+      'MISSING_ARG'
+    );
+  }
+  return value;
+}

package/src/utils/files.ts

@@ -0,0 +1,148 @@
+import { existsSync, mkdirSync, statSync } from 'node:fs';
+import { basename, dirname, extname, join, resolve } from 'node:path';
+
+// Ensure directory exists
+export function ensureDir(path: string): void {
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+// Ensure output directory exists
+export function ensureOutputDir(outputPath: string): void {
+  if (outputPath.endsWith('/') || !extname(outputPath)) {
+    // It's a directory
+    if (!existsSync(outputPath)) {
+      mkdirSync(outputPath, { recursive: true });
+    }
+  } else {
+    // It's a file, ensure parent directory exists
+    ensureDir(outputPath);
+  }
+}
+
+// Get file size in bytes
+export function getFileSize(path: string): number {
+  try {
+    return statSync(path).size;
+  } catch {
+    return 0;
+  }
+}
+
+// Check if file exists
+export function fileExists(path: string): boolean {
+  return existsSync(path);
+}
+
+// Check if path is a directory
+export function isDirectory(path: string): boolean {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// Get file extension without dot
+export function getExtension(path: string): string {
+  return extname(path).slice(1).toLowerCase();
+}
+
+// Get filename without extension
+export function getBasename(path: string): string {
+  return basename(path, extname(path));
+}
+
+// Generate output path
+export function generateOutputPath(
+  inputPath: string,
+  outputArg: string | undefined,
+  suffix?: string,
+  newExt?: string
+): string {
+  const inputBasename = getBasename(inputPath);
+  const inputExt = getExtension(inputPath);
+  const finalExt = newExt || inputExt;
+  const finalName = suffix ? `${inputBasename}${suffix}` : inputBasename;
+
+  if (!outputArg) {
+    // No output specified, use input directory with suffix
+    const dir = dirname(inputPath);
+    return join(dir, `${finalName}.${finalExt}`);
+  }
+
+  if (isDirectory(outputArg) || outputArg.endsWith('/')) {
+    // Output is a directory
+    ensureOutputDir(outputArg);
+    return join(outputArg, `${finalName}.${finalExt}`);
+  }
+
+  // Output is a file path
+  ensureDir(outputArg);
+  return outputArg;
+}
+
+// Glob files with pattern
+export async function globFiles(
+  patterns: string | string[],
+  options?: { cwd?: string; absolute?: boolean }
+): Promise<string[]> {
+  const patternList = Array.isArray(patterns) ? patterns : [patterns];
+  const cwd = options?.cwd || process.cwd();
+  const absolute = options?.absolute ?? true;
+  const results: string[] = [];
+
+  for (const pattern of patternList) {
+    const glob = new Bun.Glob(pattern);
+    // Bun.Glob.scan returns AsyncIterable
+    for await (const file of glob.scan({ cwd, absolute })) {
+      results.push(file);
+    }
+  }
+  return results;
+}
+
+// Validate input files exist
+export function validateInputFiles(files: string[]): string[] {
+  const missing: string[] = [];
+
+  for (const file of files) {
+    if (!fileExists(file)) {
+      missing.push(file);
+    }
+  }
+
+  return missing;
+}
+
+// Resolve path (handle relative paths)
+export function resolvePath(path: string): string {
+  return resolve(path);
+}
+
+// Get relative path from cwd
+export function getRelativePath(path: string): string {
+  const cwd = process.cwd();
+  if (path.startsWith(cwd)) {
+    return path.slice(cwd.length + 1);
+  }
+  return path;
+}
+
+// Supported file extensions by category
+export const SUPPORTED_EXTENSIONS = {
+  pdf: ['pdf'],
+  image: ['jpg', 'jpeg', 'png', 'webp', 'gif', 'tiff', 'tif', 'avif', 'heic', 'heif', 'svg'],
+  audio: ['mp3', 'wav', 'ogg', 'flac', 'm4a', 'aac', 'wma', 'opus'],
+  video: ['mp4', 'mkv', 'avi', 'mov', 'webm', 'flv', 'wmv'],
+  qr: ['png', 'jpg', 'jpeg', 'gif', 'bmp', 'svg'],
+} as const;
+
+// Check if file is of expected type
+export function isFileType(path: string, category: keyof typeof SUPPORTED_EXTENSIONS): boolean {
+  const ext = getExtension(path);
+  const extensions = SUPPORTED_EXTENSIONS[category] as readonly string[];
+  return extensions.includes(ext);
+}

package/src/utils/logger.ts

@@ -0,0 +1,90 @@
+import { filesize } from 'filesize';
+import { c, sym } from './style';
+
+// Styled output helpers
+export function success(message: string): void {
+  console.log(`${c.done(sym.done)} ${message}`);
+}
+
+export function error(message: string, suggestion?: string): void {
+  console.error(`${c.error(sym.error)} ${c.error(message)}`);
+  if (suggestion) {
+    console.error(`  ${c.dim('Hint:')} ${suggestion}`);
+  }
+}
+
+export function warn(message: string): void {
+  console.warn(`${c.warn(sym.warn)} ${c.warn(message)}`);
+}
+
+export function info(message: string): void {
+  console.log(`${c.info(sym.info)} ${message}`);
+}
+
+export function dim(message: string): void {
+  console.log(c.dim(message));
+}
+
+// File operation result display
+export function fileResult(
+  input: string,
+  output: string,
+  stats?: { before: number; after: number }
+): void {
+  console.log();
+  console.log(`  ${c.dim('Input')}   ${input}`);
+  console.log(`  ${c.done('Output')}  ${output}`);
+
+  if (stats) {
+    const reduction = ((1 - stats.after / stats.before) * 100).toFixed(1);
+    const beforeSize = filesize(stats.before) as string;
+    const afterSize = filesize(stats.after) as string;
+    const saved = stats.before > stats.after;
+
+    const change = saved ? c.done(`-${reduction}%`) : c.warn(`+${Math.abs(Number(reduction))}%`);
+
+    console.log(`  ${c.dim('Size')}    ${beforeSize} → ${afterSize} (${change})`);
+  }
+  console.log();
+}
+
+// Bulk operation result
+export function bulkResult(processed: number, failed: number, totalSaved?: number): void {
+  console.log();
+  console.log(c.dim('  ─────────────────────────────'));
+  console.log(`  ${c.dim('Processed')} ${c.done(String(processed))}`);
+
+  if (failed > 0) {
+    console.log(`  ${c.dim('Failed')}    ${c.error(String(failed))}`);
+  }
+
+  if (totalSaved !== undefined) {
+    const savedSize = filesize(totalSaved) as string;
+    console.log(`  ${c.dim('Saved')}     ${c.active(savedSize)}`);
+  }
+  console.log();
+}
+
+// Tool detection message
+export function toolFound(tool: string, path: string): void {
+  console.log(`${c.done(sym.done)} ${tool} ${c.dim(path)}`);
+}
+
+export function toolNotFound(tool: string, installCmd?: string): void {
+  console.warn(`${c.error(sym.error)} ${tool} ${c.dim('not found')}`);
+  if (installCmd) {
+    console.log(`  ${c.active('Install:')} ${installCmd}`);
+  }
+}
+
+// Section header
+export function header(title: string): void {
+  console.log();
+  console.log(c.title(title));
+  console.log();
+}
+
+// Format bytes
+export function formatBytes(bytes: number): string {
+  return filesize(bytes) as string;
+}