@semba-ryuichiro/webpify 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 仙波 琉一朗 / Ryuichiro Semba
+
+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,77 @@
+# webpify
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D24.0.0-brightgreen)](https://nodejs.org/)
+
+画像ファイル（PNG/JPEG/GIF）を WebP 形式に変換する CLI ツール
+
+## 機能
+
+- 単一ファイルまたはディレクトリ一括変換
+- 再帰的なディレクトリ走査
+- 品質パラメータの指定（1-100）
+- 出力先ディレクトリの指定
+- 既存ファイルの上書き制御
+- WebP ファイル一覧表示
+
+## インストール
+
+```bash
+npm install -g webpify
+```
+
+## 使い方
+
+### 基本
+
+```bash
+# 単一ファイルを変換
+webpify image.png
+
+# ディレクトリ内の画像を一括変換
+webpify ./images
+
+# 再帰的に変換
+webpify ./images -r
+```
+
+### オプション
+
+| オプション | 説明 | デフォルト |
+|-----------|------|-----------|
+| `-o, --output <dir>` | 出力先ディレクトリ | 入力と同じ |
+| `-q, --quality <n>` | 品質（1-100） | 100 |
+| `-r, --recursive` | 再帰的に処理 | false |
+| `-f, --force` | 既存ファイルを上書き | false |
+| `--list` | WebP ファイル一覧表示 | - |
+| `--quiet` | 統計情報を非表示 | false |
+| `-v, --version` | バージョン表示 | - |
+| `-h, --help` | ヘルプ表示 | - |
+
+### 例
+
+```bash
+# 品質90で変換
+webpify image.png -q 90
+
+# 別ディレクトリに出力
+webpify ./images -o ./webp-images
+
+# 強制上書き + 再帰 + 静音
+webpify ./images -r -f --quiet
+```
+
+## 要件
+
+- Node.js 24.0.0 以上
+
+## ライセンス
+
+[MIT](LICENSE)
+
+## 関連
+
+- [コントリビューションガイド](CONTRIBUTING.md)
+- [変更履歴](CHANGELOG.md)
+- [セキュリティポリシー](SECURITY.md)
+- [行動規範](CODE_OF_CONDUCT.md)

package/dist/adapters/fs-adapter/index.d.ts

@@ -0,0 +1,6 @@
+import type { FileSystemPort } from '../../ports/file-system.js';
+/**
+ * Node.js fs モジュールを使用した FileSystemPort の実装
+ * ファイル操作とディレクトリ走査機能を提供する
+ */
+export declare function createFsAdapter(): FileSystemPort;

package/dist/adapters/fs-adapter/index.js

@@ -0,0 +1,55 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Node.js fs モジュールを使用した FileSystemPort の実装
+ * ファイル操作とディレクトリ走査機能を提供する
+ */
+export function createFsAdapter() {
+    return {
+        async exists(filePath) {
+            try {
+                await fs.access(filePath);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        async isDirectory(filePath) {
+            try {
+                const stat = await fs.stat(filePath);
+                return stat.isDirectory();
+            }
+            catch {
+                return false;
+            }
+        },
+        async mkdir(dirPath) {
+            await fs.mkdir(dirPath, { recursive: true });
+        },
+        async readDir(dirPath) {
+            return await fs.readdir(dirPath);
+        },
+        async readDirRecursive(dirPath) {
+            const result = [];
+            async function traverse(currentPath) {
+                const entries = await fs.readdir(currentPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(currentPath, entry.name);
+                    if (entry.isDirectory()) {
+                        await traverse(fullPath);
+                    }
+                    else {
+                        result.push(fullPath);
+                    }
+                }
+            }
+            await traverse(dirPath);
+            return result;
+        },
+        async stat(filePath) {
+            const stat = await fs.stat(filePath);
+            return { size: stat.size };
+        },
+    };
+}

package/dist/adapters/index.d.ts

@@ -0,0 +1,2 @@
+export { createFsAdapter } from './fs-adapter/index.js';
+export { createSharpAdapter } from './sharp-adapter/index.js';

package/dist/adapters/index.js

@@ -0,0 +1,2 @@
+export { createFsAdapter } from './fs-adapter/index.js';
+export { createSharpAdapter } from './sharp-adapter/index.js';

package/dist/adapters/sharp-adapter/index.d.ts

@@ -0,0 +1,6 @@
+import type { ImageProcessorPort } from '../../ports/image-processor.js';
+/**
+ * sharp ライブラリを使用した ImageProcessorPort の実装
+ * WebP 変換と画像メタデータ取得機能を提供する
+ */
+export declare function createSharpAdapter(): ImageProcessorPort;

package/dist/adapters/sharp-adapter/index.js

@@ -0,0 +1,24 @@
+import sharp from 'sharp';
+/**
+ * sharp ライブラリを使用した ImageProcessorPort の実装
+ * WebP 変換と画像メタデータ取得機能を提供する
+ */
+export function createSharpAdapter() {
+    return {
+        async convertToWebP(inputPath, outputPath, options) {
+            const result = await sharp(inputPath).webp({ quality: options.quality }).toFile(outputPath);
+            return { size: result.size };
+        },
+        async getMetadata(filePath) {
+            const metadata = await sharp(filePath).metadata();
+            if (!metadata.width || !metadata.height || !metadata.format) {
+                throw new Error(`Failed to get metadata for ${filePath}`);
+            }
+            return {
+                format: metadata.format,
+                height: metadata.height,
+                width: metadata.width,
+            };
+        },
+    };
+}

package/dist/cli/argument-parser/index.d.ts

@@ -0,0 +1,25 @@
+import type { ParsedOptions } from '../../types/index.js';
+/**
+ * ArgumentParser サービスのインターフェース
+ */
+export interface ArgumentParserService {
+    /**
+     * コマンドライン引数をパースする
+     * @param argv - process.argv 形式の配列
+     * @returns パースされたオプション
+     */
+    parse(argv: string[]): ParsedOptions;
+    /**
+     * ヘルプメッセージを表示する
+     */
+    showHelp(): void;
+    /**
+     * バージョン情報を表示する
+     */
+    showVersion(): void;
+}
+/**
+ * ArgumentParser のファクトリ関数
+ * @returns ArgumentParserService のインスタンス
+ */
+export declare function createArgumentParser(): ArgumentParserService;

package/dist/cli/argument-parser/index.js

@@ -0,0 +1,108 @@
+import { Command } from 'commander';
+/**
+ * デフォルトの品質値
+ */
+const DEFAULT_QUALITY = 100;
+/**
+ * 品質値の最小値
+ */
+const MIN_QUALITY = 1;
+/**
+ * 品質値の最大値
+ */
+const MAX_QUALITY = 100;
+/**
+ * パッケージのバージョン（package.json から取得できない場合のフォールバック）
+ */
+const VERSION = '1.0.0';
+/**
+ * 品質値をパースしてバリデーションするカスタムパーサー
+ * @param value - ユーザーが入力した品質値（文字列）
+ * @returns パースされた品質値
+ * @throws 無効な品質値の場合はエラーをスロー
+ */
+function parseQuality(value) {
+    const quality = Number.parseInt(value, 10);
+    if (Number.isNaN(quality) || quality < MIN_QUALITY || quality > MAX_QUALITY) {
+        process.stderr.write(`error: Quality must be between ${MIN_QUALITY} and ${MAX_QUALITY}\n`);
+        process.exit(1);
+    }
+    return quality;
+}
+/**
+ * ArgumentParser のファクトリ関数
+ * @returns ArgumentParserService のインスタンス
+ */
+export function createArgumentParser() {
+    const program = new Command();
+    program
+        .name('webpify')
+        .description('CLI tool to convert images to WebP format')
+        .version(VERSION, '-v, --version', 'Show version number')
+        .argument('[input]', 'Input file or directory path')
+        .option('-o, --output <path>', 'Output path')
+        .option('-q, --quality <number>', 'Quality level (1-100)', parseQuality, DEFAULT_QUALITY)
+        .option('-r, --recursive', 'Process directories recursively', false)
+        .option('-f, --force', 'Overwrite existing files', false)
+        .option('--quiet', 'Silent mode (no output)', false)
+        .option('--list', 'List WebP files with size information', false)
+        .configureOutput({
+        writeErr: (str) => process.stderr.write(str),
+        writeOut: (str) => process.stdout.write(str),
+    })
+        .exitOverride();
+    return {
+        parse(argv) {
+            // 引数なしの場合はヘルプを表示
+            if (argv.length <= 2) {
+                program.outputHelp();
+                return {
+                    force: false,
+                    input: '',
+                    list: false,
+                    quality: DEFAULT_QUALITY,
+                    quiet: false,
+                    recursive: false,
+                };
+            }
+            try {
+                program.parse(argv);
+            }
+            catch (err) {
+                // exitOverride()により、--help/--version時に例外がスローされる
+                // 例外をキャッチして正常終了を示す
+                if (err instanceof Error && 'code' in err) {
+                    const code = err.code;
+                    if (code === 'commander.helpDisplayed' || code === 'commander.version') {
+                        return {
+                            force: false,
+                            input: '',
+                            list: false,
+                            quality: DEFAULT_QUALITY,
+                            quiet: false,
+                            recursive: false,
+                        };
+                    }
+                }
+                throw err;
+            }
+            const options = program.opts();
+            const args = program.args;
+            return {
+                force: options['force'],
+                input: args[0] || '',
+                list: options['list'],
+                output: options['output'],
+                quality: options['quality'],
+                quiet: options['quiet'],
+                recursive: options['recursive'],
+            };
+        },
+        showHelp() {
+            program.outputHelp();
+        },
+        showVersion() {
+            process.stdout.write(`${VERSION}\n`);
+        },
+    };
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+export { type ArgumentParserService, createArgumentParser } from './argument-parser/index.js';
+export { createMain, type MainDependencies, type MainService } from './main/index.js';
+export { createReporter, type ReporterService } from './reporter/index.js';

package/dist/cli/index.js

@@ -0,0 +1,3 @@
+export { createArgumentParser } from './argument-parser/index.js';
+export { createMain } from './main/index.js';
+export { createReporter } from './reporter/index.js';

package/dist/cli/main/index.d.ts

@@ -0,0 +1,30 @@
+import type { ConverterService, FileScannerService, ImageInspectorService } from '../../core/index.js';
+import type { ArgumentParserService } from '../argument-parser/index.js';
+import type { ReporterService } from '../reporter/index.js';
+/**
+ * Main サービスの依存性
+ */
+export interface MainDependencies {
+    argumentParser: ArgumentParserService;
+    reporter: ReporterService;
+    converter: ConverterService;
+    fileScanner: FileScannerService;
+    imageInspector: ImageInspectorService;
+}
+/**
+ * Main サービスインターフェース
+ */
+export interface MainService {
+    /**
+     * CLI のメイン処理を実行する
+     * @param argv コマンドライン引数（process.argv 形式）
+     * @returns 終了コード（0: 成功, 1: エラー）
+     */
+    run(argv: string[]): Promise<number>;
+}
+/**
+ * Main サービスを生成するファクトリ関数
+ * @param deps 依存性
+ * @returns MainService インスタンス
+ */
+export declare function createMain(deps: MainDependencies): MainService;

package/dist/cli/main/index.js

@@ -0,0 +1,114 @@
+/**
+ * サポートされる変換対象の拡張子
+ */
+const CONVERT_EXTENSIONS = ['png', 'jpeg', 'jpg', 'gif'];
+/**
+ * WebP ファイルの拡張子
+ */
+const WEBP_EXTENSIONS = ['webp'];
+/**
+ * Main サービスを生成するファクトリ関数
+ * @param deps 依存性
+ * @returns MainService インスタンス
+ */
+export function createMain(deps) {
+    const { argumentParser, reporter, converter, fileScanner, imageInspector } = deps;
+    /**
+     * 一覧表示モードを実行する
+     */
+    async function executeListMode(inputPath, recursive) {
+        const files = await fileScanner.scan(inputPath, {
+            extensions: WEBP_EXTENSIONS,
+            recursive,
+        });
+        const imageInfos = await imageInspector.getInfoBatch(files);
+        const items = imageInfos.map((info) => ({
+            height: info.height,
+            path: info.path,
+            size: info.size,
+            width: info.width,
+        }));
+        reporter.reportImageList(items);
+        return 0;
+    }
+    /**
+     * 単一ファイル変換モードを実行する
+     */
+    async function executeSingleFileMode(inputPath, quality, force, output, quiet) {
+        const result = await converter.convert(inputPath, {
+            force,
+            output,
+            quality,
+        });
+        reporter.reportConversion(result, quiet);
+        return result.error ? 1 : 0;
+    }
+    /**
+     * ディレクトリ変換モードを実行する
+     */
+    async function executeDirectoryMode(inputPath, quality, force, output, recursive, quiet) {
+        const files = await fileScanner.scan(inputPath, {
+            extensions: CONVERT_EXTENSIONS,
+            recursive,
+        });
+        // 変換対象ファイルがない場合は警告を表示（Requirement 4.4）
+        if (files.length === 0) {
+            process.stdout.write('Warning: No convertible files found\n');
+            return 0;
+        }
+        // 進捗コールバック
+        const onProgress = (result, index, total) => {
+            if (!quiet) {
+                reporter.reportProgress(index + 1, total, result.inputPath);
+                reporter.reportConversion(result, quiet);
+            }
+        };
+        const stats = await converter.convertBatch(files, { force, output, quality }, onProgress);
+        if (!quiet) {
+            reporter.reportStats(stats);
+        }
+        // エラーがあった場合は終了コード 1 を返す
+        return stats.errorCount > 0 ? 1 : 0;
+    }
+    return {
+        async run(argv) {
+            const options = argumentParser.parse(argv);
+            // 入力が空の場合は終了（ヘルプは既に表示済み）
+            if (!options.input) {
+                return 0;
+            }
+            // 入力パスの存在確認
+            const exists = await fileScanner.exists(options.input);
+            if (!exists) {
+                process.stderr.write(`Error: File not found: ${options.input}\n`);
+                return 1;
+            }
+            // 一覧表示モード（--list オプション）
+            if (options.list) {
+                const isDir = await fileScanner.isDirectory(options.input);
+                if (!isDir) {
+                    // 単一ファイルの場合も一覧表示
+                    const info = await imageInspector.getInfo(options.input);
+                    reporter.reportImageList([
+                        {
+                            height: info.height,
+                            path: info.path,
+                            size: info.size,
+                            width: info.width,
+                        },
+                    ]);
+                    return 0;
+                }
+                return executeListMode(options.input, options.recursive);
+            }
+            // ファイル or ディレクトリの判定
+            const isDirectory = await fileScanner.isDirectory(options.input);
+            if (isDirectory) {
+                // ディレクトリ変換モード
+                return executeDirectoryMode(options.input, options.quality, options.force, options.output, options.recursive, options.quiet);
+            }
+            // 単一ファイル変換モード
+            return executeSingleFileMode(options.input, options.quality, options.force, options.output, options.quiet);
+        },
+    };
+}

package/dist/cli/reporter/index.d.ts

@@ -0,0 +1,34 @@
+import type { ConversionResult, ConversionStats, ImageListItem } from '../../types/index.js';
+/**
+ * Reporter サービスのインターフェース
+ */
+export interface ReporterService {
+    /**
+     * 単一ファイルの変換結果を表示する
+     * @param result - 変換結果
+     * @param quiet - サイレントモードかどうか
+     */
+    reportConversion(result: ConversionResult, quiet: boolean): void;
+    /**
+     * 進捗を表示する
+     * @param current - 現在の処理番号
+     * @param total - 総ファイル数
+     * @param fileName - 処理中のファイル名
+     */
+    reportProgress(current: number, total: number, fileName: string): void;
+    /**
+     * バッチ変換の統計情報を表示する
+     * @param stats - 統計情報
+     */
+    reportStats(stats: ConversionStats): void;
+    /**
+     * WebP ファイル一覧を表示する
+     * @param items - 画像アイテムのリスト
+     */
+    reportImageList(items: ImageListItem[]): void;
+}
+/**
+ * Reporter のファクトリ関数
+ * @returns ReporterService のインスタンス
+ */
+export declare function createReporter(): ReporterService;

package/dist/cli/reporter/index.js

@@ -0,0 +1,87 @@
+import path from 'node:path';
+/**
+ * バイト数を人間が読みやすい形式にフォーマットする
+ * @param bytes - バイト数
+ * @returns フォーマットされた文字列（例: "10.00 KB"）
+ */
+function formatSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(2)} KB`;
+    }
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+/**
+ * サイズ削減率を計算してフォーマットする
+ * @param inputSize - 入力サイズ
+ * @param outputSize - 出力サイズ
+ * @returns フォーマットされた削減率（例: "50.0%" または "+20.0%"）
+ */
+function formatReduction(inputSize, outputSize) {
+    if (inputSize === 0) {
+        return '0.0%';
+    }
+    const reduction = ((inputSize - outputSize) / inputSize) * 100;
+    if (reduction < 0) {
+        return `+${Math.abs(reduction).toFixed(1)}%`;
+    }
+    return `${reduction.toFixed(1)}%`;
+}
+/**
+ * Reporter のファクトリ関数
+ * @returns ReporterService のインスタンス
+ */
+export function createReporter() {
+    return {
+        reportConversion(result, quiet) {
+            if (quiet) {
+                return;
+            }
+            const fileName = path.basename(result.inputPath);
+            if (result.error) {
+                process.stdout.write(`Error: ${fileName} - ${result.error}\n`);
+                return;
+            }
+            if (result.skipped) {
+                process.stdout.write(`Skipped: ${fileName} (file already exists)\n`);
+                return;
+            }
+            const inputSizeStr = formatSize(result.inputSize);
+            const outputSizeStr = formatSize(result.outputSize);
+            const reduction = formatReduction(result.inputSize, result.outputSize);
+            process.stdout.write(`Converted: ${fileName} (${inputSizeStr} -> ${outputSizeStr}, ${reduction})\n`);
+        },
+        reportImageList(items) {
+            if (items.length === 0) {
+                process.stdout.write('WebP ファイルが見つかりません\n');
+                return;
+            }
+            process.stdout.write('\n--- WebP File List ---\n');
+            process.stdout.write(`${'File'.padEnd(40)} ${'Size'.padEnd(12)} ${'Width'.padEnd(8)} ${'Height'.padEnd(8)}\n`);
+            process.stdout.write(`${'-'.repeat(70)}\n`);
+            for (const item of items) {
+                const fileName = path.basename(item.path);
+                const sizeStr = formatSize(item.size);
+                process.stdout.write(`${fileName.padEnd(40)} ${sizeStr.padEnd(12)} ${String(item.width).padEnd(8)} ${String(item.height).padEnd(8)}\n`);
+            }
+        },
+        reportProgress(current, total, fileName) {
+            process.stdout.write(`[${current}/${total}] Processing: ${fileName}\n`);
+        },
+        reportStats(stats) {
+            process.stdout.write('\n--- Conversion Summary ---\n');
+            process.stdout.write(`Total files: ${stats.totalFiles}\n`);
+            process.stdout.write(`Converted: ${stats.successCount}\n`);
+            process.stdout.write(`Skipped: ${stats.skippedCount}\n`);
+            process.stdout.write(`Errors: ${stats.errorCount}\n`);
+            if (stats.successCount > 0 && stats.totalInputSize > 0) {
+                const inputSizeStr = formatSize(stats.totalInputSize);
+                const outputSizeStr = formatSize(stats.totalOutputSize);
+                const reduction = formatReduction(stats.totalInputSize, stats.totalOutputSize);
+                process.stdout.write(`Total size: ${inputSizeStr} -> ${outputSizeStr} (${reduction})\n`);
+            }
+        },
+    };
+}

package/dist/core/converter/index.d.ts

@@ -0,0 +1,46 @@
+import type { FileSystemPort } from '../../ports/file-system.js';
+import type { ImageProcessorPort } from '../../ports/image-processor.js';
+import type { ConversionResult, ConversionStats, ConvertOptions } from '../../types/index.js';
+/**
+ * Converter の依存性
+ */
+export interface ConverterDependencies {
+    fileSystem: FileSystemPort;
+    imageProcessor: ImageProcessorPort;
+}
+/**
+ * 進捗コールバック関数の型
+ */
+export type ProgressCallback = (result: ConversionResult, index: number, total: number) => void;
+/**
+ * Converter サービスインターフェース
+ */
+export interface ConverterService {
+    /**
+     * ファイルがサポートされた形式かどうか判定する
+     * @param filePath ファイルパス
+     * @returns サポートされている場合は true
+     */
+    isSupportedFormat(filePath: string): boolean;
+    /**
+     * 単一ファイルを WebP に変換する
+     * @param inputPath 入力ファイルパス
+     * @param options 変換オプション
+     * @returns 変換結果
+     */
+    convert(inputPath: string, options: ConvertOptions): Promise<ConversionResult>;
+    /**
+     * 複数ファイルを一括で WebP に変換する
+     * @param inputPaths 入力ファイルパスの配列
+     * @param options 変換オプション
+     * @param onProgress 進捗コールバック（オプション）
+     * @returns 変換統計情報
+     */
+    convertBatch(inputPaths: string[], options: ConvertOptions, onProgress?: ProgressCallback): Promise<ConversionStats>;
+}
+/**
+ * Converter を生成するファクトリ関数
+ * @param deps 依存性
+ * @returns ConverterService インスタンス
+ */
+export declare function createConverter(deps: ConverterDependencies): ConverterService;

package/dist/core/converter/index.js

@@ -0,0 +1,135 @@
+import path from 'node:path';
+/**
+ * サポートされる拡張子のリスト
+ */
+const SUPPORTED_EXTENSIONS = ['png', 'jpeg', 'jpg', 'gif'];
+/**
+ * Converter を生成するファクトリ関数
+ * @param deps 依存性
+ * @returns ConverterService インスタンス
+ */
+export function createConverter(deps) {
+    const { fileSystem, imageProcessor } = deps;
+    /**
+     * ファイルの拡張子を取得する（小文字で返す）
+     */
+    function getExtension(filePath) {
+        return path.extname(filePath).slice(1).toLowerCase();
+    }
+    /**
+     * 出力パスを決定する
+     * @param inputPath 入力ファイルパス
+     * @param output 出力先オプション（ディレクトリ）
+     */
+    function resolveOutputPath(inputPath, output) {
+        const inputDir = path.dirname(inputPath);
+        const inputBasename = path.basename(inputPath, path.extname(inputPath));
+        const outputFilename = `${inputBasename}.webp`;
+        if (output) {
+            return path.join(output, outputFilename);
+        }
+        return path.join(inputDir, outputFilename);
+    }
+    /**
+     * エラー結果を生成するヘルパー関数
+     */
+    function createErrorResult(inputPath, outputPath, error, inputSize = 0) {
+        return {
+            error,
+            inputPath,
+            inputSize,
+            outputPath,
+            outputSize: 0,
+            skipped: false,
+        };
+    }
+    return {
+        async convert(inputPath, options) {
+            const outputPath = resolveOutputPath(inputPath, options.output);
+            // 入力ファイルの存在確認（Requirement 1.4）
+            const inputExists = await fileSystem.exists(inputPath);
+            if (!inputExists) {
+                return createErrorResult(inputPath, outputPath, `File not found: ${inputPath}`);
+            }
+            // サポート形式の検証（Requirement 1.5）
+            const ext = getExtension(inputPath);
+            if (!SUPPORTED_EXTENSIONS.includes(ext)) {
+                return createErrorResult(inputPath, outputPath, `Unsupported format: ${ext}. Supported: ${SUPPORTED_EXTENSIONS.join(', ')}`);
+            }
+            // 既存ファイルのスキップ処理（Requirement 5.1, 5.2）
+            const outputExists = await fileSystem.exists(outputPath);
+            if (outputExists && !options.force) {
+                const inputStat = await fileSystem.stat(inputPath);
+                return {
+                    inputPath,
+                    inputSize: inputStat.size,
+                    outputPath,
+                    outputSize: 0,
+                    skipped: true,
+                };
+            }
+            // 出力ディレクトリが存在しない場合は作成
+            const outputDir = path.dirname(outputPath);
+            const outputDirExists = await fileSystem.exists(outputDir);
+            if (!outputDirExists) {
+                await fileSystem.mkdir(outputDir);
+            }
+            // 入力ファイルのサイズを取得
+            const inputStat = await fileSystem.stat(inputPath);
+            // WebP に変換
+            try {
+                const result = await imageProcessor.convertToWebP(inputPath, outputPath, {
+                    quality: options.quality,
+                });
+                return {
+                    inputPath,
+                    inputSize: inputStat.size,
+                    outputPath,
+                    outputSize: result.size,
+                    skipped: false,
+                };
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                return createErrorResult(inputPath, outputPath, `Image processing failed: ${errorMessage}`, inputStat.size);
+            }
+        },
+        async convertBatch(inputPaths, options, onProgress) {
+            // 統計情報の初期化
+            const stats = {
+                errorCount: 0,
+                skippedCount: 0,
+                successCount: 0,
+                totalFiles: inputPaths.length,
+                totalInputSize: 0,
+                totalOutputSize: 0,
+            };
+            const total = inputPaths.length;
+            // 各ファイルを順次変換
+            for (const [index, inputPath] of inputPaths.entries()) {
+                const result = await this.convert(inputPath, options);
+                // 統計情報を更新
+                stats.totalInputSize += result.inputSize;
+                stats.totalOutputSize += result.outputSize;
+                if (result.error) {
+                    stats.errorCount++;
+                }
+                else if (result.skipped) {
+                    stats.skippedCount++;
+                }
+                else {
+                    stats.successCount++;
+                }
+                // 進捗コールバックを呼び出し
+                if (onProgress) {
+                    onProgress(result, index, total);
+                }
+            }
+            return stats;
+        },
+        isSupportedFormat(filePath) {
+            const ext = getExtension(filePath);
+            return SUPPORTED_EXTENSIONS.includes(ext);
+        },
+    };
+}

package/dist/core/file-scanner/index.d.ts

@@ -0,0 +1,36 @@
+import type { FileSystemPort } from '../../ports/file-system.js';
+import type { ScanOptions } from '../../types/index.js';
+/**
+ * FileScanner の依存性
+ */
+export interface FileScannerDependencies {
+    fileSystem: FileSystemPort;
+}
+/**
+ * FileScanner サービスインターフェース
+ */
+export interface FileScannerService {
+    /**
+     * 指定されたディレクトリ内のファイルをスキャンする
+     * @param directoryPath ディレクトリパス
+     * @param options スキャンオプション
+     * @returns マッチしたファイルパスの配列
+     */
+    scan(directoryPath: string, options: ScanOptions): Promise<string[]>;
+    /**
+     * パスがディレクトリかどうか判定する
+     * @param filePath パス
+     */
+    isDirectory(filePath: string): Promise<boolean>;
+    /**
+     * パスが存在するか確認する
+     * @param filePath パス
+     */
+    exists(filePath: string): Promise<boolean>;
+}
+/**
+ * FileScanner を生成するファクトリ関数
+ * @param deps 依存性
+ * @returns FileScannerService インスタンス
+ */
+export declare function createFileScanner(deps: FileScannerDependencies): FileScannerService;

package/dist/core/file-scanner/index.js

@@ -0,0 +1,39 @@
+import path from 'node:path';
+/**
+ * FileScanner を生成するファクトリ関数
+ * @param deps 依存性
+ * @returns FileScannerService インスタンス
+ */
+export function createFileScanner(deps) {
+    const { fileSystem } = deps;
+    /**
+     * 拡張子がマッチするかチェックする（大文字小文字を区別しない）
+     */
+    function matchesExtension(fileName, extensions) {
+        const ext = path.extname(fileName).slice(1).toLowerCase();
+        return extensions.map((e) => e.toLowerCase()).includes(ext);
+    }
+    return {
+        async exists(filePath) {
+            return fileSystem.exists(filePath);
+        },
+        async isDirectory(filePath) {
+            return fileSystem.isDirectory(filePath);
+        },
+        async scan(directoryPath, options) {
+            const { recursive, extensions } = options;
+            if (recursive) {
+                // 再帰モード: readDirRecursive で全ファイルを取得（フルパスが返る）
+                const allFiles = await fileSystem.readDirRecursive(directoryPath);
+                return allFiles.filter((filePath) => matchesExtension(filePath, extensions));
+            }
+            else {
+                // 非再帰モード: readDir でファイル名のみ取得
+                const fileNames = await fileSystem.readDir(directoryPath);
+                return fileNames
+                    .filter((fileName) => matchesExtension(fileName, extensions))
+                    .map((fileName) => path.join(directoryPath, fileName));
+            }
+        },
+    };
+}

package/dist/core/image-inspector/index.d.ts

@@ -0,0 +1,33 @@
+import type { FileSystemPort } from '../../ports/file-system.js';
+import type { ImageProcessorPort } from '../../ports/image-processor.js';
+import type { ImageInfo } from '../../types/index.js';
+/**
+ * ImageInspector の依存性
+ */
+export interface ImageInspectorDependencies {
+    fileSystem: FileSystemPort;
+    imageProcessor: ImageProcessorPort;
+}
+/**
+ * ImageInspector サービスインターフェース
+ */
+export interface ImageInspectorService {
+    /**
+     * 画像ファイルのメタデータを取得する
+     * @param filePath ファイルパス
+     * @returns 画像情報
+     */
+    getInfo(filePath: string): Promise<ImageInfo>;
+    /**
+     * 複数の画像ファイルのメタデータを一括取得する
+     * @param filePaths ファイルパスの配列
+     * @returns 画像情報の配列
+     */
+    getInfoBatch(filePaths: string[]): Promise<ImageInfo[]>;
+}
+/**
+ * ImageInspector を生成するファクトリ関数
+ * @param deps 依存性
+ * @returns ImageInspectorService インスタンス
+ */
+export declare function createImageInspector(deps: ImageInspectorDependencies): ImageInspectorService;

package/dist/core/image-inspector/index.js

@@ -0,0 +1,31 @@
+/**
+ * ImageInspector を生成するファクトリ関数
+ * @param deps 依存性
+ * @returns ImageInspectorService インスタンス
+ */
+export function createImageInspector(deps) {
+    const { fileSystem, imageProcessor } = deps;
+    return {
+        async getInfo(filePath) {
+            // ファイルサイズを取得
+            const stat = await fileSystem.stat(filePath);
+            // 画像のメタデータを取得
+            const metadata = await imageProcessor.getMetadata(filePath);
+            return {
+                format: metadata.format,
+                height: metadata.height,
+                path: filePath,
+                size: stat.size,
+                width: metadata.width,
+            };
+        },
+        async getInfoBatch(filePaths) {
+            const results = [];
+            for (const filePath of filePaths) {
+                const info = await this.getInfo(filePath);
+                results.push(info);
+            }
+            return results;
+        },
+    };
+}

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export { type ConverterDependencies, type ConverterService, createConverter, type ProgressCallback, } from './converter/index.js';
+export { createFileScanner, type FileScannerDependencies, type FileScannerService } from './file-scanner/index.js';
+export { createImageInspector, type ImageInspectorDependencies, type ImageInspectorService, } from './image-inspector/index.js';

package/dist/core/index.js

@@ -0,0 +1,3 @@
+export { createConverter, } from './converter/index.js';
+export { createFileScanner } from './file-scanner/index.js';
+export { createImageInspector, } from './image-inspector/index.js';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import { createFsAdapter, createSharpAdapter } from './adapters/index.js';
+import { createArgumentParser, createMain, createReporter } from './cli/index.js';
+import { createConverter, createFileScanner, createImageInspector } from './core/index.js';
+/**
+ * エントリポイント
+ * 依存性を組み立てて、メイン処理を実行する
+ */
+async function main() {
+    // アダプターの生成
+    const fsAdapter = createFsAdapter();
+    const sharpAdapter = createSharpAdapter();
+    // コアコンポーネントの生成
+    const converter = createConverter({
+        fileSystem: fsAdapter,
+        imageProcessor: sharpAdapter,
+    });
+    const fileScanner = createFileScanner({
+        fileSystem: fsAdapter,
+    });
+    const imageInspector = createImageInspector({
+        fileSystem: fsAdapter,
+        imageProcessor: sharpAdapter,
+    });
+    // CLI コンポーネントの生成
+    const argumentParser = createArgumentParser();
+    const reporter = createReporter();
+    // メインサービスの生成と実行
+    const mainService = createMain({
+        argumentParser,
+        converter,
+        fileScanner,
+        imageInspector,
+        reporter,
+    });
+    const exitCode = await mainService.run(process.argv);
+    process.exit(exitCode);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Fatal error: ${message}\n`);
+    process.exit(1);
+});

package/dist/ports/file-system.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ファイルシステムポートインターフェース
+ * Node.js fs モジュールを抽象化し、テスト時にモック注入を可能にする
+ */
+export interface FileSystemPort {
+    /**
+     * パスが存在するか確認する
+     * @param path ファイルまたはディレクトリのパス
+     */
+    exists(path: string): Promise<boolean>;
+    /**
+     * パスがディレクトリかどうか確認する
+     * @param path パス
+     */
+    isDirectory(path: string): Promise<boolean>;
+    /**
+     * ディレクトリ内のファイル一覧を取得する
+     * @param path ディレクトリパス
+     */
+    readDir(path: string): Promise<string[]>;
+    /**
+     * ディレクトリ内のファイルを再帰的に取得する
+     * @param path ディレクトリパス
+     */
+    readDirRecursive(path: string): Promise<string[]>;
+    /**
+     * ディレクトリを作成する（再帰的）
+     * @param path ディレクトリパス
+     */
+    mkdir(path: string): Promise<void>;
+    /**
+     * ファイルの統計情報を取得する
+     * @param path ファイルパス
+     */
+    stat(path: string): Promise<{
+        size: number;
+    }>;
+}

package/dist/ports/file-system.js

@@ -0,0 +1 @@
+export {};

package/dist/ports/image-processor.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 画像処理ポートインターフェース
+ * sharp などの画像処理ライブラリを抽象化し、テスト時にモック注入を可能にする
+ */
+export interface ImageProcessorPort {
+    /**
+     * 画像を WebP 形式に変換する
+     * @param inputPath 入力ファイルパス
+     * @param outputPath 出力ファイルパス
+     * @param options 変換オプション
+     * @returns 変換後のファイルサイズ情報
+     */
+    convertToWebP(inputPath: string, outputPath: string, options: {
+        quality: number;
+    }): Promise<{
+        size: number;
+    }>;
+    /**
+     * 画像のメタデータを取得する
+     * @param filePath ファイルパス
+     * @returns 画像の幅、高さ、フォーマット
+     */
+    getMetadata(filePath: string): Promise<{
+        width: number;
+        height: number;
+        format: string;
+    }>;
+}

package/dist/ports/image-processor.js

@@ -0,0 +1 @@
+export {};

package/dist/ports/index.d.ts

@@ -0,0 +1,2 @@
+export type { FileSystemPort } from './file-system.js';
+export type { ImageProcessorPort } from './image-processor.js';

package/dist/ports/index.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,105 @@
+/**
+ * サポートされる画像フォーマット
+ */
+export type SupportedFormat = 'png' | 'jpeg' | 'jpg' | 'gif';
+/**
+ * 変換オプション
+ */
+export interface ConvertOptions {
+    /** 出力先パス（省略時は入力ファイルと同じディレクトリ） */
+    output?: string | undefined;
+    /** 変換品質（1-100、デフォルト: 80） */
+    quality: number;
+    /** 既存ファイルを上書きするかどうか */
+    force: boolean;
+}
+/**
+ * 単一ファイルの変換結果
+ */
+export interface ConversionResult {
+    /** 入力ファイルパス */
+    inputPath: string;
+    /** 出力ファイルパス */
+    outputPath: string;
+    /** 入力ファイルサイズ（バイト） */
+    inputSize: number;
+    /** 出力ファイルサイズ（バイト） */
+    outputSize: number;
+    /** スキップされたかどうか */
+    skipped: boolean;
+    /** エラーメッセージ（エラー発生時のみ） */
+    error?: string | undefined;
+}
+/**
+ * バッチ変換の統計情報
+ */
+export interface ConversionStats {
+    /** 処理対象のファイル総数 */
+    totalFiles: number;
+    /** 変換成功数 */
+    successCount: number;
+    /** スキップ数 */
+    skippedCount: number;
+    /** エラー数 */
+    errorCount: number;
+    /** 入力ファイルの合計サイズ（バイト） */
+    totalInputSize: number;
+    /** 出力ファイルの合計サイズ（バイト） */
+    totalOutputSize: number;
+}
+/**
+ * 画像情報（一覧表示用）
+ */
+export interface ImageInfo {
+    /** ファイルパス */
+    path: string;
+    /** ファイルサイズ（バイト） */
+    size: number;
+    /** 画像の幅（ピクセル） */
+    width: number;
+    /** 画像の高さ（ピクセル） */
+    height: number;
+    /** 画像フォーマット */
+    format: string;
+}
+/**
+ * ファイルスキャンオプション
+ */
+export interface ScanOptions {
+    /** サブディレクトリも再帰的にスキャンするか */
+    recursive: boolean;
+    /** フィルタリングする拡張子リスト */
+    extensions: string[];
+}
+/**
+ * CLI パースオプション
+ */
+export interface ParsedOptions {
+    /** 入力パス（ファイルまたはディレクトリ） */
+    input: string;
+    /** 出力先パス */
+    output?: string | undefined;
+    /** 変換品質（1-100） */
+    quality: number;
+    /** 再帰的に処理するか */
+    recursive: boolean;
+    /** 既存ファイルを上書きするか */
+    force: boolean;
+    /** サイレントモード */
+    quiet: boolean;
+    /** WebP ファイル一覧表示モード */
+    list: boolean;
+}
+/**
+ * 一覧表示用の画像アイテム
+ */
+export interface ImageListItem {
+    /** ファイルパス */
+    path: string;
+    /** ファイルサイズ（バイト） */
+    size: number;
+    /** 画像の幅（ピクセル） */
+    width: number;
+    /** 画像の高さ（ピクセル） */
+    height: number;
+}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,115 @@
+{
+  "author": "Ryuichiro Semba",
+  "bin": {
+    "webpify": "dist/index.js"
+  },
+  "bugs": {
+    "url": "https://github.com/semba-yui/webpify/issues"
+  },
+  "dependencies": {
+    "commander": "catalog:",
+    "sharp": "catalog:"
+  },
+  "description": "CLI tool to convert images to WebP format",
+  "devDependencies": {
+    "@biomejs/biome": "catalog:",
+    "@commitlint/cli": "catalog:",
+    "@commitlint/config-conventional": "catalog:",
+    "@fast-check/vitest": "catalog:",
+    "@secretlint/secretlint-rule-preset-recommend": "catalog:",
+    "@stryker-mutator/core": "catalog:",
+    "@stryker-mutator/typescript-checker": "catalog:",
+    "@stryker-mutator/vitest-runner": "catalog:",
+    "@types/node": "catalog:",
+    "@vitest/coverage-v8": "catalog:",
+    "dependency-cruiser": "catalog:",
+    "fast-check": "catalog:",
+    "lefthook": "catalog:",
+    "remark": "catalog:",
+    "remark-cli": "catalog:",
+    "remark-frontmatter": "catalog:",
+    "remark-gfm": "catalog:",
+    "remark-lint": "catalog:",
+    "remark-preset-lint-consistent": "catalog:",
+    "remark-preset-lint-recommended": "catalog:",
+    "remark-toc": "catalog:",
+    "secretlint": "catalog:",
+    "ts-node": "catalog:",
+    "typedoc": "catalog:",
+    "typedoc-plugin-merge-modules": "catalog:",
+    "typedoc-theme-hierarchy": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "onFail": "download",
+      "version": ">=24.11.0"
+    }
+  },
+  "engines": {
+    "runtime": {
+      "name": "node",
+      "onFail": "download",
+      "version": "^24.11.0"
+    }
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://github.com/semba-yui/webpify#readme",
+  "keywords": [
+    "cli",
+    "converter",
+    "gif",
+    "image",
+    "image-processing",
+    "jpeg",
+    "jpg",
+    "optimization",
+    "png",
+    "sharp",
+    "webp"
+  ],
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "name": "@semba-ryuichiro/webpify",
+  "packageManager": "pnpm@10.26.2",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/semba-yui/webpify.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "deps": "dependency-cruiser src --config .dependency-cruiser.cjs",
+    "deps:graph": "dependency-cruiser src --config .dependency-cruiser.cjs --output-type dot | dot -T svg > dependency-graph.svg",
+    "dev": "tsc --watch",
+    "docs:gen": "typedoc",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "lint:md": "remark . --quiet",
+    "lint:md:fix": "remark . --quiet --output",
+    "lint:secret": "secretlint \"**/*\"",
+    "prepublishOnly": "pnpm run lint && pnpm run test && pnpm run build",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:mutation": "stryker run",
+    "test:mutation:dry": "stryker run --dryRunOnly",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "version": "1.0.0"
+}