Automating Image Compression for Jekyll Blogs with C# GitHub Actions

using Actions.Core.Extensions;
using Actions.Core.Services;
using ImageCompressor.Handlers;
using ImageCompressor.Services;
using Microsoft.Extensions.DependencyInjection;

using var services = new ServiceCollection()
    .AddGitHubActionsCore()
    .BuildServiceProvider();

var core = services.GetRequiredService<ICoreService>();
var compressorService = new ImageCompressorService(core);
var commandLineHandler = new CommandLineHandler(core, compressorService);

var rootCommand = commandLineHandler.CreateRootCommand();

return rootCommand.Parse(args).Invoke();

public class ImageCompressorService(ICoreService core)
{
    private readonly ICoreService _core = core;

    public async Task<CompressionResult> CompressImagesAsync(string imagesPath, int quality, int maxWidth)
    {
        if (!Directory.Exists(imagesPath))
        {
            _core.WriteWarning($"Images path '{imagesPath}' does not exist. Skipping compression.");
            return new CompressionResult();
        }

        var imageFiles = GetImageFiles(imagesPath);

        if (imageFiles.Count == 0)
        {
            _core.WriteInfo("No images found to compress.");
            return new CompressionResult();
        }

        _core.WriteInfo($"Found {imageFiles.Count} images to process");

        var result = new CompressionResult
        {
            TotalImagesProcessed = imageFiles.Count
        };

        foreach (var imagePath in imageFiles)
        {
            await ProcessImageAsync(imagePath, quality, maxWidth, result);
        }

        _core.WriteInfo(@$"\n✅ Compressed {result.CompressedCount} images, 
            saved {FileHelper.FormatBytes(result.TotalBytesSaved)} total");

        return result;
    }

    private static List<string> GetImageFiles(string imagesPath)
    {
        var imageExtensions = new[] { ".jpg", ".jpeg", ".png" };
        return [.. Directory.GetFiles(imagesPath, "*.*", SearchOption.AllDirectories)
            .Where(f => imageExtensions.Contains(Path.GetExtension(f).ToLower()))];
    }

    private async Task ProcessImageAsync(string imagePath, int quality, int maxWidth, CompressionResult result)
    {
        var originalSize = new FileInfo(imagePath).Length;

        try
        {
            using var image = await Image.LoadAsync(imagePath);
            var extension = Path.GetExtension(imagePath).ToLower();

            // Resize if needed
            if (maxWidth > 0 && image.Width > maxWidth)
            {
                ResizeImage(image, maxWidth, imagePath);
            }

            // Compress based on format
            await CompressAndSaveImageAsync(image, imagePath, extension, quality);

            UpdateCompressionStats(imagePath, originalSize, result);
        }
        catch (Exception ex)
        {
            _core.WriteWarning($"Failed to compress {Path.GetFileName(imagePath)}: {ex.Message}");
        }
    }

    private void ResizeImage(Image image, int maxWidth, string imagePath)
    {
        var ratio = (double)maxWidth / image.Width;
        var newHeight = (int)(image.Height * ratio);

        image.Mutate(x => x.Resize(maxWidth, newHeight));
        _core.WriteDebug($"Resized {Path.GetFileName(imagePath)} to {maxWidth}x{newHeight}");
    }

    private static async Task CompressAndSaveImageAsync(Image image, string imagePath, 
        string extension, int quality)
    {
        if (extension == ".png")
        {
            var encoder = new PngEncoder
            {
                CompressionLevel = PngCompressionLevel.BestCompression
            };
            await image.SaveAsync(imagePath, encoder);
        }
        else // .jpg or .jpeg
        {
            var encoder = new JpegEncoder
            {
                Quality = quality
            };
            await image.SaveAsync(imagePath, encoder);
        }
    }

    private void UpdateCompressionStats(string imagePath, long originalSize, CompressionResult result)
    {
        var newSize = new FileInfo(imagePath).Length;
        var savedBytes = originalSize - newSize;

        if (savedBytes > 0)
        {
            result.TotalBytesSaved += savedBytes;
            result.CompressedCount++;
            var savedPercent = savedBytes * 100.0 / originalSize;
            _core.WriteInfo(@$"✓ {Path.GetFileName(imagePath)}: {FileHelper.FormatBytes(originalSize)} 
                → {FileHelper.FormatBytes(newSize)} (saved {savedPercent:F1}%)");
        }
        else
        {
            _core.WriteDebug($"○ {Path.GetFileName(imagePath)}: Already optimized");
        }
    }
}

public class CommandLineHandler(ICoreService core, ImageCompressorService compressorService)
{
    private readonly ICoreService _core = core;
    private readonly ImageCompressorService _compressorService = compressorService;

    public RootCommand CreateRootCommand()
    {
        var pathOption = new Option<string>("--path")
        {
            Description = "The path to the directory containing images to compress. Default is 'assets/images'.",
            DefaultValueFactory = (arg) =>
            {
                return string.IsNullOrEmpty(arg.GetValueOrDefault<string>()) ? "assets/images" 
                    : arg.GetValueOrDefault<string>();
            }
        };

        var qualityOption = new Option<int>("--quality")
        {
            Description = "The quality to compress images to (1-100). Higher is better quality. Default is 75.",
            DefaultValueFactory = (arg) =>
            {
                return arg.GetValueOrDefault<int>() == 0 ? 75 : arg.GetValueOrDefault<int>();
            }
        };

        var maxWidthOption = new Option<int>("--max-width")
        {
            Description = "The maximum width to resize images to. Set to 0 to disable resizing. Default is 0.",
            DefaultValueFactory = (arg) =>
            {
                return arg.GetValueOrDefault<int>() == 0 ? 0 : arg.GetValueOrDefault<int>();
            }
        };

        var rootCommand = new RootCommand("Compress images for Jekyll blog")
        {
            pathOption,
            qualityOption,
            maxWidthOption
        };

        rootCommand.Description = "Compress images in the specified directory using ImageSharp.";

        rootCommand.SetAction(async (result) =>
        {
            var imagesPath = result.GetValue(pathOption)!;
            var quality = result.GetValue(qualityOption);
            var maxWidth = result.GetValue(maxWidthOption);
            
            try
            {
                var compressionResult = await _compressorService.CompressImagesAsync(imagesPath, quality, maxWidth);
                await _core.SetOutputAsync("compressed-count", compressionResult.CompressedCount.ToString());
                await _core.SetOutputAsync("saved-bytes", compressionResult.TotalBytesSaved.ToString());
            }
            catch (Exception ex)
            {
                _core.SetFailed($"Image compression failed: {ex.Message}");
                Environment.ExitCode = 1;
            }
        });

        return rootCommand;
    }
}