image-convert-cli 1.1.1 → 1.1.3

package/README.md

@@ -1,12 +1,12 @@
 # image-convert-cli
 
-> A fast, interactive CLI tool for converting images between WebP, JPEG, and JPG formats
+> A fast, interactive CLI tool for converting images between WebP, JPEG, JPG and PNG formats
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 ## Demo
 
-<video src="assets/demo.mp4" width="100%" autoplay loop muted playsinline></video>
+https://github.com/user-attachments/assets/f3df2efc-5db7-4201-9092-1aa309880380
 
 ## Quick Start
 
@@ -182,8 +182,6 @@ interface ConversionResult {
 }
 ```
 
-See `CLAUDE.md` for detailed development workflow including TDD practices.
-
 ## Contributing
 
 1. Fork the repository

package/bin/index.ts

@@ -8,7 +8,8 @@ const options: ConvertOptions = {};
 
 // Check for update command (positional argument)
 if (args[0] === "update") {
-  await handleUpdate();
+  const autoUpdate = args.includes("--yes") || args.includes("-y");
+  await handleUpdate(undefined, undefined, autoUpdate);
   process.exit(0);
 }
 

package/dist/index.js

@@ -6571,10 +6571,13 @@ var require_lib2 = __commonJS((exports, module) => {
   module.exports = Sharp;
 });
 
+// src/cli.ts
+import { spawn } from "child_process";
+
 // src/prompts.ts
 import * as readline3 from "readline";
-import * as fs2 from "fs";
-import * as path from "path";
+import * as fs3 from "fs";
+import * as path2 from "path";
 
 // node_modules/@inquirer/core/dist/lib/key.js
 var isUpKey = (key, keybindings = []) => key.name === "up" || keybindings.includes("vim") && key.name === "k" || keybindings.includes("emacs") && key.ctrl && key.name === "p";
@@ -8280,7 +8283,7 @@ var dist_default3 = createPrompt((config, done) => {
 });
 // src/converter.ts
 var import_sharp = __toESM(require_lib2(), 1);
-import * as fs from "fs";
+import * as fs2 from "fs";
 
 // src/utils/format.ts
 function formatBytes(bytes) {
@@ -8292,11 +8295,53 @@ function formatBytes(bytes) {
   return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
 }
 
+// src/utils/path.ts
+import * as path from "path";
+import * as fs from "fs";
+function getDefaultDestinationPath(sourcePath, format) {
+  const parsed = path.parse(sourcePath);
+  return path.join(parsed.dir, `${parsed.name}.${format}`);
+}
+function isDirectory(sourcePath) {
+  try {
+    return fs.statSync(sourcePath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function getExtension(filePath) {
+  const ext = path.extname(filePath);
+  return ext.length > 0 ? ext.slice(1).toLowerCase() : "";
+}
+function isSameFormat(sourcePath, targetFormat) {
+  const ext = getExtension(sourcePath);
+  if (ext === targetFormat)
+    return true;
+  if ((ext === "jpeg" || ext === "jpg") && (targetFormat === "jpeg" || targetFormat === "jpg")) {
+    return true;
+  }
+  return false;
+}
+var SUPPORTED_FORMATS = ["webp", "jpeg", "jpg", "png"];
+function getImageFilesFromDirectory(dirPath) {
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    return entries.filter((entry) => entry.isFile()).map((entry) => path.join(dirPath, entry.name)).filter((filePath) => SUPPORTED_FORMATS.includes(getExtension(filePath)));
+  } catch {
+    return [];
+  }
+}
+async function ensureDirectoryExists(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
 // src/converter.ts
 async function convertImage(sourcePath, destinationPath, format, compress) {
   const startTime = Date.now();
   try {
-    const originalSize = fs.statSync(sourcePath).size;
+    const originalSize = fs2.statSync(sourcePath).size;
     let sharpFormat;
     let options;
     switch (format) {
@@ -8317,7 +8362,7 @@ async function convertImage(sourcePath, destinationPath, format, compress) {
         throw new Error(`Unsupported format: ${format}`);
     }
     await import_sharp.default(sourcePath).toFormat(sharpFormat, options).toFile(destinationPath);
-    const outputSize = fs.statSync(destinationPath).size;
+    const outputSize = fs2.statSync(destinationPath).size;
     const elapsed = Date.now() - startTime;
     return {
       success: true,
@@ -8354,16 +8399,85 @@ Output saved to: ${result.destinationPath}`);
 \u2717 Conversion failed:`, result.error);
   }
 }
+async function convertBatch(settings) {
+  const startTime = Date.now();
+  const files = getImageFilesFromDirectory(settings.sourceDir);
+  await ensureDirectoryExists(settings.destinationDir);
+  const results = [];
+  let successCount = 0;
+  let failureCount = 0;
+  let skippedCount = 0;
+  for (const sourcePath of files) {
+    const fileName = __require("path").basename(sourcePath);
+    const destPath = __require("path").join(settings.destinationDir, `${__require("path").parse(fileName).name}.${settings.targetFormat}`);
+    if (isSameFormat(sourcePath, settings.targetFormat)) {
+      skippedCount++;
+      continue;
+    }
+    if (settings.yesMode && fs2.existsSync(destPath)) {
+      skippedCount++;
+      continue;
+    }
+    const result = await convertImage(sourcePath, destPath, settings.targetFormat, settings.compress);
+    results.push(result);
+    if (result.success) {
+      successCount++;
+    } else {
+      failureCount++;
+    }
+  }
+  return {
+    totalFiles: files.length,
+    successCount,
+    failureCount,
+    skippedCount,
+    results,
+    totalElapsed: Date.now() - startTime
+  };
+}
+function displayBatchResult(summary) {
+  console.log(`
+Batch conversion complete!`);
+  console.log(`  Total files: ${summary.totalFiles}`);
+  console.log(`  Converted: ${summary.successCount}`);
+  console.log(`  Failed: ${summary.failureCount}`);
+  console.log(`  Skipped: ${summary.skippedCount}`);
+  console.log(`  Time: ${summary.totalElapsed}ms`);
+  if (summary.successCount > 0) {
+    let totalOriginal = 0;
+    let totalOutput = 0;
+    for (const result of summary.results) {
+      if (result.success) {
+        totalOriginal += result.originalSize;
+        totalOutput += result.outputSize;
+      }
+    }
+    if (totalOriginal > 0) {
+      console.log(`  Saved: ${((totalOriginal - totalOutput) / totalOriginal * 100).toFixed(1)}%`);
+    }
+  }
+  console.log(`
+Output directory: ${summary.results[0]?.destinationPath ? __require("path").dirname(summary.results[0].destinationPath) : "N/A"}`);
+  if (summary.failureCount > 0) {
+    console.log(`
+Failed files:`);
+    for (const result of summary.results) {
+      if (!result.success) {
+        console.log(`  - ${result.sourcePath}: ${result.error}`);
+      }
+    }
+  }
+}
 
 // src/prompts.ts
 function filePathCompleter(line) {
   const trimmed = line.trim();
   const input = trimmed.split(" ")[0] || ".";
   const isDirectoryInput = input.endsWith("/");
-  const dir = isDirectoryInput ? input.slice(0, -1) || "." : path.dirname(input) || ".";
-  const base = isDirectoryInput ? "" : path.basename(input) || "";
+  const dir = isDirectoryInput ? input.slice(0, -1) || "." : path2.dirname(input) || ".";
+  const base = isDirectoryInput ? "" : path2.basename(input) || "";
   try {
-    const files = fs2.readdirSync(dir, { withFileTypes: true });
+    const files = fs3.readdirSync(dir, { withFileTypes: true });
     const filtered = base ? files.filter((dirent) => dirent.name.startsWith(base)) : files;
     const completions = filtered.map((dirent) => {
       const fullPath = dir === "." ? dirent.name : `${dir}/${dirent.name}`;
@@ -8405,7 +8519,7 @@ class InteractivePromptService {
       if (!input.trim()) {
         return "Please enter a file path";
       }
-      if (!fs2.existsSync(input)) {
+      if (!fs3.existsSync(input)) {
         return "File does not exist";
       }
       return true;
@@ -8416,8 +8530,8 @@ class InteractivePromptService {
       if (!input.trim()) {
         return "Please enter a destination path";
       }
-      const dir = path.dirname(input);
-      if (dir !== "." && !fs2.existsSync(dir)) {
+      const dir = path2.dirname(input);
+      if (dir !== "." && !fs3.existsSync(dir)) {
         return "Destination directory does not exist";
       }
       return true;
@@ -8446,6 +8560,29 @@ class InteractivePromptService {
       default: true
     });
   }
+  async promptForOverwrite(filePath) {
+    return dist_default2({
+      message: `File ${filePath} already exists. Overwrite?`,
+      default: false
+    });
+  }
+  async promptBatchDestination(defaultPath, validate2) {
+    return inputWithPathCompletion("Output directory", defaultPath, validate2 || ((input) => {
+      if (!input.trim()) {
+        return "Please enter an output directory";
+      }
+      if (!fs3.existsSync(input)) {
+        return "Output directory does not exist";
+      }
+      return true;
+    }));
+  }
+  async promptBatchConfirm(fileCount) {
+    return dist_default2({
+      message: `Convert ${fileCount} files?`,
+      default: true
+    });
+  }
   showHelp() {
     console.log(`Image Converter CLI
 
@@ -8499,16 +8636,44 @@ Conversion settings:`);
   }
 }
 
-// src/utils/path.ts
-import * as path2 from "path";
-function getDefaultDestinationPath(sourcePath, format) {
-  const parsed = path2.parse(sourcePath);
-  return path2.join(parsed.dir, `${parsed.name}.${format}`);
-}
-
 // src/cli.ts
 var NPM_REGISTRY_URL = "https://registry.npmjs.org/image-convert-cli/latest";
-async function handleUpdate(fetchVersion, currentVersion) {
+async function executeUpdate() {
+  return new Promise((resolve) => {
+    console.log("Updating image-convert-cli...");
+    const child = spawn("bun", ["add", "-g", "image-convert-cli"], {
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (data) => {
+      process.stdout.write(data);
+    });
+    child.stderr?.on("data", (data) => {
+      process.stderr.write(data);
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        console.log("Update completed successfully.");
+      } else {
+        console.error(`Update failed with exit code: ${code}`);
+      }
+      resolve();
+    });
+    child.on("error", (error) => {
+      console.error(`Update failed: ${error.message}`);
+      resolve();
+    });
+  });
+}
+async function promptForUpdate(latestVersion, promptService) {
+  const prompts = promptService || new InteractivePromptService;
+  return prompts.promptConfirm({
+    sourcePath: "",
+    targetFormat: "webp",
+    destinationPath: "",
+    compress: false
+  });
+}
+async function handleUpdate(fetchVersion, currentVersion, autoUpdate, promptService) {
   const fetcher = fetchVersion || (async () => {
     const response = await fetch(NPM_REGISTRY_URL);
     if (!response.ok) {
@@ -8524,7 +8689,16 @@ async function handleUpdate(fetchVersion, currentVersion) {
       console.log(`You are running the latest version: ${version}`);
     } else {
       console.log(`Update available: ${version} -> ${latestVersion}`);
-      console.log("Run: bun update to upgrade");
+      if (autoUpdate) {
+        await executeUpdate();
+      } else {
+        const shouldUpdate = await promptForUpdate(latestVersion, promptService);
+        if (shouldUpdate) {
+          await executeUpdate();
+        } else {
+          console.log("Update cancelled.");
+        }
+      }
     }
   } catch (error) {
     console.error(`Error checking for updates: ${error.message}`);
@@ -8550,6 +8724,11 @@ async function runCli(options, promptService) {
 `);
   const sourcePath = options.source || await prompts.promptSourceFile();
   const targetFormat = options.format || await prompts.promptFormat();
+  const isBatchMode = isDirectory(sourcePath);
+  if (isBatchMode) {
+    await runBatchMode(sourcePath, targetFormat, options, prompts);
+    return;
+  }
   const destinationPath = options.destination || await prompts.promptDestination(getDefaultDestinationPath(sourcePath, targetFormat));
   const compress = options.yes !== undefined ? options.yes : await prompts.promptCompress();
   const settings = {
@@ -8570,12 +8749,35 @@ async function runCli(options, promptService) {
     process.exit(1);
   }
 }
+async function runBatchMode(sourceDir, targetFormat, options, prompts) {
+  const yesMode = options.yes === true;
+  const destinationDir = options.destination || (yesMode ? sourceDir : await prompts.promptBatchDestination(sourceDir));
+  const compress = yesMode ? false : await prompts.promptCompress();
+  const files = getImageFilesFromDirectory(sourceDir);
+  if (!yesMode) {
+    const shouldProceed = await prompts.promptBatchConfirm(files.length);
+    if (!shouldProceed) {
+      console.log("Batch conversion cancelled.");
+      return;
+    }
+  }
+  const batchSettings = {
+    sourceDir,
+    targetFormat,
+    destinationDir,
+    compress,
+    yesMode
+  };
+  const result = await convertBatch(batchSettings);
+  displayBatchResult(result);
+}
 
 // bin/index.ts
 var args = process.argv.slice(2);
 var options = {};
 if (args[0] === "update") {
-  await handleUpdate();
+  const autoUpdate = args.includes("--yes") || args.includes("-y");
+  await handleUpdate(undefined, undefined, autoUpdate);
   process.exit(0);
 }
 if (args[0] === "version") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "image-convert-cli",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "type": "module",
   "bin": {
     "imgc": "./dist/index.js"

package/src/cli.ts

@@ -1,13 +1,63 @@
+import * as path from "node:path";
+import { spawn } from "node:child_process";
 import type { ConvertOptions } from "./types";
 import { IPromptService, InteractivePromptService } from "./prompts";
-import { convertImage, displayConversionResult } from "./converter";
-import { getDefaultDestinationPath } from "./utils/path";
+import { convertImage, displayConversionResult, convertBatch, displayBatchResult } from "./converter";
+import { getDefaultDestinationPath, isDirectory, getImageFilesFromDirectory } from "./utils/path";
+import type { BatchConversionSettings } from "./types";
 
 const NPM_REGISTRY_URL = "https://registry.npmjs.org/image-convert-cli/latest";
 
+export async function executeUpdate(): Promise<void> {
+  return new Promise((resolve) => {
+    console.log("Updating image-convert-cli...");
+
+    const child = spawn("bun", ["add", "-g", "image-convert-cli"], {
+      stdio: ["inherit", "pipe", "pipe"],
+    });
+
+    child.stdout?.on("data", (data) => {
+      process.stdout.write(data);
+    });
+
+    child.stderr?.on("data", (data) => {
+      process.stderr.write(data);
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        console.log("Update completed successfully.");
+      } else {
+        console.error(`Update failed with exit code: ${code}`);
+      }
+      resolve();
+    });
+
+    child.on("error", (error) => {
+      console.error(`Update failed: ${error.message}`);
+      resolve();
+    });
+  });
+}
+
+export async function promptForUpdate(
+  latestVersion: string,
+  promptService?: IPromptService,
+): Promise<boolean> {
+  const prompts = promptService || new InteractivePromptService();
+  return prompts.promptConfirm({
+    sourcePath: "",
+    targetFormat: "webp",
+    destinationPath: "",
+    compress: false,
+  });
+}
+
 export async function handleUpdate(
   fetchVersion?: () => Promise<string>,
   currentVersion?: string,
+  autoUpdate?: boolean,
+  promptService?: IPromptService,
 ): Promise<void> {
   const fetcher = fetchVersion || (async () => {
     const response = await fetch(NPM_REGISTRY_URL);
@@ -27,7 +77,17 @@ export async function handleUpdate(
       console.log(`You are running the latest version: ${version}`);
     } else {
       console.log(`Update available: ${version} -> ${latestVersion}`);
-      console.log("Run: bun update to upgrade");
+
+      if (autoUpdate) {
+        await executeUpdate();
+      } else {
+        const shouldUpdate = await promptForUpdate(latestVersion, promptService);
+        if (shouldUpdate) {
+          await executeUpdate();
+        } else {
+          console.log("Update cancelled.");
+        }
+      }
     }
   } catch (error) {
     console.error(`Error checking for updates: ${(error as Error).message}`);
@@ -64,6 +124,15 @@ export async function runCli(
   const targetFormat =
     options.format || (await prompts.promptFormat());
 
+  // Check if source is a directory (batch mode)
+  const isBatchMode = isDirectory(sourcePath);
+
+  if (isBatchMode) {
+    await runBatchMode(sourcePath, targetFormat, options, prompts);
+    return;
+  }
+
+  // Single file conversion
   const destinationPath =
     options.destination ||
     (await prompts.promptDestination(
@@ -103,3 +172,40 @@ export async function runCli(
     process.exit(1);
   }
 }
+
+async function runBatchMode(
+  sourceDir: string,
+  targetFormat: string,
+  options: ConvertOptions,
+  prompts: IPromptService,
+): Promise<void> {
+  const yesMode = options.yes === true;
+
+  // Get destination directory - default to same as source
+  const destinationDir = options.destination || (yesMode ? sourceDir : await prompts.promptBatchDestination(sourceDir));
+
+  const compress = yesMode ? false : await prompts.promptCompress();
+
+  // Count files to convert
+  const files = getImageFilesFromDirectory(sourceDir);
+
+  // In non-yes mode, show batch confirmation
+  if (!yesMode) {
+    const shouldProceed = await prompts.promptBatchConfirm(files.length);
+    if (!shouldProceed) {
+      console.log("Batch conversion cancelled.");
+      return;
+    }
+  }
+
+  const batchSettings: BatchConversionSettings = {
+    sourceDir,
+    targetFormat: targetFormat as any,
+    destinationDir,
+    compress,
+    yesMode,
+  };
+
+  const result = await convertBatch(batchSettings);
+  displayBatchResult(result);
+}

package/src/converter.ts

@@ -1,7 +1,18 @@
 import sharp from "sharp";
 import * as fs from "node:fs";
-import type { ConversionResult, SupportedFormat } from "./types";
+import type {
+  ConversionResult,
+  SupportedFormat,
+  BatchConversionSettings,
+  BatchConversionSummary,
+  BatchConversionResult,
+} from "./types";
 import { formatBytes } from "./utils/format";
+import {
+  getImageFilesFromDirectory,
+  isSameFormat,
+  ensureDirectoryExists,
+} from "./utils/path";
 
 export async function convertImage(
   sourcePath: string,
@@ -83,3 +94,99 @@ export function displayConversionResult(result: ConversionResult): void {
     console.error("\n✗ Conversion failed:", result.error);
   }
 }
+
+export async function convertBatch(
+  settings: BatchConversionSettings,
+): Promise<BatchConversionSummary> {
+  const startTime = Date.now();
+  const files = getImageFilesFromDirectory(settings.sourceDir);
+
+  await ensureDirectoryExists(settings.destinationDir);
+
+  const results: BatchConversionResult[] = [];
+  let successCount = 0;
+  let failureCount = 0;
+  let skippedCount = 0;
+
+  for (const sourcePath of files) {
+    const fileName = require("node:path").basename(sourcePath);
+    const destPath = require("node:path").join(
+      settings.destinationDir,
+      `${require("node:path").parse(fileName).name}.${settings.targetFormat}`,
+    );
+
+    // Skip files already in target format
+    if (isSameFormat(sourcePath, settings.targetFormat)) {
+      skippedCount++;
+      continue;
+    }
+
+    // Skip existing files in yes mode
+    if (settings.yesMode && fs.existsSync(destPath)) {
+      skippedCount++;
+      continue;
+    }
+
+    const result = await convertImage(
+      sourcePath,
+      destPath,
+      settings.targetFormat,
+      settings.compress,
+    );
+
+    results.push(result);
+
+    if (result.success) {
+      successCount++;
+    } else {
+      failureCount++;
+    }
+  }
+
+  return {
+    totalFiles: files.length,
+    successCount,
+    failureCount,
+    skippedCount,
+    results,
+    totalElapsed: Date.now() - startTime,
+  };
+}
+
+export function displayBatchResult(summary: BatchConversionSummary): void {
+  console.log("\nBatch conversion complete!");
+  console.log(`  Total files: ${summary.totalFiles}`);
+  console.log(`  Converted: ${summary.successCount}`);
+  console.log(`  Failed: ${summary.failureCount}`);
+  console.log(`  Skipped: ${summary.skippedCount}`);
+  console.log(`  Time: ${summary.totalElapsed}ms`);
+
+  if (summary.successCount > 0) {
+    let totalOriginal = 0;
+    let totalOutput = 0;
+
+    for (const result of summary.results) {
+      if (result.success) {
+        totalOriginal += result.originalSize;
+        totalOutput += result.outputSize;
+      }
+    }
+
+    if (totalOriginal > 0) {
+      console.log(
+        `  Saved: ${(((totalOriginal - totalOutput) / totalOriginal) * 100).toFixed(1)}%`,
+      );
+    }
+  }
+
+  console.log(`\nOutput directory: ${summary.results[0]?.destinationPath ? require("node:path").dirname(summary.results[0].destinationPath) : "N/A"}`);
+
+  if (summary.failureCount > 0) {
+    console.log("\nFailed files:");
+    for (const result of summary.results) {
+      if (!result.success) {
+        console.log(`  - ${result.sourcePath}: ${result.error}`);
+      }
+    }
+  }
+}

package/src/index.ts

@@ -1,7 +1,7 @@
 export * from "./types";
 export * from "./utils/path";
 export * from "./utils/format";
-export { convertImage, displayConversionResult } from "./converter";
+export { convertImage, displayConversionResult, convertBatch, displayBatchResult } from "./converter";
 export { runCli, handleUpdate } from "./cli";
 export {
   type IPromptService,

package/src/prompts.ts

@@ -72,6 +72,9 @@ export interface IPromptService {
   promptFormat(): Promise<SupportedFormat>;
   promptCompress(): Promise<boolean>;
   promptConfirm(settings: ConversionSettings): Promise<boolean>;
+  promptForOverwrite(filePath: string): Promise<boolean>;
+  promptBatchDestination(defaultPath: string, validate?: (path: string) => string | true): Promise<string>;
+  promptBatchConfirm(fileCount: number): Promise<boolean>;
   showHelp(): void;
   showSettings(settings: ConversionSettings): void;
   showResult(result: { success: boolean; destinationPath: string; elapsed: number; originalSize: number; outputSize: number; error?: string }): void;
@@ -144,6 +147,40 @@ export class InteractivePromptService implements IPromptService {
     });
   }
 
+  async promptForOverwrite(filePath: string): Promise<boolean> {
+    return confirm({
+      message: `File ${filePath} already exists. Overwrite?`,
+      default: false,
+    });
+  }
+
+  async promptBatchDestination(
+    defaultPath: string,
+    validate?: (path: string) => string | true,
+  ): Promise<string> {
+    return inputWithPathCompletion(
+      "Output directory",
+      defaultPath,
+      validate ||
+        ((input) => {
+          if (!input.trim()) {
+            return "Please enter an output directory";
+          }
+          if (!fs.existsSync(input)) {
+            return "Output directory does not exist";
+          }
+          return true;
+        }),
+    );
+  }
+
+  async promptBatchConfirm(fileCount: number): Promise<boolean> {
+    return confirm({
+      message: `Convert ${fileCount} files?`,
+      default: true,
+    });
+  }
+
   showHelp(): void {
     console.log(`Image Converter CLI
 
@@ -205,6 +242,9 @@ export class NoopPromptService implements IPromptService {
     format?: SupportedFormat;
     compress?: boolean;
     confirm?: boolean;
+    overwrite?: boolean;
+    batchDestination?: string;
+    batchConfirm?: boolean;
   };
 
   constructor(responses?: {
@@ -213,6 +253,9 @@ export class NoopPromptService implements IPromptService {
     format?: SupportedFormat;
     compress?: boolean;
     confirm?: boolean;
+    overwrite?: boolean;
+    batchDestination?: string;
+    batchConfirm?: boolean;
   }) {
     this.responses = responses || {};
   }
@@ -237,6 +280,18 @@ export class NoopPromptService implements IPromptService {
     return this.responses.confirm ?? true;
   }
 
+  async promptForOverwrite(): Promise<boolean> {
+    return this.responses.overwrite ?? false;
+  }
+
+  async promptBatchDestination(defaultPath: string): Promise<string> {
+    return this.responses.batchDestination || defaultPath;
+  }
+
+  async promptBatchConfirm(): Promise<boolean> {
+    return this.responses.batchConfirm ?? true;
+  }
+
   showHelp(): void {}
   showSettings(): void {}
   showResult(): void {}

package/src/types.ts

@@ -26,3 +26,30 @@ export type ConversionSettings = {
   destinationPath: string;
   compress: boolean;
 };
+
+export type BatchConversionResult = {
+  success: boolean;
+  sourcePath: string;
+  destinationPath: string;
+  originalSize: number;
+  outputSize: number;
+  elapsed: number;
+  error?: string;
+};
+
+export type BatchConversionSettings = {
+  sourceDir: string;
+  targetFormat: SupportedFormat;
+  destinationDir: string;
+  compress: boolean;
+  yesMode: boolean;
+};
+
+export type BatchConversionSummary = {
+  totalFiles: number;
+  successCount: number;
+  failureCount: number;
+  skippedCount: number;
+  results: BatchConversionResult[];
+  totalElapsed: number;
+};

package/src/utils/path.ts

@@ -1,4 +1,5 @@
 import * as path from "node:path";
+import * as fs from "node:fs";
 import type { SupportedFormat } from "../types";
 
 export function getDefaultDestinationPath(
@@ -8,3 +9,46 @@ export function getDefaultDestinationPath(
   const parsed = path.parse(sourcePath);
   return path.join(parsed.dir, `${parsed.name}.${format}`);
 }
+
+export function isDirectory(sourcePath: string): boolean {
+  try {
+    return fs.statSync(sourcePath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export function getExtension(filePath: string): string {
+  const ext = path.extname(filePath);
+  return ext.length > 0 ? ext.slice(1).toLowerCase() : "";
+}
+
+export function isSameFormat(sourcePath: string, targetFormat: SupportedFormat): boolean {
+  const ext = getExtension(sourcePath);
+  if (ext === targetFormat) return true;
+  // Handle jpeg/jpg equivalence
+  if ((ext === "jpeg" || ext === "jpg") && (targetFormat === "jpeg" || targetFormat === "jpg")) {
+    return true;
+  }
+  return false;
+}
+
+const SUPPORTED_FORMATS = ["webp", "jpeg", "jpg", "png"];
+
+export function getImageFilesFromDirectory(dirPath: string): string[] {
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    return entries
+      .filter((entry) => entry.isFile())
+      .map((entry) => path.join(dirPath, entry.name))
+      .filter((filePath) => SUPPORTED_FORMATS.includes(getExtension(filePath)));
+  } catch {
+    return [];
+  }
+}
+
+export async function ensureDirectoryExists(dirPath: string): Promise<void> {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}