@mantiqh/image-optimizer 1.1.1 → 1.2.1

package/AGENTS.md

@@ -0,0 +1,104 @@
+# AGENTS.md
+
+## Project Overview
+
+TypeScript CLI tool for image optimization (files, folders, zip archives).
+Single source file: `src/index.ts`. Built with `tsup`, uses `pnpm`.
+
+## Commands
+
+```bash
+pnpm build          # tsup build → dist/index.js (ESM)
+pnpm dev            # watch mode, auto-runs on change
+pnpm start          # run built output
+pnpm build && pnpm start -- -s <path>  # build + run against a path
+```
+
+No test framework, linter, or formatter configured. No `pnpm test` or `pnpm lint`.
+
+## Testing
+
+No automated tests exist. To verify changes, build and run manually:
+
+```bash
+pnpm build && node dist/index.js -s ./test-images
+```
+
+## Project Structure
+
+```
+src/index.ts        # entire application (~314 lines)
+dist/index.js       # built output (ESM bundle)
+test-images/        # manual test assets
+```
+
+## Code Style
+
+### Formatting
+- 2-space indentation
+- Double quotes for strings
+- No trailing semicolons (inconsistent in codebase, but prefer omitting)
+
+### Imports
+- ESM `import` syntax only (`"type": "module"` in package.json)
+- Node built-ins first (`fs/promises`, `path`), then npm packages
+- No `import *` — use named/default imports
+
+```ts
+import { Command } from "commander";
+import fs from "fs/promises";
+import path from "path";
+```
+
+### Naming
+- `camelCase` for functions and variables (`processDirectory`, `optimizeBuffer`)
+- `UPPER_SNAKE_CASE` for constants (`SUPPORTED_EXTENSIONS`)
+- No classes — use pure functions
+
+### Types
+- TypeScript strict mode enabled (`tsconfig.json: strict: true`)
+- `config` parameter is loosely typed as `any` throughout — follow this pattern for now
+- Declare explicit return types on key functions (`Promise<Buffer>`, `void`)
+- Use `catch (error: any)` pattern for error handling
+
+### Error Handling
+- `try/catch` blocks around processing logic
+- Silent fallback: return original data on optimization failure (see `optimizeBuffer`)
+- `process.exit(1)` for fatal errors (missing source, unsupported type)
+- Use `spinner.fail()` for user-facing error messages via `ora`
+
+### Async
+- `async/await` everywhere — no callbacks, no `.then()` chains
+
+### Comments
+- Section headers: `// --- Section Name ---` (e.g. `// --- Processors ---`)
+- Inline `//` comments for clarification
+- No JSDoc
+
+### Architecture Pattern
+- `main()` — entry point, CLI setup via `commander`, dispatches to processors
+- `processDirectory()` / `processZip()` / `processSingleFile()` — mode-specific handlers
+- `optimizeBuffer()` — core sharp-based optimization, returns original on failure
+- `isSupportedImage()` / `determineOutputPath()` — helpers
+
+## Dependencies
+
+- **sharp** — image processing (resize, compress, format conversion)
+- **commander** — CLI argument parsing
+- **chalk** — terminal colors
+- **ora** — spinner/progress
+- **jszip** — zip file handling
+
+## Key Config
+
+- **tsconfig**: ES2022 target, NodeNext module resolution, strict mode
+- **package manager**: pnpm 10.12.3
+- **module type**: ESM (`"type": "module"`)
+- **Node version**: ES2022 compatible (Node 18+)
+
+## Gotchas
+
+- SVG files are returned as-is (sharp corrupts SVGs)
+- If optimized output is larger than input, original is returned
+- Directory output appends `-1` if source === destination (loop prevention)
+- `optimizeBuffer` silently catches all errors — don't add throw/rethrow without checking callers

package/README.md

@@ -9,7 +9,9 @@ Built for developers to quickly reduce asset sizes before deployment without com
 
 - **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`.
+- **Expanded Support:** Optimizes `JPG`, `PNG`, `WebP`, `AVIF`, `GIF`, `TIFF`. SVGs are skipped (copied as-is).
+- **Fast:** Parallel processing — optimizes up to 5 images concurrently per directory.
+- **Progress Tracking:** Shows `[N/total]` progress while optimizing.
 - **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.
 

package/dist/index.js

@@ -8,6 +8,10 @@ import JSZip from "jszip";
 import sharp from "sharp";
 import chalk from "chalk";
 import ora from "ora";
+function logOutputPath(outputPath) {
+  console.log(`
+\u{1F4C1} Output: ${chalk.cyan(outputPath)}`);
+}
 var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
   ".jpg",
   ".jpeg",
@@ -23,7 +27,7 @@ program.name("image-optimizer").description(
   chalk.cyan(
     "\u{1F680} Universal CLI to optimize images (File, Folder, or Zip). Supports JPG, PNG, WebP, AVIF, GIF, TIFF, SVG."
   )
-).version("1.1.1").requiredOption(
+).version("1.2.1").requiredOption(
   "-s, --source <path>",
   "Path to the input file, folder, or zip"
 ).option(
@@ -55,6 +59,7 @@ async function main() {
       );
       spinner.text = "Processing Directory...";
       await processDirectory(sourcePath, outputPath, config);
+      logOutputPath(outputPath);
     } else if (sourcePath.endsWith(".zip")) {
       const outputPath = determineOutputPath(
         sourcePath,
@@ -63,6 +68,7 @@ async function main() {
       );
       spinner.text = "Processing Zip...";
       await processZip(sourcePath, outputPath, config);
+      logOutputPath(outputPath);
     } else if (isSupportedImage(sourcePath)) {
       const ext = path.extname(sourcePath);
       const outputPath = determineOutputPath(
@@ -72,6 +78,7 @@ async function main() {
       );
       spinner.text = "Processing Single File...";
       await processSingleFile(sourcePath, outputPath, config);
+      logOutputPath(outputPath);
     } else {
       spinner.fail(
         "Unsupported file type. Please provide a Folder, Zip, or supported Image."
@@ -91,38 +98,48 @@ async function processDirectory(source, destination, config) {
   }
   await fs.mkdir(destination, { recursive: true });
   const entries = await fs.readdir(source, { withFileTypes: true });
+  const dirEntries = entries.filter((e) => e.isDirectory());
+  const imageEntries = entries.filter((e) => e.isFile() && isSupportedImage(e.name) && path.extname(e.name).toLowerCase() !== ".svg");
+  const nonImageEntries = entries.filter((e) => e.isFile() && (!isSupportedImage(e.name) || path.extname(e.name).toLowerCase() === ".svg"));
+  for (const entry of dirEntries) {
+    await processDirectory(path.join(source, entry.name), path.join(destination, entry.name), config);
+  }
   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 batchSize = 5;
+  const totalImages = imageEntries.length;
+  for (let i = 0; i < imageEntries.length; i += batchSize) {
+    const batch = imageEntries.slice(i, Math.min(i + batchSize, imageEntries.length));
+    const results = await Promise.all(batch.map(async (entry, j) => {
+      const srcPath = path.join(source, entry.name);
+      const destPath = path.join(destination, entry.name);
+      const num = i + j + 1;
+      config.spinner.text = `Optimizing [${num}/${totalImages}]: ${entry.name}`;
+      try {
         const buffer = await fs.readFile(srcPath);
-        const optimizedBuffer = await optimizeBuffer(
-          buffer,
-          path.extname(entry.name),
-          config
-        );
+        const optimizedBuffer = await optimizeBuffer(buffer, path.extname(entry.name), config);
         await fs.writeFile(destPath, optimizedBuffer);
-        processedCount++;
-      } else {
+        return 1;
+      } catch (error) {
+        console.error(chalk.red(`Failed to optimize ${entry.name}: ${error.message}`));
         await fs.copyFile(srcPath, destPath);
+        return 1;
       }
-    }
-  }
-  if (processedCount > 0) {
+    }));
+    processedCount += results.length;
   }
-  console.log(`
-\u{1F4C1} Output: ${chalk.cyan(destination)}`);
+  await Promise.all(nonImageEntries.map((entry) => {
+    return fs.copyFile(path.join(source, entry.name), path.join(destination, entry.name));
+  }));
+  return processedCount;
 }
 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);
+  const imageFiles = fileNames.filter((f) => !zip.files[f].dir && isSupportedImage(f) && path.extname(f).toLowerCase() !== ".svg");
+  const totalImages = imageFiles.length;
+  let imageIndex = 0;
   for (const fileName of fileNames) {
     const file = zip.files[fileName];
     if (file.dir) {
@@ -130,14 +147,19 @@ async function processZip(source, destination, config) {
       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);
+    const ext = path.extname(fileName).toLowerCase();
+    if (ext === ".svg") {
+      newZip.file(fileName, content);
+    } else if (isSupportedImage(fileName)) {
+      imageIndex++;
+      config.spinner.text = `Optimizing in zip [${imageIndex}/${totalImages}]: ${fileName}`;
+      try {
+        const optimized = await optimizeBuffer(content, path.extname(fileName), config);
+        newZip.file(fileName, optimized);
+      } catch (error) {
+        console.error(chalk.red(`Failed to optimize ${fileName}: ${error.message}`));
+        newZip.file(fileName, content);
+      }
     } else {
       newZip.file(fileName, content);
     }
@@ -149,15 +171,11 @@ async function processZip(source, destination, config) {
     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();
@@ -168,6 +186,8 @@ async function optimizeBuffer(buffer, ext, config) {
       pipeline = pipeline.resize({ width: config.width });
     }
     switch (extension) {
+      case ".svg":
+        return buffer;
       case ".jpeg":
       case ".jpg":
         pipeline = pipeline.jpeg({ quality: config.quality, mozjpeg: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantiqh/image-optimizer",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "description": "CLI to optimize images.",
   "main": "dist/index.js",
   "bin": {
@@ -11,7 +11,8 @@
     "build": "tsup src/index.ts --format esm --clean",
     "dev": "tsup src/index.ts --format esm --watch --onSuccess \"node dist/index.js\"",
     "start": "node dist/index.js",
-    "prepublishOnly": "pnpm build"
+    "prepublishOnly": "pnpm build",
+    "deploy": "bash scripts/deploy.sh"
   },
   "keywords": [],
   "author": "Muqtadir A.",

package/scripts/deploy.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+BUMP="${1:-patch}"
+
+echo "==> Bumping version ($BUMP)..."
+
+# Bump version in package.json, creates git commit + tag
+VERSION=$(npm version "$BUMP" --no-git-tag-version)
+
+# Sync version to CLI --version output
+sed -i '' "s/.version(\"[^\"]*\")/.version(\"${VERSION#v}\")/" src/index.ts
+
+echo "==> Building..."
+pnpm build
+
+echo "==> Committing version bump..."
+git add package.json src/index.ts
+git commit -m "$VERSION"
+git tag "$VERSION"
+
+echo "==> Pushing to git..."
+git push && git push --tags
+
+echo "==> Publishing to npm..."
+npm publish --access public
+
+echo "==> Done! Published $VERSION"

package/src/index.ts

@@ -7,6 +7,10 @@ import sharp from "sharp";
 import chalk from "chalk";
 import ora from "ora";
 
+function logOutputPath(outputPath: string): void {
+  console.log(`\n📁 Output: ${chalk.cyan(outputPath)}`);
+}
+
 // --- Configuration ---
 const SUPPORTED_EXTENSIONS = new Set([
   ".jpg",
@@ -28,7 +32,7 @@ program
       "🚀 Universal CLI to optimize images (File, Folder, or Zip). Supports JPG, PNG, WebP, AVIF, GIF, TIFF, SVG."
     )
   )
-  .version("1.1.1")
+  .version("1.2.1")
   .requiredOption(
     "-s, --source <path>",
     "Path to the input file, folder, or zip"
@@ -75,6 +79,7 @@ async function main() {
       );
       spinner.text = "Processing Directory...";
       await processDirectory(sourcePath, outputPath, config);
+      logOutputPath(outputPath); // Log the output path after processing
     } else if (sourcePath.endsWith(".zip")) {
       // MODE: Zip
       const outputPath = determineOutputPath(
@@ -84,6 +89,7 @@ async function main() {
       );
       spinner.text = "Processing Zip...";
       await processZip(sourcePath, outputPath, config);
+      logOutputPath(outputPath); // Log the output path after processing
     } else if (isSupportedImage(sourcePath)) {
       // MODE: Single File
       const ext = path.extname(sourcePath);
@@ -94,6 +100,7 @@ async function main() {
       );
       spinner.text = "Processing Single File...";
       await processSingleFile(sourcePath, outputPath, config);
+      logOutputPath(outputPath); // Log the output path after processing
     } else {
       spinner.fail(
         "Unsupported file type. Please provide a Folder, Zip, or supported Image."
@@ -115,54 +122,55 @@ async function processDirectory(
   source: string,
   destination: string,
   config: any
-) {
-  // 1. Create Destination Folder
-  // If user pointed source as destination (rare error), avoid loop
+): Promise<number> {
   if (source === destination) {
     destination += "-1";
   }
   await fs.mkdir(destination, { recursive: true });
 
-  // 2. Read Directory
   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);
+  const dirEntries = entries.filter(e => e.isDirectory());
+  const imageEntries = entries.filter(e => e.isFile() && isSupportedImage(e.name) && path.extname(e.name).toLowerCase() !== ".svg");
+  const nonImageEntries = entries.filter(e => e.isFile() && (!isSupportedImage(e.name) || path.extname(e.name).toLowerCase() === ".svg"));
 
-    if (entry.isDirectory()) {
-      // Recursive call
-      await processDirectory(srcPath, destPath, config);
-    } else if (entry.isFile()) {
-      if (isSupportedImage(entry.name)) {
-        config.spinner.text = `Optimizing: ${entry.name}`;
+  // Process directories sequentially (recursive)
+  for (const entry of dirEntries) {
+    await processDirectory(path.join(source, entry.name), path.join(destination, entry.name), config);
+  }
+
+  // Process images in parallel batches of 5
+  let processedCount = 0;
+  const batchSize = 5;
+  const totalImages = imageEntries.length;
+
+  for (let i = 0; i < imageEntries.length; i += batchSize) {
+    const batch = imageEntries.slice(i, Math.min(i + batchSize, imageEntries.length));
+    const results = await Promise.all(batch.map(async (entry, j) => {
+      const srcPath = path.join(source, entry.name);
+      const destPath = path.join(destination, entry.name);
+      const num = i + j + 1;
+      config.spinner.text = `Optimizing [${num}/${totalImages}]: ${entry.name}`;
+      try {
         const buffer = await fs.readFile(srcPath);
-        const optimizedBuffer = await optimizeBuffer(
-          buffer,
-          path.extname(entry.name),
-          config
-        );
+        const optimizedBuffer = await optimizeBuffer(buffer, path.extname(entry.name), config);
         await fs.writeFile(destPath, optimizedBuffer);
-        processedCount++;
-      } else {
-        // Copy non-images
+        return 1;
+      } catch (error: any) {
+        console.error(chalk.red(`Failed to optimize ${entry.name}: ${error.message}`));
         await fs.copyFile(srcPath, destPath);
+        return 1;
       }
-    }
+    }));
+    processedCount += results.length;
   }
-  // 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)}`);
+
+  // Copy non-image files in parallel
+  await Promise.all(nonImageEntries.map(entry => {
+    return fs.copyFile(path.join(source, entry.name), path.join(destination, entry.name));
+  }));
+
+  return processedCount;
 }
 
 async function processZip(source: string, destination: string, config: any) {
@@ -171,6 +179,9 @@ async function processZip(source: string, destination: string, config: any) {
   const newZip = new JSZip();
 
   const fileNames = Object.keys(zip.files);
+  const imageFiles = fileNames.filter(f => !zip.files[f].dir && isSupportedImage(f) && path.extname(f).toLowerCase() !== ".svg");
+  const totalImages = imageFiles.length;
+  let imageIndex = 0;
 
   for (const fileName of fileNames) {
     const file = zip.files[fileName];
@@ -180,14 +191,20 @@ async function processZip(source: string, destination: string, config: any) {
     }
 
     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);
+    const ext = path.extname(fileName).toLowerCase();
+
+    if (ext === ".svg") {
+      newZip.file(fileName, content);
+    } else if (isSupportedImage(fileName)) {
+      imageIndex++;
+      config.spinner.text = `Optimizing in zip [${imageIndex}/${totalImages}]: ${fileName}`;
+      try {
+        const optimized = await optimizeBuffer(content, path.extname(fileName), config);
+        newZip.file(fileName, optimized);
+      } catch (error: any) {
+        console.error(chalk.red(`Failed to optimize ${fileName}: ${error.message}`));
+        newZip.file(fileName, content);
+      }
     } else {
       newZip.file(fileName, content);
     }
@@ -200,7 +217,6 @@ async function processZip(source: string, destination: string, config: any) {
     compressionOptions: { level: 6 },
   });
   await fs.writeFile(destination, outputBuffer);
-  console.log(`\n📁 Output: ${chalk.cyan(destination)}`);
 }
 
 async function processSingleFile(
@@ -211,7 +227,6 @@ async function processSingleFile(
   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)}`);
 }
 
 // --- Core Optimizer ---
@@ -234,6 +249,8 @@ async function optimizeBuffer(
 
     // Compress based on format
     switch (extension) {
+      case ".svg":
+        return buffer;
       case ".jpeg":
       case ".jpg":
         pipeline = pipeline.jpeg({ quality: config.quality, mozjpeg: true });