image-convert-cli 1.0.0

package/index.ts

@@ -0,0 +1 @@
+console.log("Hello via Bun!");

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "image-convert-cli",
+  "version": "1.0.0",
+  "type": "module",
+  "bin": {
+    "imgc": "./dist/index.js"
+  },
+  "scripts": {
+    "start": "bun bin/index.ts",
+    "test": "bun test",
+    "prepare": "husky install",
+    "build": "bun build ./bin/index.ts --outdir ./dist --target bun",
+    "publish": "bun run build && bun publish --access public --ignore-scripts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.2.0",
+    "sharp": "^0.34.5"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.8",
+    "husky": "^9.1.7"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,68 @@
+import type { ConvertOptions } from "./types";
+import { IPromptService, InteractivePromptService } from "./prompts";
+import { convertImage, displayConversionResult } from "./converter";
+import { getDefaultDestinationPath } from "./utils/path";
+
+export async function runCli(
+  options: ConvertOptions,
+  promptService?: IPromptService,
+): Promise<void> {
+  const prompts = promptService || new InteractivePromptService();
+
+  if (options.help) {
+    prompts.showHelp();
+    return;
+  }
+
+  if (options.yes && (!options.source || !options.format)) {
+    console.error("Error: -y mode requires --source and --format arguments");
+    prompts.showHelp();
+    return;
+  }
+
+  console.log("Image Converter - Convert images to webp, jpeg, or jpg\n");
+
+  const sourcePath = options.source || await prompts.promptSourceFile();
+
+  const targetFormat =
+    options.format || (await prompts.promptFormat());
+
+  const destinationPath =
+    options.destination ||
+    (await prompts.promptDestination(
+      getDefaultDestinationPath(sourcePath, targetFormat),
+    ));
+
+  const compress =
+    options.yes !== undefined ? options.yes : await prompts.promptCompress();
+
+  const settings = {
+    sourcePath,
+    targetFormat,
+    destinationPath,
+    compress,
+  };
+
+  prompts.showSettings(settings);
+
+  const shouldProceed =
+    options.yes !== undefined ? options.yes : await prompts.promptConfirm(settings);
+
+  if (!shouldProceed) {
+    console.log("Conversion cancelled.");
+    return;
+  }
+
+  const result = await convertImage(
+    sourcePath,
+    destinationPath,
+    targetFormat,
+    compress,
+  );
+
+  displayConversionResult(result);
+
+  if (!result.success) {
+    process.exit(1);
+  }
+}

package/src/converter.ts

@@ -0,0 +1,79 @@
+import sharp from "sharp";
+import * as fs from "node:fs";
+import type { ConversionResult, SupportedFormat } from "./types";
+import { formatBytes } from "./utils/format";
+
+export async function convertImage(
+  sourcePath: string,
+  destinationPath: string,
+  format: SupportedFormat,
+  compress: boolean,
+): Promise<ConversionResult> {
+  const startTime = Date.now();
+
+  try {
+    const originalSize = fs.statSync(sourcePath).size;
+
+    // Determine output format for Sharp
+    let sharpFormat: keyof sharp.FormatEnum;
+    let options: sharp.JpegOptions | sharp.WebpOptions | sharp.OutputInfo;
+
+    switch (format) {
+      case "webp":
+        sharpFormat = "webp";
+        options = compress
+          ? { quality: 100, lossless: true }
+          : { quality: 100 };
+        break;
+      case "jpeg":
+      case "jpg":
+        sharpFormat = "jpeg";
+        options = compress ? { quality: 100, mozjpeg: true } : { quality: 100 };
+        break;
+      default:
+        throw new Error(`Unsupported format: ${format}`);
+    }
+
+    // Perform the conversion
+    await sharp(sourcePath)
+      .toFormat(sharpFormat, options)
+      .toFile(destinationPath);
+
+    const outputSize = fs.statSync(destinationPath).size;
+    const elapsed = Date.now() - startTime;
+
+    return {
+      success: true,
+      sourcePath,
+      destinationPath,
+      originalSize,
+      outputSize,
+      elapsed,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      sourcePath,
+      destinationPath,
+      originalSize: 0,
+      outputSize: 0,
+      elapsed: Date.now() - startTime,
+      error: (error as Error).message,
+    };
+  }
+}
+
+export function displayConversionResult(result: ConversionResult): void {
+  if (result.success) {
+    console.log("\n✓ Conversion complete!");
+    console.log(`  Time: ${result.elapsed}ms`);
+    console.log(`  Original size: ${formatBytes(result.originalSize)}`);
+    console.log(`  Output size: ${formatBytes(result.outputSize)}`);
+    console.log(
+      `  Saved: ${(((result.originalSize - result.outputSize) / result.originalSize) * 100).toFixed(1)}%`,
+    );
+    console.log(`\nOutput saved to: ${result.destinationPath}`);
+  } else {
+    console.error("\n✗ Conversion failed:", result.error);
+  }
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from "./types";
+export * from "./utils/path";
+export * from "./utils/format";
+export { convertImage, displayConversionResult } from "./converter";
+export { runCli } from "./cli";
+export {
+  type IPromptService,
+  InteractivePromptService,
+  NoopPromptService,
+} from "./prompts";

package/src/prompts.ts

@@ -0,0 +1,233 @@
+import * as readline from "node:readline";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { select, confirm } from "@inquirer/prompts";
+import type { SupportedFormat, ConversionSettings } from "./types";
+import { getDefaultDestinationPath } from "./utils/path";
+import { displayConversionResult } from "./converter";
+
+function filePathCompleter(line: string): readline.CompleterResult {
+  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) || "");
+
+  try {
+    const files: fs.Dirent[] = fs.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}`;
+      return dirent.isDirectory() ? `${fullPath}/` : fullPath;
+    });
+
+    return [completions.length ? completions : [input], input];
+  } catch (error) {
+    return [[input], input];
+  }
+}
+
+async function inputWithPathCompletion(
+  message: string,
+  defaultValue?: string,
+  validate?: (input: string) => string | true,
+): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    completer: filePathCompleter,
+  });
+
+  const question = defaultValue
+    ? `${message} (${defaultValue}): `
+    : `${message}: `;
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      const result = answer.trim() || defaultValue || "";
+      rl.close();
+
+      if (validate) {
+        const validationResult = validate(result);
+        if (validationResult !== true) {
+          console.log(`\nError: ${validationResult}`);
+          inputWithPathCompletion(message, defaultValue, validate).then(resolve);
+          return;
+        }
+      }
+
+      resolve(result);
+    });
+  });
+}
+
+export interface IPromptService {
+  promptSourceFile(validate?: (path: string) => string | true): Promise<string>;
+  promptDestination(defaultPath: string, validate?: (path: string) => string | true): Promise<string>;
+  promptFormat(): Promise<SupportedFormat>;
+  promptCompress(): Promise<boolean>;
+  promptConfirm(settings: ConversionSettings): Promise<boolean>;
+  showHelp(): void;
+  showSettings(settings: ConversionSettings): void;
+  showResult(result: { success: boolean; destinationPath: string; elapsed: number; originalSize: number; outputSize: number; error?: string }): void;
+}
+
+export class InteractivePromptService implements IPromptService {
+  async promptSourceFile(
+    validate?: (path: string) => string | true,
+  ): Promise<string> {
+    return inputWithPathCompletion(
+      "Source file path",
+      undefined,
+      validate ||
+        ((input) => {
+          if (!input.trim()) {
+            return "Please enter a file path";
+          }
+          if (!fs.existsSync(input)) {
+            return "File does not exist";
+          }
+          return true;
+        }),
+    );
+  }
+
+  async promptDestination(
+    defaultPath: string,
+    validate?: (path: string) => string | true,
+  ): Promise<string> {
+    return inputWithPathCompletion(
+      "Destination path",
+      defaultPath,
+      validate ||
+        ((input) => {
+          if (!input.trim()) {
+            return "Please enter a destination path";
+          }
+          const dir = path.dirname(input);
+          if (dir !== "." && !fs.existsSync(dir)) {
+            return "Destination directory does not exist";
+          }
+          return true;
+        }),
+    );
+  }
+
+  async promptFormat(): Promise<SupportedFormat> {
+    return select<SupportedFormat>({
+      message: "Target format:",
+      choices: [
+        { value: "webp", description: "WebP format (recommended for web)" },
+        { value: "jpeg", description: "JPEG format" },
+        { value: "jpg", description: "JPG format" },
+      ],
+    });
+  }
+
+  async promptCompress(): Promise<boolean> {
+    return confirm({
+      message: "Do you want to compress the image?",
+      default: false,
+    });
+  }
+
+  async promptConfirm(settings: ConversionSettings): Promise<boolean> {
+    return confirm({
+      message: "Proceed with conversion?",
+      default: true,
+    });
+  }
+
+  showHelp(): void {
+    console.log(`Image Converter CLI
+
+Usage:
+  imgc [options]
+  imgc --source <path> --format <format> [options]
+  imgc -y --source <path> --format <format>
+
+Options:
+  --help, -h       Show this help message
+  --yes, -y        Non-interactive mode (use defaults for optional prompts)
+  --source, -s     Source file path (required with -y)
+  --format, -f     Target format: webp, jpeg, or jpg (required with -y)
+  --dest, -d       Destination path (optional, auto-generated if not provided)
+  --compress, -c  Enable compression (optional, default: false)
+
+Examples:
+  imgc                           # Interactive mode
+  imgc --help                    # Show help
+  imgc -y --source photo.png --format webp
+  imgc -y --source photo.jpg --format jpeg --compress
+`);
+  }
+
+  showSettings(settings: ConversionSettings): void {
+    console.log("\nConversion settings:");
+    console.log(`  Source: ${settings.sourcePath}`);
+    console.log(`  Target format: ${settings.targetFormat.toUpperCase()}`);
+    console.log(`  Destination: ${settings.destinationPath}`);
+    console.log(`  Compression: ${settings.compress ? "Yes" : "No"}`);
+  }
+
+  showResult(result: { success: boolean; destinationPath: string; elapsed: number; originalSize: number; outputSize: number; error?: string }): void {
+    displayConversionResult({
+      success: result.success,
+      sourcePath: "",
+      destinationPath: result.destinationPath,
+      originalSize: result.originalSize,
+      outputSize: result.outputSize,
+      elapsed: result.elapsed,
+      error: result.error,
+    });
+  }
+}
+
+export class NoopPromptService implements IPromptService {
+  private responses: {
+    source?: string;
+    destination?: string;
+    format?: SupportedFormat;
+    compress?: boolean;
+    confirm?: boolean;
+  };
+
+  constructor(responses?: {
+    source?: string;
+    destination?: string;
+    format?: SupportedFormat;
+    compress?: boolean;
+    confirm?: boolean;
+  }) {
+    this.responses = responses || {};
+  }
+
+  async promptSourceFile(): Promise<string> {
+    return this.responses.source || "";
+  }
+
+  async promptDestination(defaultPath: string): Promise<string> {
+    return this.responses.destination || defaultPath;
+  }
+
+  async promptFormat(): Promise<SupportedFormat> {
+    return this.responses.format || "webp";
+  }
+
+  async promptCompress(): Promise<boolean> {
+    return this.responses.compress ?? false;
+  }
+
+  async promptConfirm(): Promise<boolean> {
+    return this.responses.confirm ?? true;
+  }
+
+  showHelp(): void {}
+  showSettings(): void {}
+  showResult(): void {}
+}

package/src/types.ts

@@ -0,0 +1,27 @@
+export type SupportedFormat = "webp" | "jpeg" | "jpg";
+
+export type ConvertOptions = {
+  help?: boolean;
+  yes?: boolean;
+  source?: string;
+  format?: SupportedFormat;
+  destination?: string;
+  compress?: boolean;
+};
+
+export type ConversionResult = {
+  success: boolean;
+  sourcePath: string;
+  destinationPath: string;
+  originalSize: number;
+  outputSize: number;
+  elapsed: number;
+  error?: string;
+};
+
+export type ConversionSettings = {
+  sourcePath: string;
+  targetFormat: SupportedFormat;
+  destinationPath: string;
+  compress: boolean;
+};

package/src/utils/format.ts

@@ -0,0 +1,7 @@
+export function formatBytes(bytes: number): string {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}

package/src/utils/path.ts

@@ -0,0 +1,10 @@
+import * as path from "node:path";
+import type { SupportedFormat } from "../types";
+
+export function getDefaultDestinationPath(
+  sourcePath: string,
+  format: SupportedFormat,
+): string {
+  const parsed = path.parse(sourcePath);
+  return path.join(parsed.dir, `${parsed.name}.${format}`);
+}