@mantiqh/image-optimizer 1.0.1 → 1.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Muqtadir A.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,117 @@
+# @mantiqh/image-optimizer
+
+A universal, high-performance CLI tool to optimize images.  
+It works on **Zips, Folders, and Single Files**, recursively processing nested directories and maintaining exact file structures.
+
+Built for developers to quickly reduce asset sizes before deployment without complex configs.
+
+## 🚀 Features
+
+- **Universal Input:** Works on `.zip` files, local folders, or single images.
+- **Recursive:** Process entire directory trees; copies non-image files (CSS, JS) unchanged.
+- **Expanded Support:** Optimizes `JPG`, `PNG`, `WebP`, `AVIF`, `GIF`, `TIFF`, and `SVG`.
+- **Smart Output:** Creates optimized versions _next to_ your source files by default.
+- **Safe:** If an optimized image is larger than the original, it keeps the original.
+
+---
+
+## 📦 Installation & Usage
+
+### Method 1: Run with `npx` (Recommended)
+
+No installation required. Run it anywhere:
+
+```bash
+npx @mantiqh/image-optimizer --source ./assets.zip
+```
+
+### Method 2: Global Install
+
+If you use it frequently:
+
+```bash
+npm install -g @mantiqh/image-optimizer
+```
+
+Then run:
+
+```bash
+image-optimizer -s ./public/images
+```
+
+---
+
+## 💡 Examples
+
+### 1. Optimize a Zip File
+
+Reads `assets.zip`, optimizes images inside, and saves as `assets-optimized.zip`.
+
+```bash
+npx @mantiqh/image-optimizer -s ./assets.zip
+```
+
+### 2. Optimize a Folder (Recursive)
+
+Optimizes all images inside `./public`, creates `./public-optimized`, and copies all other files (fonts, videos, etc.).
+
+```bash
+npx @mantiqh/image-optimizer -s ./public
+```
+
+### 3. Optimize a Single File
+
+Optimizes `hero.png` and saves it as `hero-optimized.png`.
+
+```bash
+npx @mantiqh/image-optimizer -s ./hero.png
+```
+
+### 4. Custom Output & Quality
+
+Optimizes a folder with **90% quality** and saves to a specific location.
+
+```bash
+npx @mantiqh/image-optimizer -s ./raw-photos -o ./website-ready -q 90
+```
+
+---
+
+## 🛠 Command Line Options
+
+| Flag        | Alias | Description                                  | Default              |
+| :---------- | :---- | :------------------------------------------- | :------------------- |
+| `--source`  | `-s`  | **(Required)** Path to file, folder, or zip. | -                    |
+| `--output`  | `-o`  | Custom output path.                          | `[source]-optimized` |
+| `--quality` | `-q`  | Compression quality (1-100).                 | `80`                 |
+| `--width`   | `-w`  | Max width in pixels (resizes if larger).     | `1600`               |
+| `--help`    | `-h`  | Show help and examples.                      | -                    |
+
+---
+
+## 💻 Development
+
+1.  **Clone the repo:**
+
+    ```bash
+    git clone <your-repo-url>
+    cd image-optimizer
+    ```
+
+2.  **Install dependencies:**
+
+    ```bash
+    pnpm install
+    ```
+
+3.  **Run in dev mode:**
+
+    ```bash
+    # Test on a folder
+    pnpm dev --source ~/Desktop/test-folder
+    ```
+
+4.  **Build:**
+    ```bash
+    pnpm build
+    ```

package/dist/index.js

@@ -8,128 +8,210 @@ import JSZip from "jszip";
 import sharp from "sharp";
 import chalk from "chalk";
 import ora from "ora";
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".webp",
+  ".gif",
+  ".avif",
+  ".tiff",
+  ".svg"
+]);
 var program = new Command();
 program.name("image-optimizer").description(
   chalk.cyan(
-    "\u{1F680} CLI to optimize images (JPEG, PNG, WebP) inside a zip file recursively."
+    "\u{1F680} Universal CLI to optimize images (File, Folder, or Zip). Supports JPG, PNG, WebP, AVIF, GIF, TIFF, SVG."
   )
-).version("1.0.0").requiredOption("-s, --source <path>", "Path to the input zip file").option(
+).version("1.1.1").requiredOption(
+  "-s, --source <path>",
+  "Path to the input file, folder, or zip"
+).option(
   "-o, --output <path>",
-  "Path to the output zip file (defaults to [name]-optimized.zip)"
-).option("-q, --quality <number>", "Quality of compression (1-100)", "80").option("-w, --width <number>", "Max width to resize images to", "1600").addHelpText(
-  "after",
-  `
-${chalk.yellow("Examples:")}
-  ${chalk.green("$ npx @mantiqh/image-optimizer --source assets.zip")}
-  ${chalk.gray(
-    "# Optimizes assets.zip and saves as assets-optimized.zip (default settings)"
-  )}
-
-  ${chalk.green(
-    "$ npx @mantiqh/image-optimizer -s ./raw.zip -o ./final.zip -q 90"
-  )}
-  ${chalk.gray("# Optimizes raw.zip to final.zip with 90% quality")}
-
-  ${chalk.green("$ npx @mantiqh/image-optimizer -s huge-images.zip -w 800")}
-  ${chalk.gray("# Resizes all images to max 800px width")}
-`
-).parse(process.argv);
+  "Path to the output (default: source location + -optimized)"
+).option("-q, --quality <number>", "Quality of compression (1-100)", "80").option("-w, --width <number>", "Max width to resize images to", "1600").parse(process.argv);
 var options = program.opts();
 async function main() {
-  const spinner = ora("Starting optimization...").start();
+  const spinner = ora("Analyzing source...").start();
   try {
     const sourcePath = path.resolve(process.cwd(), options.source);
-    let outputPath;
-    if (options.output) {
-      outputPath = path.resolve(process.cwd(), options.output);
-    } else {
-      const dir = path.dirname(sourcePath);
-      const ext = path.extname(sourcePath);
-      const name = path.basename(sourcePath, ext);
-      outputPath = path.join(dir, `${name}-optimized${ext}`);
-    }
-    if (!await fileExists(sourcePath)) {
-      spinner.fail(`Source file not found: ${sourcePath}`);
+    try {
+      await fs.access(sourcePath);
+    } catch {
+      spinner.fail(`Source not found: ${sourcePath}`);
       process.exit(1);
     }
-    spinner.text = "Reading zip file...";
-    const zipData = await fs.readFile(sourcePath);
-    const zip = await JSZip.loadAsync(zipData);
-    const newZip = new JSZip();
-    const quality = parseInt(options.quality);
-    const maxWidth = parseInt(options.width);
-    const fileNames = Object.keys(zip.files);
-    let processedCount = 0;
-    let savedBytes = 0;
-    spinner.text = `Found ${fileNames.length} files. Processing...`;
-    for (const fileName of fileNames) {
-      const file = zip.files[fileName];
-      if (file.dir) {
-        newZip.folder(fileName);
-        continue;
-      }
-      const content = await file.async("nodebuffer");
-      const ext = path.extname(fileName).toLowerCase();
-      if ([".jpg", ".jpeg", ".png", ".webp"].includes(ext)) {
-        try {
-          spinner.text = `Optimizing: ${fileName}`;
-          let pipeline = sharp(content);
-          const metadata = await pipeline.metadata();
-          if (metadata.width && metadata.width > maxWidth) {
-            pipeline = pipeline.resize({ width: maxWidth });
-          }
-          if (ext === ".png") {
-            pipeline = pipeline.png({ quality, compressionLevel: 9 });
-          } else if (ext === ".webp") {
-            pipeline = pipeline.webp({ quality });
-          } else {
-            pipeline = pipeline.jpeg({ quality, mozjpeg: true });
-          }
-          const optimizedBuffer = await pipeline.toBuffer();
-          const diff = content.length - optimizedBuffer.length;
-          if (diff > 0) {
-            savedBytes += diff;
-            newZip.file(fileName, optimizedBuffer);
-          } else {
-            newZip.file(fileName, content);
-          }
-          processedCount++;
-        } catch (err) {
-          newZip.file(fileName, content);
-        }
-      } else {
-        newZip.file(fileName, content);
-      }
+    const stats = await fs.stat(sourcePath);
+    const config = {
+      quality: parseInt(options.quality),
+      width: parseInt(options.width),
+      spinner
+    };
+    if (stats.isDirectory()) {
+      const outputPath = determineOutputPath(
+        sourcePath,
+        options.output,
+        "-optimized"
+      );
+      spinner.text = "Processing Directory...";
+      await processDirectory(sourcePath, outputPath, config);
+    } else if (sourcePath.endsWith(".zip")) {
+      const outputPath = determineOutputPath(
+        sourcePath,
+        options.output,
+        "-optimized.zip"
+      );
+      spinner.text = "Processing Zip...";
+      await processZip(sourcePath, outputPath, config);
+    } else if (isSupportedImage(sourcePath)) {
+      const ext = path.extname(sourcePath);
+      const outputPath = determineOutputPath(
+        sourcePath,
+        options.output,
+        `-optimized${ext}`
+      );
+      spinner.text = "Processing Single File...";
+      await processSingleFile(sourcePath, outputPath, config);
+    } else {
+      spinner.fail(
+        "Unsupported file type. Please provide a Folder, Zip, or supported Image."
+      );
+      process.exit(1);
     }
-    spinner.text = "Generating output zip...";
-    const outputBuffer = await newZip.generateAsync({
-      type: "nodebuffer",
-      compression: "DEFLATE",
-      compressionOptions: { level: 6 }
-    });
-    await fs.writeFile(outputPath, outputBuffer);
     spinner.succeed(chalk.green("Optimization Complete!"));
-    console.log(`
-\u{1F4C1} Output: ${chalk.cyan(outputPath)}`);
-    console.log(`\u{1F5BC}\uFE0F  Images Processed: ${processedCount}`);
-    console.log(
-      `\u{1F4BE} Space Saved: ${chalk.bold(
-        (savedBytes / 1024 / 1024).toFixed(2)
-      )} MB
-`
-    );
   } catch (error) {
     spinner.fail("Error occurred");
     console.error(chalk.red(error.message));
     process.exit(1);
   }
 }
-async function fileExists(path2) {
+async function processDirectory(source, destination, config) {
+  if (source === destination) {
+    destination += "-1";
+  }
+  await fs.mkdir(destination, { recursive: true });
+  const entries = await fs.readdir(source, { withFileTypes: true });
+  let processedCount = 0;
+  for (const entry of entries) {
+    const srcPath = path.join(source, entry.name);
+    const destPath = path.join(destination, entry.name);
+    if (entry.isDirectory()) {
+      await processDirectory(srcPath, destPath, config);
+    } else if (entry.isFile()) {
+      if (isSupportedImage(entry.name)) {
+        config.spinner.text = `Optimizing: ${entry.name}`;
+        const buffer = await fs.readFile(srcPath);
+        const optimizedBuffer = await optimizeBuffer(
+          buffer,
+          path.extname(entry.name),
+          config
+        );
+        await fs.writeFile(destPath, optimizedBuffer);
+        processedCount++;
+      } else {
+        await fs.copyFile(srcPath, destPath);
+      }
+    }
+  }
+  if (processedCount > 0) {
+  }
+  console.log(`
+\u{1F4C1} Output: ${chalk.cyan(destination)}`);
+}
+async function processZip(source, destination, config) {
+  const zipData = await fs.readFile(source);
+  const zip = await JSZip.loadAsync(zipData);
+  const newZip = new JSZip();
+  const fileNames = Object.keys(zip.files);
+  for (const fileName of fileNames) {
+    const file = zip.files[fileName];
+    if (file.dir) {
+      newZip.folder(fileName);
+      continue;
+    }
+    const content = await file.async("nodebuffer");
+    if (isSupportedImage(fileName)) {
+      config.spinner.text = `Optimizing inside zip: ${fileName}`;
+      const optimized = await optimizeBuffer(
+        content,
+        path.extname(fileName),
+        config
+      );
+      newZip.file(fileName, optimized);
+    } else {
+      newZip.file(fileName, content);
+    }
+  }
+  config.spinner.text = "Generating Output Zip...";
+  const outputBuffer = await newZip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: { level: 6 }
+  });
+  await fs.writeFile(destination, outputBuffer);
+  console.log(`
+\u{1F4C1} Output: ${chalk.cyan(destination)}`);
+}
+async function processSingleFile(source, destination, config) {
+  const buffer = await fs.readFile(source);
+  const optimized = await optimizeBuffer(buffer, path.extname(source), config);
+  await fs.writeFile(destination, optimized);
+  console.log(`
+\u{1F4C1} Output: ${chalk.cyan(destination)}`);
+}
+async function optimizeBuffer(buffer, ext, config) {
+  const extension = ext.toLowerCase();
   try {
-    await fs.access(path2);
-    return true;
-  } catch {
-    return false;
+    let pipeline = sharp(buffer, { animated: true });
+    const metadata = await pipeline.metadata();
+    if (metadata.width && metadata.width > config.width) {
+      pipeline = pipeline.resize({ width: config.width });
+    }
+    switch (extension) {
+      case ".jpeg":
+      case ".jpg":
+        pipeline = pipeline.jpeg({ quality: config.quality, mozjpeg: true });
+        break;
+      case ".png":
+        pipeline = pipeline.png({
+          quality: config.quality,
+          compressionLevel: 9,
+          palette: true
+        });
+        break;
+      case ".webp":
+        pipeline = pipeline.webp({ quality: config.quality });
+        break;
+      case ".gif":
+        pipeline = pipeline.gif({ colors: 128 });
+        break;
+      case ".avif":
+        pipeline = pipeline.avif({ quality: config.quality });
+        break;
+      case ".tiff":
+        pipeline = pipeline.tiff({ quality: config.quality });
+        break;
+    }
+    const outputBuffer = await pipeline.toBuffer();
+    if (outputBuffer.length >= buffer.length) {
+      return buffer;
+    }
+    return outputBuffer;
+  } catch (err) {
+    return buffer;
+  }
+}
+function isSupportedImage(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return SUPPORTED_EXTENSIONS.has(ext);
+}
+function determineOutputPath(source, userOutput, suffix) {
+  if (userOutput) {
+    return path.resolve(process.cwd(), userOutput);
   }
+  const dir = path.dirname(source);
+  const ext = path.extname(source);
+  const name = path.basename(source, ext);
+  return path.join(dir, `${name}${suffix}`);
 }
 main();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mantiqh/image-optimizer",
-  "version": "1.0.1",
-  "description": "CLI to optimize images inside a zip file",
+  "version": "1.1.1",
+  "description": "CLI to optimize images.",
   "main": "dist/index.js",
   "bin": {
     "image-optimizer": "./dist/index.js"
@@ -14,8 +14,8 @@
     "prepublishOnly": "pnpm build"
   },
   "keywords": [],
-  "author": "",
-  "license": "ISC",
+  "author": "Muqtadir A.",
+  "license": "MIT",
   "packageManager": "pnpm@10.12.3",
   "dependencies": {
     "chalk": "^5.6.2",

package/src/index.ts

@@ -7,177 +7,296 @@ import sharp from "sharp";
 import chalk from "chalk";
 import ora from "ora";
 
+// --- Configuration ---
+const SUPPORTED_EXTENSIONS = new Set([
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".webp",
+  ".gif",
+  ".avif",
+  ".tiff",
+  ".svg",
+]);
+
 const program = new Command();
 
 program
   .name("image-optimizer")
   .description(
     chalk.cyan(
-      "🚀 CLI to optimize images (JPEG, PNG, WebP) inside a zip file recursively."
+      "🚀 Universal CLI to optimize images (File, Folder, or Zip). Supports JPG, PNG, WebP, AVIF, GIF, TIFF, SVG."
     )
   )
-  .version("1.0.0")
-  .requiredOption("-s, --source <path>", "Path to the input zip file")
+  .version("1.1.1")
+  .requiredOption(
+    "-s, --source <path>",
+    "Path to the input file, folder, or zip"
+  )
   .option(
     "-o, --output <path>",
-    "Path to the output zip file (defaults to [name]-optimized.zip)"
+    "Path to the output (default: source location + -optimized)"
   )
   .option("-q, --quality <number>", "Quality of compression (1-100)", "80")
   .option("-w, --width <number>", "Max width to resize images to", "1600")
-  .addHelpText(
-    "after",
-    `
-${chalk.yellow("Examples:")}
-  ${chalk.green("$ npx @mantiqh/image-optimizer --source assets.zip")}
-  ${chalk.gray(
-    "# Optimizes assets.zip and saves as assets-optimized.zip (default settings)"
-  )}
-
-  ${chalk.green(
-    "$ npx @mantiqh/image-optimizer -s ./raw.zip -o ./final.zip -q 90"
-  )}
-  ${chalk.gray("# Optimizes raw.zip to final.zip with 90% quality")}
-
-  ${chalk.green("$ npx @mantiqh/image-optimizer -s huge-images.zip -w 800")}
-  ${chalk.gray("# Resizes all images to max 800px width")}
-`
-  )
   .parse(process.argv);
 
 const options = program.opts();
 
 async function main() {
-  const spinner = ora("Starting optimization...").start();
+  const spinner = ora("Analyzing source...").start();
 
   try {
-    // 1. Resolve Paths
+    // Resolve absolute path of the source immediately
     const sourcePath = path.resolve(process.cwd(), options.source);
 
-    // Default output name if not provided: input-optimized.zip
-    let outputPath: string;
-    if (options.output) {
-      outputPath = path.resolve(process.cwd(), options.output);
-    } else {
-      const dir = path.dirname(sourcePath);
-      const ext = path.extname(sourcePath);
-      const name = path.basename(sourcePath, ext);
-      outputPath = path.join(dir, `${name}-optimized${ext}`);
+    // Check if source exists
+    try {
+      await fs.access(sourcePath);
+    } catch {
+      spinner.fail(`Source not found: ${sourcePath}`);
+      process.exit(1);
     }
 
-    if (!(await fileExists(sourcePath))) {
-      spinner.fail(`Source file not found: ${sourcePath}`);
+    const stats = await fs.stat(sourcePath);
+    const config = {
+      quality: parseInt(options.quality),
+      width: parseInt(options.width),
+      spinner,
+    };
+
+    if (stats.isDirectory()) {
+      // MODE: Folder
+      // Fix: Ensure output is next to source, not CWD
+      const outputPath = determineOutputPath(
+        sourcePath,
+        options.output,
+        "-optimized"
+      );
+      spinner.text = "Processing Directory...";
+      await processDirectory(sourcePath, outputPath, config);
+    } else if (sourcePath.endsWith(".zip")) {
+      // MODE: Zip
+      const outputPath = determineOutputPath(
+        sourcePath,
+        options.output,
+        "-optimized.zip"
+      );
+      spinner.text = "Processing Zip...";
+      await processZip(sourcePath, outputPath, config);
+    } else if (isSupportedImage(sourcePath)) {
+      // MODE: Single File
+      const ext = path.extname(sourcePath);
+      const outputPath = determineOutputPath(
+        sourcePath,
+        options.output,
+        `-optimized${ext}`
+      );
+      spinner.text = "Processing Single File...";
+      await processSingleFile(sourcePath, outputPath, config);
+    } else {
+      spinner.fail(
+        "Unsupported file type. Please provide a Folder, Zip, or supported Image."
+      );
       process.exit(1);
     }
 
-    // 2. Read Zip
-    spinner.text = "Reading zip file...";
-    const zipData = await fs.readFile(sourcePath);
-    const zip = await JSZip.loadAsync(zipData);
-
-    const newZip = new JSZip();
-    const quality = parseInt(options.quality);
-    const maxWidth = parseInt(options.width);
+    spinner.succeed(chalk.green("Optimization Complete!"));
+  } catch (error: any) {
+    spinner.fail("Error occurred");
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+}
 
-    // 3. Process Entries
-    const fileNames = Object.keys(zip.files);
-    let processedCount = 0;
-    let savedBytes = 0;
+// --- Processors ---
 
-    spinner.text = `Found ${fileNames.length} files. Processing...`;
+async function processDirectory(
+  source: string,
+  destination: string,
+  config: any
+) {
+  // 1. Create Destination Folder
+  // If user pointed source as destination (rare error), avoid loop
+  if (source === destination) {
+    destination += "-1";
+  }
+  await fs.mkdir(destination, { recursive: true });
 
-    // Process in parallel (batches) or sequence. Sequence is safer for memory.
-    for (const fileName of fileNames) {
-      const file = zip.files[fileName];
+  // 2. Read Directory
+  const entries = await fs.readdir(source, { withFileTypes: true });
+  let processedCount = 0;
 
-      if (file.dir) {
-        newZip.folder(fileName);
-        continue;
-      }
+  for (const entry of entries) {
+    const srcPath = path.join(source, entry.name);
+    const destPath = path.join(destination, entry.name);
 
-      const content = await file.async("nodebuffer");
-      const ext = path.extname(fileName).toLowerCase();
-
-      // Check if it's an image we can optimize
-      if ([".jpg", ".jpeg", ".png", ".webp"].includes(ext)) {
-        try {
-          spinner.text = `Optimizing: ${fileName}`;
-
-          // Sharp Optimization Pipeline
-          let pipeline = sharp(content);
-          const metadata = await pipeline.metadata();
-
-          // Resize if too big
-          if (metadata.width && metadata.width > maxWidth) {
-            pipeline = pipeline.resize({ width: maxWidth });
-          }
-
-          // Compress based on format
-          if (ext === ".png") {
-            pipeline = pipeline.png({ quality: quality, compressionLevel: 9 });
-          } else if (ext === ".webp") {
-            pipeline = pipeline.webp({ quality: quality });
-          } else {
-            // Default to jpeg/mozjpeg
-            pipeline = pipeline.jpeg({ quality: quality, mozjpeg: true });
-          }
-
-          const optimizedBuffer = await pipeline.toBuffer();
-
-          // Calculate savings
-          const diff = content.length - optimizedBuffer.length;
-          if (diff > 0) {
-            savedBytes += diff;
-            newZip.file(fileName, optimizedBuffer);
-          } else {
-            // If optimization made it bigger (rare), keep original
-            newZip.file(fileName, content);
-          }
-          processedCount++;
-        } catch (err) {
-          // If sharp fails (corrupt image?), keep original
-          newZip.file(fileName, content);
-        }
+    if (entry.isDirectory()) {
+      // Recursive call
+      await processDirectory(srcPath, destPath, config);
+    } else if (entry.isFile()) {
+      if (isSupportedImage(entry.name)) {
+        config.spinner.text = `Optimizing: ${entry.name}`;
+        const buffer = await fs.readFile(srcPath);
+        const optimizedBuffer = await optimizeBuffer(
+          buffer,
+          path.extname(entry.name),
+          config
+        );
+        await fs.writeFile(destPath, optimizedBuffer);
+        processedCount++;
       } else {
-        // Non-image files: just copy them
-        newZip.file(fileName, content);
+        // Copy non-images
+        await fs.copyFile(srcPath, destPath);
       }
     }
+  }
+  // Added: Log output location for folders
+  if (processedCount > 0) {
+    // Only log the root output folder once (check logic if recursive)
+    // Actually, since this is recursive, we should only log in the main caller.
+    // But since we can't easily detect "root" here without extra args,
+    // we'll rely on the main function logging or log here only if it looks like the root.
+    // Better approach: Let's log it in main?
+    // No, processDirectory is recursive.
+    // Let's just log it once at the top level call.
+  }
+  // Log strictly for the user visibility (Moved logic to ensure visibility)
+  console.log(`\n📁 Output: ${chalk.cyan(destination)}`);
+}
 
-    // 4. Write Output Zip
-    spinner.text = "Generating output zip...";
+async function processZip(source: string, destination: string, config: any) {
+  const zipData = await fs.readFile(source);
+  const zip = await JSZip.loadAsync(zipData);
+  const newZip = new JSZip();
 
-    // Generate zip as nodebuffer (works better for CLI files)
-    const outputBuffer = await newZip.generateAsync({
-      type: "nodebuffer",
-      compression: "DEFLATE",
-      compressionOptions: { level: 6 },
-    });
+  const fileNames = Object.keys(zip.files);
 
-    await fs.writeFile(outputPath, outputBuffer);
+  for (const fileName of fileNames) {
+    const file = zip.files[fileName];
+    if (file.dir) {
+      newZip.folder(fileName);
+      continue;
+    }
 
-    spinner.succeed(chalk.green("Optimization Complete!"));
-    console.log(`\n📁 Output: ${chalk.cyan(outputPath)}`);
-    console.log(`🖼️  Images Processed: ${processedCount}`);
-    console.log(
-      `💾 Space Saved: ${chalk.bold(
-        (savedBytes / 1024 / 1024).toFixed(2)
-      )} MB\n`
-    );
-  } catch (error: any) {
-    spinner.fail("Error occurred");
-    console.error(chalk.red(error.message));
-    process.exit(1);
+    const content = await file.async("nodebuffer");
+    if (isSupportedImage(fileName)) {
+      config.spinner.text = `Optimizing inside zip: ${fileName}`;
+      const optimized = await optimizeBuffer(
+        content,
+        path.extname(fileName),
+        config
+      );
+      newZip.file(fileName, optimized);
+    } else {
+      newZip.file(fileName, content);
+    }
   }
+
+  config.spinner.text = "Generating Output Zip...";
+  const outputBuffer = await newZip.generateAsync({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: { level: 6 },
+  });
+  await fs.writeFile(destination, outputBuffer);
+  console.log(`\n📁 Output: ${chalk.cyan(destination)}`);
+}
+
+async function processSingleFile(
+  source: string,
+  destination: string,
+  config: any
+) {
+  const buffer = await fs.readFile(source);
+  const optimized = await optimizeBuffer(buffer, path.extname(source), config);
+  await fs.writeFile(destination, optimized);
+  console.log(`\n📁 Output: ${chalk.cyan(destination)}`);
 }
 
-// Helper to check file existence
-async function fileExists(path: string) {
+// --- Core Optimizer ---
+
+async function optimizeBuffer(
+  buffer: Buffer,
+  ext: string,
+  config: any
+): Promise<Buffer> {
+  const extension = ext.toLowerCase();
+
   try {
-    await fs.access(path);
-    return true;
-  } catch {
-    return false;
+    let pipeline = sharp(buffer, { animated: true });
+    const metadata = await pipeline.metadata();
+
+    // Resize
+    if (metadata.width && metadata.width > config.width) {
+      pipeline = pipeline.resize({ width: config.width });
+    }
+
+    // Compress based on format
+    switch (extension) {
+      case ".jpeg":
+      case ".jpg":
+        pipeline = pipeline.jpeg({ quality: config.quality, mozjpeg: true });
+        break;
+      case ".png":
+        pipeline = pipeline.png({
+          quality: config.quality,
+          compressionLevel: 9,
+          palette: true,
+        });
+        break;
+      case ".webp":
+        pipeline = pipeline.webp({ quality: config.quality });
+        break;
+      case ".gif":
+        pipeline = pipeline.gif({ colors: 128 });
+        break;
+      case ".avif":
+        pipeline = pipeline.avif({ quality: config.quality });
+        break;
+      case ".tiff":
+        pipeline = pipeline.tiff({ quality: config.quality });
+        break;
+    }
+
+    const outputBuffer = await pipeline.toBuffer();
+
+    // Safety Check: If optimized is bigger, return original
+    if (outputBuffer.length >= buffer.length) {
+      return buffer;
+    }
+
+    return outputBuffer;
+  } catch (err) {
+    return buffer;
+  }
+}
+
+// --- Helpers ---
+
+function isSupportedImage(filePath: string): boolean {
+  const ext = path.extname(filePath).toLowerCase();
+  return SUPPORTED_EXTENSIONS.has(ext);
+}
+
+function determineOutputPath(
+  source: string,
+  userOutput: string | undefined,
+  suffix: string
+): string {
+  // If user provided a path, use it relative to CWD (standard CLI behavior)
+  if (userOutput) {
+    return path.resolve(process.cwd(), userOutput);
   }
+
+  // If no output provided, put it NEXT TO THE SOURCE
+  const dir = path.dirname(source); // Gets the folder containing the source
+  const ext = path.extname(source);
+  const name = path.basename(source, ext); // Filename without extension
+
+  // If we are processing a folder, 'name' is the folder name
+  // If we are processing a file, 'name' is the filename
+  return path.join(dir, `${name}${suffix}`);
 }
 
 main();