image-processor-mcp 0.1.0 → 0.1.2

package/src/index.ts

@@ -1,204 +0,0 @@
-#!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ErrorCode,
-  ListToolsRequestSchema,
-  McpError,
-} from '@modelcontextprotocol/sdk/types.js';
-import sharp from 'sharp';
-import { ToolController } from './controllers/tool.controller.js';
-import { APP_CONFIG } from './config/app.config.js';
-import type { DownloadImageArgs, CompressImageArgs, CompressDirectoryArgs } from './types.js';
-
-sharp.cache(false);
-
-class ImageDownloaderServer {
-  private server: Server;
-
-  constructor() {
-    this.server = new Server(
-      {
-        name: APP_CONFIG.name,
-        version: APP_CONFIG.version,
-      },
-      {
-        capabilities: {
-          tools: {},
-        },
-      }
-    );
-
-    this.setupToolHandlers();
-    this.server.onerror = (error) => console.error('[MCP Error]', error);
-    process.on('SIGINT', async () => {
-      await this.server.close();
-      process.exit(0);
-    });
-  }
-
-  private isDownloadImageArgs(args: unknown): args is DownloadImageArgs {
-    if (!args || typeof args !== 'object') return false;
-    const a = args as Record<string, unknown>;
-    return typeof a.url === 'string' && typeof a.outputPath === 'string';
-  }
-
-  private isCompressImageArgs(args: unknown): args is CompressImageArgs {
-    if (!args || typeof args !== 'object') return false;
-    const a = args as Record<string, unknown>;
-    return (
-      typeof a.inputPath === 'string' &&
-      typeof a.outputPath === 'string' &&
-      (a.outputFormat === undefined || typeof a.outputFormat === 'string') &&
-      (a.quality === undefined || typeof a.quality === 'number') &&
-      (a.lossless === undefined || typeof a.lossless === 'boolean') &&
-      (a.effort === undefined || typeof a.effort === 'number') &&
-      (a.width === undefined || typeof a.width === 'number') &&
-      (a.height === undefined || typeof a.height === 'number') &&
-      (a.maxDimension === undefined || typeof a.maxDimension === 'number') &&
-      (a.recursiveCompress === undefined || typeof a.recursiveCompress === 'boolean') &&
-      (a.expectedSizeKB === undefined || typeof a.expectedSizeKB === 'number') &&
-      (a.qualityStepDown === undefined || typeof a.qualityStepDown === 'number') &&
-      (a.minimumQualityFloor === undefined || typeof a.minimumQualityFloor === 'number')
-    );
-  }
-
-  private isCompressDirectoryArgs(args: unknown): args is CompressDirectoryArgs {
-    if (!args || typeof args !== 'object') return false;
-    const a = args as Record<string, unknown>;
-    return (
-      typeof a.inputDir === 'string' &&
-      typeof a.outputDir === 'string' &&
-      (a.outputFormat === undefined || typeof a.outputFormat === 'string') &&
-      (a.quality === undefined || typeof a.quality === 'number') &&
-      (a.lossless === undefined || typeof a.lossless === 'boolean') &&
-      (a.effort === undefined || typeof a.effort === 'number') &&
-      (a.maxDimension === undefined || typeof a.maxDimension === 'number') &&
-      (a.normalizeFilename === undefined || typeof a.normalizeFilename === 'boolean') &&
-      (a.filenameReplaceChars === undefined || typeof a.filenameReplaceChars === 'string') &&
-      (a.filenameCase === undefined || typeof a.filenameCase === 'string') &&
-      (a.normalizeDirname === undefined || typeof a.normalizeDirname === 'boolean') &&
-      (a.dirnameReplaceChars === undefined || typeof a.dirnameReplaceChars === 'string') &&
-      (a.dirnameCase === undefined || typeof a.dirnameCase === 'string') &&
-      (a.recursiveCompress === undefined || typeof a.recursiveCompress === 'boolean') &&
-      (a.expectedSizeKB === undefined || typeof a.expectedSizeKB === 'number') &&
-      (a.qualityStepDown === undefined || typeof a.qualityStepDown === 'number') &&
-      (a.minimumQualityFloor === undefined || typeof a.minimumQualityFloor === 'number')
-    );
-  }
-
-  private setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-      tools: [
-        {
-          name: 'download_image',
-          description: 'Download an image from a URL to a specified path',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              url: { type: 'string', description: 'URL of the image to download' },
-              outputPath: { type: 'string', description: 'Path where to save the image' },
-            },
-            required: ['url', 'outputPath'],
-          },
-        },
-        {
-          name: 'compress_image',
-          description: 'Compress or convert a single image with format conversion, quality adjustment, resizing, and optional recursive compression',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              inputPath: { type: 'string', description: 'Path to the input image' },
-              outputPath: { type: 'string', description: 'Path where to save the compressed image' },
-              outputFormat: { type: 'string', description: 'Output format: webp, avif, jpeg, png, tiff, gif (default: webp)' },
-              quality: { type: 'number', description: 'Compression quality 1-100 (default: 85)', minimum: 1, maximum: 100 },
-              lossless: { type: 'boolean', description: 'Use lossless compression (default: false)' },
-              effort: { type: 'number', description: 'CPU effort 0-6, 6 is slowest with best compression (default: 6)', minimum: 0, maximum: 6 },
-              width: { type: 'number', description: 'Exact target width (maintains aspect ratio if only width is specified)' },
-              height: { type: 'number', description: 'Exact target height (maintains aspect ratio if only height is specified)' },
-              maxDimension: { type: 'number', description: 'Auto-resize if width or height exceeds this threshold (default: 2000)' },
-              recursiveCompress: { type: 'boolean', description: 'Re-compress until file is under target size (default: false)' },
-              expectedSizeKB: { type: 'number', description: 'Target file size in KB for recursive compression (default: 100)' },
-              qualityStepDown: { type: 'number', description: 'Quality decrease per recursive iteration (default: 5)' },
-              minimumQualityFloor: { type: 'number', description: 'Minimum quality allowed during recursive compression (default: 10)' },
-            },
-            required: ['inputPath', 'outputPath'],
-          },
-        },
-        {
-          name: 'compress_directory',
-          description: 'Batch compress all images in a directory recursively, preserving folder structure, with an auto-generated report',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              inputDir: { type: 'string', description: 'Input directory containing images' },
-              outputDir: { type: 'string', description: 'Output directory for compressed images' },
-              outputFormat: { type: 'string', description: 'Output format: webp, avif, jpeg, png, tiff, gif (default: webp)' },
-              quality: { type: 'number', description: 'Compression quality 1-100 (default: 85)', minimum: 1, maximum: 100 },
-              lossless: { type: 'boolean', description: 'Use lossless compression (default: false)' },
-              effort: { type: 'number', description: 'CPU effort 0-6 (default: 6)', minimum: 0, maximum: 6 },
-              maxDimension: { type: 'number', description: 'Auto-resize threshold in pixels (default: 2000)' },
-              normalizeFilename: { type: 'boolean', description: 'Enable filename normalization' },
-              filenameReplaceChars: { type: 'string', description: 'Characters to replace with underscore, comma-separated' },
-              filenameCase: { type: 'string', description: 'Filename case: lowercase, uppercase, original' },
-              normalizeDirname: { type: 'boolean', description: 'Enable directory name normalization' },
-              dirnameReplaceChars: { type: 'string', description: 'Characters to replace in directory names, comma-separated' },
-              dirnameCase: { type: 'string', description: 'Directory name case: lowercase, uppercase, original' },
-              recursiveCompress: { type: 'boolean', description: 'Re-compress oversized outputs until target size' },
-              expectedSizeKB: { type: 'number', description: 'Target file size in KB (default: 100)' },
-              qualityStepDown: { type: 'number', description: 'Quality decrease per iteration (default: 5)' },
-              minimumQualityFloor: { type: 'number', description: 'Minimum quality floor (default: 10)' },
-            },
-            required: ['inputDir', 'outputDir'],
-          },
-        },
-        {
-          name: 'get_acknowledgement',
-          description: 'Get all configuration defaults, supported formats, and detailed tool descriptions with parameter explanations',
-          inputSchema: {
-            type: 'object',
-            properties: {},
-            required: [],
-          },
-        },
-      ],
-    }));
-
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      switch (request.params.name) {
-        case 'download_image':
-          if (!this.isDownloadImageArgs(request.params.arguments)) {
-            throw new McpError(ErrorCode.InvalidParams, 'Invalid arguments for download_image');
-          }
-          return ToolController.handleDownloadImage(request.params.arguments);
-        case 'compress_image':
-          if (!this.isCompressImageArgs(request.params.arguments)) {
-            throw new McpError(ErrorCode.InvalidParams, 'Invalid arguments for compress_image');
-          }
-          return ToolController.handleCompressImage(request.params.arguments);
-        case 'compress_directory':
-          if (!this.isCompressDirectoryArgs(request.params.arguments)) {
-            throw new McpError(ErrorCode.InvalidParams, 'Invalid arguments for compress_directory');
-          }
-          return ToolController.handleCompressDirectory(request.params.arguments);
-        case 'get_acknowledgement':
-          return ToolController.handleGetAcknowledgement();
-        default:
-          throw new McpError(
-            ErrorCode.MethodNotFound,
-            "Unknown tool: " + request.params.name
-          );
-      }
-    });
-  }
-
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    console.error('Image Downloader MCP server running on stdio');
-  }
-}
-
-const server = new ImageDownloaderServer();
-server.run().catch(console.error);

package/src/services/file.services.ts

@@ -1,179 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import type { FileNamingOptions, ScanFile, TreeNode } from '../types.js';
-import { SUPPORTED_EXTENSIONS } from '../config/config.constants.js';
-
-export class FileService {
-  static async getImageFiles(dirPath: string, extensions: string[] = SUPPORTED_EXTENSIONS): Promise<string[]> {
-    const files: string[] = [];
-    const items = await fs.readdir(dirPath, { withFileTypes: true });
-    for (const item of items) {
-      const fullPath = path.join(dirPath, item.name);
-      if (item.isDirectory()) {
-        const subFiles = await this.getImageFiles(fullPath, extensions);
-        files.push(...subFiles);
-      } else if (item.isFile()) {
-        const ext = path.extname(item.name).toLowerCase();
-        if (extensions.includes(ext)) {
-          files.push(fullPath);
-        }
-      }
-    }
-    return files;
-  }
-
-  static async getFileSize(filePath: string): Promise<number> {
-    try {
-      const stats = await fs.stat(filePath);
-      return stats.size;
-    } catch {
-      return 0;
-    }
-  }
-
-  static async ensureDir(dirPath: string): Promise<void> {
-    await fs.ensureDir(dirPath);
-  }
-
-  static normalizeName(name: string, options: { replaceChars: string[]; case: string }): string {
-    let normalized = name;
-    if (options.replaceChars.length > 0) {
-      for (const char of options.replaceChars) {
-        if (char) {
-          normalized = normalized.split(char).join('_');
-        }
-      }
-      normalized = normalized.replace(/_+/g, '_').replace(/^_|_$/g, '');
-    }
-    if (options.case === 'lowercase') normalized = normalized.toLowerCase();
-    else if (options.case === 'uppercase') normalized = normalized.toUpperCase();
-    return normalized;
-  }
-
-  static getOutputPath(
-    inputPath: string, inputDir: string, outputDir: string,
-    format: string, fileNaming: FileNamingOptions, dirNaming: FileNamingOptions,
-  ): string {
-    const relativePath = path.relative(inputDir, inputPath);
-    let normalizedPath = relativePath;
-
-    if (dirNaming.enabled) {
-      const parts = relativePath.split(path.sep);
-      const dirParts = parts.slice(0, -1).map(d => this.normalizeName(d, dirNaming));
-      const filename = parts[parts.length - 1];
-      normalizedPath = dirParts.length > 0 ? path.join(...dirParts, filename) : filename;
-    }
-
-    if (fileNaming.enabled) {
-      const ext = path.extname(normalizedPath);
-      const name = path.basename(normalizedPath, ext);
-      const dir = path.dirname(normalizedPath);
-      const normalizedName = this.normalizeName(name, fileNaming);
-      normalizedPath = dir === '.' ? `${normalizedName}${ext}` : path.join(dir, `${normalizedName}${ext}`);
-    }
-
-    const baseName = path.basename(normalizedPath, path.extname(normalizedPath));
-    const dir = path.dirname(normalizedPath);
-    const newExt = `.${format}`;
-    const outputRelPath = dir === '.' ? `${baseName}${newExt}` : path.join(dir, `${baseName}${newExt}`);
-
-    return path.join(outputDir, outputRelPath);
-  }
-
-  static async scanFiles(dirPath: string, baseDir: string, extensions: string[]): Promise<ScanFile[]> {
-    const files: ScanFile[] = [];
-    const items = await fs.readdir(dirPath, { withFileTypes: true });
-    for (const item of items) {
-      const fullPath = path.join(dirPath, item.name);
-      if (item.isDirectory()) {
-        const subFiles = await this.scanFiles(fullPath, baseDir, extensions);
-        files.push(...subFiles);
-      } else if (item.isFile()) {
-        const ext = path.extname(item.name).toLowerCase();
-        if (extensions.includes(ext)) {
-          const stats = await fs.stat(fullPath);
-          files.push({
-            fullPath,
-            relativePath: path.relative(baseDir, fullPath),
-            size: stats.size,
-            ext,
-            nameWithoutExt: path.basename(item.name, path.extname(item.name)),
-          });
-        }
-      }
-    }
-    return files;
-  }
-
-  static buildTree(files: ScanFile[], baseDir: string): TreeNode {
-    const root: TreeNode = { name: path.basename(path.resolve(baseDir)), type: 'directory', children: [] };
-    for (const file of files) {
-      const parts = file.relativePath.split(path.sep);
-      let current = root;
-      for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        const isLast = i === parts.length - 1;
-        let child = current.children?.find(c => c.name === part);
-        if (!child) {
-          child = {
-            name: part,
-            type: isLast ? 'file' : 'directory',
-            children: isLast ? undefined : [],
-            size: isLast ? file.size : undefined,
-          };
-          current.children!.push(child);
-        }
-        current = child;
-      }
-    }
-    this.sortTree(root);
-    return root;
-  }
-
-  private static sortTree(node: TreeNode): void {
-    if (!node.children) return;
-    node.children.sort((a, b) => {
-      if (a.type !== b.type) return a.type === 'directory' ? -1 : 1;
-      return a.name.localeCompare(b.name);
-    });
-    for (const child of node.children) {
-      this.sortTree(child);
-    }
-  }
-
-  static formatTreeMarkdown(node: TreeNode, indent: string = ''): string[] {
-    const lines: string[] = [];
-    if (indent === '') {
-      lines.push('.');
-    }
-    if (!node.children) return lines;
-    for (let i = 0; i < node.children.length; i++) {
-      const child = node.children[i];
-      const isLast = i === node.children.length - 1;
-      const connector = isLast ? '`-- ' : '|-- ';
-      if (child.type === 'file') {
-        const sizeStr = this.formatBytes(child.size || 0);
-        lines.push(`${indent}${connector}${child.name} (${sizeStr})`);
-      } else {
-        lines.push(`${indent}${connector}${child.name}`);
-        const newIndent = indent + (isLast ? '    ' : '|   ');
-        if (child.children) {
-          lines.push(...this.formatTreeMarkdown(child, newIndent));
-        }
-      }
-    }
-    return lines;
-  }
-
-  static normalizeKey(str: string): string {
-    return str.toLowerCase().replace(/[-\s.]+/g, '_');
-  }
-
-  static formatBytes(bytes: number): string {
-    if (bytes === 0) return '0 Bytes';
-    const k = 1024;
-    const sizes = ['Bytes', '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/services/image.services.ts

@@ -1,132 +0,0 @@
-import sharp from 'sharp';
-import { FileService } from './file.services.js';
-import type { CompressionResult, CompressOptions } from '../types.js';
-import { DEFAULTS } from '../config/config.constants.js';
-
-export class ImageService {
-  static async compressImage(
-    inputPath: string,
-    outputPath: string,
-    options: CompressOptions,
-  ): Promise<CompressionResult> {
-    const {
-      quality = DEFAULTS.quality,
-      lossless = DEFAULTS.lossless,
-      effort = DEFAULTS.effort,
-      width,
-      height,
-      maxDimension = DEFAULTS.maxDimension,
-      recursiveCompress = false,
-      expectedSizeKB = DEFAULTS.expectedSizeKB,
-      qualityStepDown = DEFAULTS.qualityStepDown,
-      minimumQualityFloor = DEFAULTS.minimumQualityFloor,
-      outputFormat = DEFAULTS.outputFormat,
-    } = options;
-
-    try {
-      const originalSize = await FileService.getFileSize(inputPath);
-      const metadata = await sharp(inputPath).metadata();
-      const imgWidth = metadata.width || 0;
-      const imgHeight = metadata.height || 0;
-
-      let resizeOptions: { width?: number; height?: number } = {};
-
-      if (width || height) {
-        resizeOptions = { ...(width ? { width } : {}), ...(height ? { height } : {}) };
-      } else if (imgWidth > maxDimension || imgHeight > maxDimension) {
-        const ratio = Math.min(maxDimension / imgWidth, maxDimension / imgHeight);
-        resizeOptions = {
-          width: Math.round(imgWidth * ratio),
-          height: Math.round(imgHeight * ratio),
-        };
-      }
-
-      let currentQuality = quality;
-      let iterations = 0;
-      let compressedSize = 0;
-      const qualitySteps: number[] = [];
-
-      while (true) {
-        let pipeline = sharp(inputPath);
-
-        if (Object.keys(resizeOptions).length > 0) {
-          pipeline = pipeline.resize(resizeOptions.width, resizeOptions.height, {
-            fit: 'inside',
-            withoutEnlargement: true,
-          });
-        }
-
-        pipeline = this.applyFormat(pipeline, outputFormat, { quality: currentQuality, lossless, effort });
-        await pipeline.toFile(outputPath);
-
-        compressedSize = await FileService.getFileSize(outputPath);
-        iterations++;
-        qualitySteps.push(currentQuality);
-
-        const compressedKB = compressedSize / 1024;
-
-        if (recursiveCompress && compressedKB > expectedSizeKB && currentQuality - qualityStepDown >= minimumQualityFloor) {
-          currentQuality -= qualityStepDown;
-        } else {
-          break;
-        }
-      }
-
-      const compressionRatio = originalSize > 0
-        ? parseFloat(((originalSize - compressedSize) / originalSize * 100).toFixed(2))
-        : 0;
-
-      return {
-        inputPath,
-        outputPath,
-        originalSize,
-        compressedSize,
-        compressionRatio,
-        success: true,
-        iterations,
-        qualitySteps,
-        finalQuality: qualitySteps[qualitySteps.length - 1],
-        exceededTarget: recursiveCompress && (compressedSize / 1024) > expectedSizeKB,
-      };
-    } catch (error) {
-      return {
-        inputPath,
-        outputPath,
-        originalSize: 0,
-        compressedSize: 0,
-        compressionRatio: 0,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error',
-        iterations: 0,
-        qualitySteps: [],
-        finalQuality: 0,
-        exceededTarget: false,
-      };
-    }
-  }
-
-  static applyFormat(
-    pipeline: sharp.Sharp,
-    format: string,
-    options: { quality: number; lossless: boolean; effort: number },
-  ): sharp.Sharp {
-    const { quality, lossless, effort } = options;
-
-    switch (format) {
-      case 'webp':
-        return pipeline.webp({ quality, lossless, effort, smartSubsample: true, alphaQuality: 90 });
-      case 'avif':
-        return pipeline.avif({ quality, lossless, effort });
-      case 'jpeg':
-        return pipeline.jpeg({ quality, mozjpeg: true });
-      case 'png':
-        return pipeline.png({ compressionLevel: 9 });
-      case 'tiff':
-        return pipeline.tiff({ quality, compression: 'lzw' });
-      case 'gif':
-        return pipeline.gif();
-      default:
-        return pipeline.webp({ quality, lossless });
-    }
-  }
-}

package/src/services/report.services.ts

@@ -1,147 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import type { CompressionResult } from '../types.js';
-import { FileService } from './file.services.js';
-import { APP_CONFIG } from '../config/app.config.js';
-import { SUPPORTED_OUTPUT_FORMATS } from '../config/config.constants.js';
-
-export class ReportService {
-  static async generateReport(
-    results: CompressionResult[],
-    inputDir: string,
-    outputDir: string,
-    outputFormat: string,
-    startTime: number,
-    duration: number,
-    skippedFiles: string[] = [],
-  ): Promise<string> {
-    const reportDir = path.join(outputDir, 'report');
-    await fs.ensureDir(reportDir);
-
-    const now = new Date();
-    const pad = (n: number) => String(n).padStart(2, '0');
-    const timestamp = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}`;
-    const reportFilename = `scan-report-${timestamp}.md`;
-    const reportPath = path.join(reportDir, reportFilename);
-
-    const successful = results.filter(r => r.success);
-    const failed = results.filter(r => !r.success);
-    const totalOriginalSize = results.reduce((s, r) => s + r.originalSize, 0);
-    const totalCompressedSize = results.reduce((s, r) => s + r.compressedSize, 0);
-    const overallReduction = totalOriginalSize > 0
-      ? ((totalOriginalSize - totalCompressedSize) / totalOriginalSize * 100).toFixed(2)
-      : '0.00';
-
-    const lines: string[] = [];
-
-    lines.push('# Compression Report');
-    lines.push('');
-    lines.push('**MCP Server:** ' + APP_CONFIG.name + ' v' + APP_CONFIG.version);
-    lines.push('**Generated:** ' + now.toLocaleString());
-    lines.push('');
-    lines.push('**Duration:** ' + (duration / 1000).toFixed(2) + 's');
-    lines.push('');
-
-    if (results.length > 0 && skippedFiles.length === 0) {
-      const extensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.webp', `.${outputFormat}`];
-      const outputFiles = await FileService.scanFiles(outputDir, outputDir, extensions);
-      const tree = FileService.buildTree(outputFiles, outputDir);
-      const treeLines = FileService.formatTreeMarkdown(tree);
-
-      lines.push('## Summary');
-      lines.push('');
-      lines.push('| Metric | Value |');
-      lines.push('|--------|-------|');
-      lines.push(`| Total files | ${results.length} |`);
-      lines.push(`| Successful | ${successful.length} |`);
-      lines.push(`| Failed | ${failed.length} |`);
-      lines.push(`| Total original size | ${FileService.formatBytes(totalOriginalSize)} |`);
-      lines.push(`| Total compressed size | ${FileService.formatBytes(totalCompressedSize)} |`);
-      lines.push(`| Overall reduction | ${overallReduction}% |`);
-      lines.push('');
-
-      lines.push('## File Tree');
-      lines.push('');
-      lines.push('```');
-      lines.push(...treeLines);
-      lines.push('```');
-      lines.push('');
-
-      lines.push('## File Details');
-      lines.push('');
-      const uniqueResults = new Map<string, typeof successful[0]>();
-      for (const r of successful) {
-        uniqueResults.set(r.outputPath, r);
-      }
-
-      for (const r of uniqueResults.values()) {
-        const relPath = path.relative(outputDir, r.outputPath);
-        const outKB = (r.compressedSize / 1024).toFixed(2);
-        const inKB = (r.originalSize / 1024).toFixed(2);
-        const warning = r.exceededTarget ? ' ⚠ EXCEEDS LIMIT' : '';
-
-        lines.push(`### ${relPath}`);
-        lines.push(`- Input: ${path.basename(r.inputPath)} | ${inKB} KB`);
-        lines.push(`- Output: ${path.basename(r.outputPath)} | ${outKB} KB${warning}`);
-        lines.push(`- Compression: ${r.compressionRatio}%`);
-        if (r.iterations > 1) {
-          lines.push(`- Iterations: ${r.iterations} | Quality steps: ${r.qualitySteps.join(' → ')} → ${r.finalQuality}`);
-        }
-        lines.push('');
-      }
-
-      if (failed.length > 0) {
-        lines.push('## Failed Files');
-        lines.push('');
-        for (const r of failed) {
-          const relPath = path.relative(inputDir, r.inputPath);
-          lines.push(`- ${relPath}: ${r.error}`);
-        }
-        lines.push('');
-      }
-
-      if (successful.length > 0) {
-        lines.push('## Input vs Output Comparison');
-        lines.push('');
-        lines.push('| File | Input Size | Output Size | Compression | Status |');
-        lines.push('|------|-----------|------------|-------------|--------|');
-        for (const r of uniqueResults.values()) {
-          const relPath = path.relative(outputDir, r.outputPath);
-          const warn = (r.compressedSize / 1024) > 100 ? ' ⚠' : '';
-          lines.push(`| ${relPath} | ${FileService.formatBytes(r.originalSize)} | ${FileService.formatBytes(r.compressedSize)} | ${r.compressionRatio}% | ✅${warn} |`);
-        }
-        lines.push('');
-      }
-    }
-
-    if (skippedFiles.length > 0) {
-      const altFormats = SUPPORTED_OUTPUT_FORMATS.filter(f => f !== outputFormat);
-      const formatsList = altFormats.map(f => '`' + f + '`').join(', ');
-
-      lines.push('### ⚠ Notice');
-      lines.push('');
-      lines.push(`The following **${skippedFiles.length}** file(s) already have the \`.${outputFormat}\` extension and were **skipped** from compression:`);
-      lines.push('');
-      lines.push('> To compress these files:');
-      lines.push('> - **Option 1:** Delete the existing `.${outputFormat}` files from the input directory, then run again');
-      lines.push(`> - **Option 2:** Choose a different output format (e.g., ${formatsList}) instead of \`${outputFormat}\``);
-      lines.push('');
-      for (const f of skippedFiles) {
-        lines.push(`- \`${path.relative(path.resolve(inputDir), f)}\``);
-      }
-      lines.push('');
-    }
-
-    lines.push('');
-    lines.push('---');
-    lines.push('---');
-    lines.push('');
-    lines.push('**Developed by Dhvanil Pansuriya**');
-    lines.push('');
-    lines.push('[GitHub](https://github.com/pansuriyadhvanil/) · [LinkedIn](https://linkedin.com/in/dhvanil-pansuriya/)');
-    lines.push('');
-
-    await fs.writeFile(reportPath, lines.join('\n'), 'utf-8');
-    return reportPath;
-  }
-}