noupload 1.0.0

package/src/commands/image/compress.ts

@@ -0,0 +1,95 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import {
+  ensureDir,
+  generateOutputPath,
+  getExtension,
+  getFileSize,
+  resolvePath,
+} from '../../utils/files';
+import { fileResult, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+export const compressCmd = defineCommand({
+  meta: {
+    name: 'compress',
+    description: 'Compress an image to reduce file size',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input image file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    quality: {
+      type: 'string',
+      alias: 'q',
+      description: 'Quality (1-100)',
+      default: '80',
+    },
+  },
+  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, '-compressed');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const quality = Number.parseInt(args.quality || '80', 10);
+      const ext = getExtension(inputPath);
+
+      // Lazy load sharp
+      const { default: sharp } = await import('sharp');
+
+      await withSpinner(
+        `Compressing image (quality: ${quality})...`,
+        async () => {
+          let pipeline = sharp(inputPath);
+
+          switch (ext) {
+            case 'jpg':
+            case 'jpeg':
+              pipeline = pipeline.jpeg({ quality, mozjpeg: true });
+              break;
+            case 'png':
+              pipeline = pipeline.png({ quality, compressionLevel: 9 });
+              break;
+            case 'webp':
+              pipeline = pipeline.webp({ quality });
+              break;
+            case 'avif':
+              pipeline = pipeline.avif({ quality });
+              break;
+            default:
+              pipeline = pipeline.jpeg({ quality, mozjpeg: true });
+          }
+
+          await pipeline.toFile(outputPath);
+        },
+        'Image compressed successfully'
+      );
+
+      const outputSize = getFileSize(outputPath);
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: outputSize,
+      });
+
+      success('Image compressed');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/image/convert.ts

@@ -0,0 +1,116 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import sharp from 'sharp';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import {
+  ensureDir,
+  generateOutputPath,
+  getExtension,
+  getFileSize,
+  resolvePath,
+} from '../../utils/files';
+import { fileResult, info, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+
+const SUPPORTED_FORMATS = ['jpg', 'jpeg', 'png', 'webp', 'avif', 'gif', 'tiff', 'heif'];
+
+export const convert = defineCommand({
+  meta: {
+    name: 'convert',
+    description: 'Convert an image to a different format',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input image file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    format: {
+      type: 'string',
+      alias: 'f',
+      description: `Output format: ${SUPPORTED_FORMATS.join(', ')}`,
+      required: true,
+    },
+    quality: {
+      type: 'string',
+      alias: 'q',
+      description: 'Quality (1-100)',
+      default: '85',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const format = requireArg(args.format, 'format').toLowerCase();
+
+      if (!SUPPORTED_FORMATS.includes(format)) {
+        throw new Error(
+          `Unsupported format: ${format}. Supported: ${SUPPORTED_FORMATS.join(', ')}`
+        );
+      }
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const inputExt = getExtension(inputPath);
+      const outputPath = generateOutputPath(inputPath, args.output, '', format);
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const quality = Number.parseInt(args.quality || '85', 10);
+
+      await withSpinner(
+        `Converting ${inputExt.toUpperCase()} to ${format.toUpperCase()}...`,
+        async () => {
+          let pipeline = sharp(inputPath);
+
+          switch (format) {
+            case 'jpg':
+            case 'jpeg':
+              pipeline = pipeline.jpeg({ quality, mozjpeg: true });
+              break;
+            case 'png':
+              pipeline = pipeline.png({ quality });
+              break;
+            case 'webp':
+              pipeline = pipeline.webp({ quality });
+              break;
+            case 'avif':
+              pipeline = pipeline.avif({ quality });
+              break;
+            case 'gif':
+              pipeline = pipeline.gif();
+              break;
+            case 'tiff':
+              pipeline = pipeline.tiff({ quality });
+              break;
+            case 'heif':
+              pipeline = pipeline.heif({ quality });
+              break;
+          }
+
+          await pipeline.toFile(outputPath);
+        },
+        'Image converted successfully'
+      );
+
+      info(`Format: ${inputExt.toUpperCase()} → ${format.toUpperCase()}`);
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Image converted');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/image/crop.ts

@@ -0,0 +1,96 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import sharp from 'sharp';
+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 crop = defineCommand({
+  meta: {
+    name: 'crop',
+    description: 'Crop an image',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input image file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    x: {
+      type: 'string',
+      description: 'Left offset in pixels',
+      default: '0',
+    },
+    y: {
+      type: 'string',
+      description: 'Top offset in pixels',
+      default: '0',
+    },
+    width: {
+      type: 'string',
+      alias: 'w',
+      description: 'Crop width in pixels',
+      required: true,
+    },
+    height: {
+      type: 'string',
+      alias: 'h',
+      description: 'Crop height in pixels',
+      required: true,
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const width = requireArg(args.width, 'width');
+      const height = requireArg(args.height, 'height');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, '-cropped');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const left = Number.parseInt(args.x || '0', 10);
+      const top = Number.parseInt(args.y || '0', 10);
+      const cropWidth = Number.parseInt(width, 10);
+      const cropHeight = Number.parseInt(height, 10);
+
+      // Validate crop area
+      const metadata = await sharp(inputPath).metadata();
+      if (left + cropWidth > (metadata.width || 0) || top + cropHeight > (metadata.height || 0)) {
+        throw new Error('Crop area exceeds image boundaries');
+      }
+
+      await withSpinner(
+        `Cropping image (${cropWidth}x${cropHeight} at ${left},${top})...`,
+        async () => {
+          await sharp(inputPath)
+            .extract({ left, top, width: cropWidth, height: cropHeight })
+            .toFile(outputPath);
+        },
+        'Image cropped successfully'
+      );
+
+      info(`Crop: ${cropWidth}x${cropHeight} at position (${left}, ${top})`);
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Image cropped');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/image/favicon.ts

@@ -0,0 +1,89 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { defineCommand } from 'citty';
+import sharp from 'sharp';
+import { FileNotFoundError, handleError, requireArg } from '../../utils/errors';
+import { ensureOutputDir, getBasename, resolvePath } from '../../utils/files';
+import { info, success } from '../../utils/logger';
+import { withSpinner } from '../../utils/progress';
+import { c } from '../../utils/style';
+
+const FAVICON_SIZES = [16, 32, 48, 64, 128, 180, 192, 512];
+
+export const favicon = defineCommand({
+  meta: {
+    name: 'favicon',
+    description: 'Generate favicons from an image',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input image file (should be square)',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output directory',
+      required: true,
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const output = requireArg(args.output, 'output');
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputDir = resolvePath(output);
+      ensureOutputDir(`${outputDir}/`);
+
+      await withSpinner(
+        `Generating ${FAVICON_SIZES.length} favicon sizes...`,
+        async () => {
+          for (const size of FAVICON_SIZES) {
+            const outputPath = join(outputDir, `favicon-${size}x${size}.png`);
+            await sharp(inputPath)
+              .resize(size, size, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
+              .png()
+              .toFile(outputPath);
+          }
+
+          // Also generate apple-touch-icon
+          await sharp(inputPath)
+            .resize(180, 180, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
+            .png()
+            .toFile(join(outputDir, 'apple-touch-icon.png'));
+
+          // Generate favicon.ico (16x16 and 32x32 combined would need ICO format)
+          // For simplicity, we'll just create a 32x32 PNG named favicon.png
+          await sharp(inputPath)
+            .resize(32, 32, { fit: 'contain', background: { r: 0, g: 0, b: 0, alpha: 0 } })
+            .png()
+            .toFile(join(outputDir, 'favicon.png'));
+        },
+        'Favicons generated successfully'
+      );
+
+      info(`Generated ${FAVICON_SIZES.length} sizes: ${FAVICON_SIZES.join(', ')}`);
+      info(`Output directory: ${outputDir}`);
+
+      console.log();
+      console.log(c.dim('  Add to your HTML:'));
+      console.log(
+        `  ${c.white('<link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png">')}`
+      );
+      console.log(
+        `  ${c.white('<link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png">')}`
+      );
+      console.log();
+
+      success('Favicons generated');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/image/filters.ts

@@ -0,0 +1,108 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+import sharp from 'sharp';
+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';
+
+const AVAILABLE_FILTERS = ['grayscale', 'sepia', 'blur', 'sharpen', 'negate', 'normalize'];
+
+export const filters = defineCommand({
+  meta: {
+    name: 'filters',
+    description: 'Apply filters to an image',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input image file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    filter: {
+      type: 'string',
+      alias: 'f',
+      description: `Filter: ${AVAILABLE_FILTERS.join(', ')}`,
+      required: true,
+    },
+    intensity: {
+      type: 'string',
+      alias: 'i',
+      description: 'Filter intensity (for blur, sharpen)',
+      default: '3',
+    },
+  },
+  async run({ args }) {
+    try {
+      const input = requireArg(args.input, 'input');
+      const filter = requireArg(args.filter, 'filter').toLowerCase();
+
+      if (!AVAILABLE_FILTERS.includes(filter)) {
+        throw new Error(`Unknown filter: ${filter}. Available: ${AVAILABLE_FILTERS.join(', ')}`);
+      }
+
+      const inputPath = resolvePath(input as string);
+      if (!existsSync(inputPath)) {
+        throw new FileNotFoundError(input as string);
+      }
+
+      const outputPath = generateOutputPath(inputPath, args.output, `-${filter}`);
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const intensity = Number.parseFloat(args.intensity || '3');
+
+      await withSpinner(
+        `Applying ${filter} filter...`,
+        async () => {
+          let pipeline = sharp(inputPath);
+
+          switch (filter) {
+            case 'grayscale':
+              pipeline = pipeline.grayscale();
+              break;
+            case 'sepia':
+              // Sepia effect using recomb matrix
+              pipeline = pipeline.recomb([
+                [0.393, 0.769, 0.189],
+                [0.349, 0.686, 0.168],
+                [0.272, 0.534, 0.131],
+              ]);
+              break;
+            case 'blur':
+              pipeline = pipeline.blur(intensity);
+              break;
+            case 'sharpen':
+              pipeline = pipeline.sharpen(intensity);
+              break;
+            case 'negate':
+              pipeline = pipeline.negate();
+              break;
+            case 'normalize':
+              pipeline = pipeline.normalize();
+              break;
+          }
+
+          await pipeline.toFile(outputPath);
+        },
+        'Filter applied successfully'
+      );
+
+      info(`Filter: ${filter}`);
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Filter applied to image');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});

package/src/commands/image/index.ts

@@ -0,0 +1,49 @@
+import { defineCommand } from 'citty';
+import { adjust } from './adjust';
+import { border } from './border';
+import { bulkCompress } from './bulk-compress';
+import { bulkConvert } from './bulk-convert';
+import { bulkResize } from './bulk-resize';
+import { compressCmd } from './compress';
+import { convert } from './convert';
+import { crop } from './crop';
+import { favicon } from './favicon';
+import { filters } from './filters';
+import { resize } from './resize';
+import { rotate } from './rotate';
+import { stripMetadata } from './strip-metadata';
+import { toBase64 } from './to-base64';
+import { watermark } from './watermark';
+
+export const image = defineCommand({
+  meta: {
+    name: 'image',
+    description: 'Image manipulation tools',
+  },
+  subCommands: {
+    // Essentials
+    compress: compressCmd,
+    resize,
+    convert,
+    crop,
+    rotate,
+
+    // Adjustments & Filters
+    adjust,
+    filters,
+    border,
+
+    // Content & Metadata
+    watermark,
+    'strip-metadata': stripMetadata,
+
+    // Web & Utils
+    favicon,
+    'to-base64': toBase64,
+
+    // Bulk Operations
+    'bulk-compress': bulkCompress,
+    'bulk-resize': bulkResize,
+    'bulk-convert': bulkConvert,
+  },
+});

package/src/commands/image/resize.ts

@@ -0,0 +1,110 @@
+import { existsSync } from 'node:fs';
+import { defineCommand } from 'citty';
+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';
+
+type FitMode = 'cover' | 'contain' | 'fill' | 'inside' | 'outside';
+
+export const resize = defineCommand({
+  meta: {
+    name: 'resize',
+    description: 'Resize an image',
+  },
+  args: {
+    input: {
+      type: 'positional',
+      description: 'Input image file',
+      required: true,
+    },
+    output: {
+      type: 'string',
+      alias: 'o',
+      description: 'Output file path',
+    },
+    width: {
+      type: 'string',
+      alias: 'w',
+      description: 'Target width in pixels',
+    },
+    height: {
+      type: 'string',
+      alias: 'h',
+      description: 'Target height in pixels',
+    },
+    fit: {
+      type: 'string',
+      alias: 'f',
+      description: 'Fit mode: cover, contain, fill, inside, outside',
+      default: 'inside',
+    },
+    scale: {
+      type: 'string',
+      alias: 's',
+      description: 'Scale factor (e.g., 0.5 for half size)',
+    },
+  },
+  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, '-resized');
+      ensureDir(outputPath);
+
+      const inputSize = getFileSize(inputPath);
+      const fit = (args.fit || 'inside') as FitMode;
+
+      // Lazy load sharp
+      const { default: sharp } = await import('sharp');
+
+      // Get original dimensions
+      const metadata = await sharp(inputPath).metadata();
+      const originalWidth = metadata.width || 0;
+      const originalHeight = metadata.height || 0;
+
+      let targetWidth: number | undefined;
+      let targetHeight: number | undefined;
+
+      if (args.scale) {
+        const scale = Number.parseFloat(args.scale);
+        targetWidth = Math.round(originalWidth * scale);
+        targetHeight = Math.round(originalHeight * scale);
+      } else {
+        targetWidth = args.width ? Number.parseInt(args.width, 10) : undefined;
+        targetHeight = args.height ? Number.parseInt(args.height, 10) : undefined;
+      }
+
+      if (!targetWidth && !targetHeight) {
+        throw new Error('Specify --width, --height, or --scale');
+      }
+
+      await withSpinner(
+        'Resizing image...',
+        async () => {
+          await sharp(inputPath)
+            .resize(targetWidth, targetHeight, { fit, withoutEnlargement: true })
+            .toFile(outputPath);
+        },
+        'Image resized successfully'
+      );
+
+      const outputMetadata = await sharp(outputPath).metadata();
+      info(`${originalWidth}x${originalHeight} → ${outputMetadata.width}x${outputMetadata.height}`);
+
+      fileResult(inputPath, outputPath, {
+        before: inputSize,
+        after: getFileSize(outputPath),
+      });
+
+      success('Image resized');
+    } catch (err) {
+      handleError(err);
+    }
+  },
+});