image-processor-mcp 0.1.0

package/src/services/image.services.ts

@@ -0,0 +1,132 @@
+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

@@ -0,0 +1,147 @@
+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;
+  }
+}

package/src/types.ts

@@ -0,0 +1,89 @@
+export interface DownloadImageArgs {
+  url: string;
+  outputPath: string;
+}
+
+export interface CompressImageArgs {
+  inputPath: string;
+  outputPath: string;
+  outputFormat?: string;
+  quality?: number;
+  lossless?: boolean;
+  effort?: number;
+  width?: number;
+  height?: number;
+  maxDimension?: number;
+  recursiveCompress?: boolean;
+  expectedSizeKB?: number;
+  qualityStepDown?: number;
+  minimumQualityFloor?: number;
+}
+
+export interface CompressDirectoryArgs {
+  inputDir: string;
+  outputDir: string;
+  outputFormat?: string;
+  quality?: number;
+  lossless?: boolean;
+  effort?: number;
+  maxDimension?: number;
+  normalizeFilename?: boolean;
+  filenameReplaceChars?: string;
+  filenameCase?: string;
+  normalizeDirname?: boolean;
+  dirnameReplaceChars?: string;
+  dirnameCase?: string;
+  recursiveCompress?: boolean;
+  expectedSizeKB?: number;
+  qualityStepDown?: number;
+  minimumQualityFloor?: number;
+}
+
+export interface FileNamingOptions {
+  enabled: boolean;
+  replaceChars: string[];
+  case: 'lowercase' | 'uppercase' | 'original';
+}
+
+export interface CompressionResult {
+  inputPath: string;
+  outputPath: string;
+  originalSize: number;
+  compressedSize: number;
+  compressionRatio: number;
+  success: boolean;
+  error?: string;
+  iterations: number;
+  qualitySteps: number[];
+  finalQuality: number;
+  exceededTarget: boolean;
+}
+
+export interface ScanFile {
+  fullPath: string;
+  relativePath: string;
+  size: number;
+  ext: string;
+  nameWithoutExt: string;
+}
+
+export interface TreeNode {
+  name: string;
+  type: 'directory' | 'file';
+  children?: TreeNode[];
+  size?: number;
+}
+
+export interface CompressOptions {
+  quality?: number;
+  lossless?: boolean;
+  effort?: number;
+  width?: number;
+  height?: number;
+  maxDimension?: number;
+  recursiveCompress?: boolean;
+  expectedSizeKB?: number;
+  qualityStepDown?: number;
+  minimumQualityFloor?: number;
+  outputFormat?: string;
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "node16",
+    "moduleResolution": "node16",
+    "esModuleInterop": true,
+    "strict": true,
+    "outDir": "build",
+    "rootDir": "src",
+    "declaration": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "build"]
+}