CLI: Add EPUB optimizer for e-paper devices. Issue #2

Author: bigbag

Makefile

@@ -1,6 +1,6 @@
 # Makefile for EPUB to XTC Converter & Optimizer
 
-.PHONY: all serve docker-serve tag help
+.PHONY: all serve docker-serve cli-install cli-convert cli-optimize tag help
 
 PORT ?= 8000
 
@@ -18,6 +18,17 @@ docker-serve: ## Run in Docker (Ctrl+C to stop). Usage: make docker-serve [PORT=
 	@echo "Running at http://localhost:$(PORT) (Ctrl+C to stop)"
 	@docker run --rm -p $(PORT):8000 epub-to-xtc
 
+## CLI:
+
+cli-install: ## Install CLI dependencies
+	@cd cli && npm install
+
+cli-convert: ## Convert EPUB to XTC. Usage: make cli-convert INPUT=book.epub OUTPUT=book.xtc CONFIG=settings.json
+	@cd cli && node index.js convert $(INPUT) -o $(OUTPUT) -c $(CONFIG)
+
+cli-optimize: ## Optimize EPUB for e-paper. Usage: make cli-optimize INPUT=book.epub OUTPUT=optimized.epub CONFIG=settings.json
+	@cd cli && node index.js optimize $(INPUT) -o $(OUTPUT) -c $(CONFIG)
+
 ## Release:
 
 tag: ## Create and push a version tag (triggers GitHub release)

README.md

@@ -81,8 +81,16 @@ node index.js convert ./epubs/ -o ./output/ -c settings.json
 
 # Use XTCH format (2-bit grayscale)
 node index.js convert book.epub -f xtch -c settings.json
+
+# Optimize single EPUB for e-paper
+node index.js optimize book.epub -o book_optimized.epub -c settings.json
+
+# Optimize all EPUBs in a directory
+node index.js optimize ./epubs/ -o ./output/ -c settings.json
 ```
 
+Optimization options are configured in `settings.json` under the `optimizer` section. Set `recursive` to `true` to process subdirectories; use `include`/`exclude` glob patterns to filter files.
+
 Example `settings.json`:
 ```json
 {
@@ -92,7 +100,17 @@ Example `settings.json`:
   "lineHeight": 120,
   "textAlign": "justify",
   "hyphenation": { "enabled": true, "language": "en" },
-  "output": { "format": "xtc", "dithering": true, "ditherStrength": 0.7 }
+  "output": { "format": "xtc", "dithering": true, "ditherStrength": 0.7 },
+  "optimizer": {
+    "removeCss": true,
+    "stripFonts": true,
+    "grayscale": true,
+    "maxImageWidth": 480,
+    "injectCss": true,
+    "recursive": false,
+    "include": "*.epub",
+    "exclude": null
+  }
 }
 ```
 
@@ -159,6 +177,7 @@ Then open http://localhost:8000 in your browser.
 │   ├── converter.js            # WASM integration and conversion logic
 │   ├── encoder.js              # XTG/XTH/XTC format encoding
 │   ├── dither.js               # Floyd-Steinberg dithering
+│   ├── optimizer.js            # EPUB optimizer for e-paper
 │   ├── settings.js             # Settings management
 │   └── package.json            # CLI dependencies
 ├── docs/
@@ -182,6 +201,8 @@ Then open http://localhost:8000 in your browser.
 - Node.js 18+
 - [Commander](https://github.com/tj/commander.js) - CLI framework
 - [JSZip](https://stuk.github.io/jszip/) - ZIP file handling
+- [sharp](https://sharp.pixelplumbing.com/) - Image processing (optimizer)
+- [minimatch](https://github.com/isaacs/minimatch) - Glob pattern matching (optimizer)
 - CREngine WASM (shared with web app)
 
 ## Browser Support

cli/index.js

@@ -8,8 +8,10 @@
 const { program } = require('commander');
 const fs = require('fs');
 const path = require('path');
-const { loadSettings, resolveSettings, validateSettings, generateDefaultConfig } = require('./settings');
+const { minimatch } = require('minimatch');
+const { loadSettings, resolveSettings, validateSettings, validateOptimizerSettings, generateDefaultConfig } = require('./settings');
 const { convertEpub, getOutputPath, cleanup } = require('./converter');
+const { optimizeEpub } = require('./optimizer');
 
 program
     .name('epub-to-xtc')
@@ -87,6 +89,152 @@ program
         console.log('\nImportant: Edit the file to set font.path to your TTF/OTF font file.');
     });
 
+program
+    .command('optimize <input>')
+    .description('Optimize EPUB file(s) for e-paper devices')
+    .option('-o, --output <path>', 'Output file or directory')
+    .option('-c, --config <path>', 'Path to settings JSON file')
+    .action(async (input, options) => {
+        try {
+            const settings = loadSettings(options.config);
+            const opts = settings.optimizer || {};
+
+            const errors = validateOptimizerSettings(settings);
+            if (errors.length > 0) {
+                console.error('Configuration errors:');
+                errors.forEach(e => console.error(`  - ${e}`));
+                process.exit(1);
+            }
+
+            const inputPath = path.resolve(input);
+
+            if (!fs.existsSync(inputPath)) {
+                console.error(`Input not found: ${inputPath}`);
+                process.exit(1);
+            }
+
+            const stat = fs.statSync(inputPath);
+
+            if (stat.isDirectory()) {
+                await optimizeDirectory(inputPath, options.output, opts);
+            } else if (stat.isFile() && inputPath.endsWith('.epub')) {
+                await optimizeSingleFile(inputPath, options.output, opts);
+            } else {
+                console.error('Input must be an EPUB file or directory containing EPUB files');
+                process.exit(1);
+            }
+
+        } catch (err) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+    });
+
+function formatSize(bytes) {
+    return (bytes / 1024).toFixed(1) + ' KB';
+}
+
+async function optimizeSingleFile(inputPath, outputPath, opts) {
+    if (!outputPath) {
+        const dir = path.dirname(inputPath);
+        const ext = path.extname(inputPath);
+        const base = path.basename(inputPath, ext);
+        outputPath = path.join(dir, `${base}_optimized${ext}`);
+    } else if (fs.existsSync(outputPath) && fs.statSync(outputPath).isDirectory()) {
+        outputPath = path.join(outputPath, path.basename(inputPath));
+    } else {
+        outputPath = path.resolve(outputPath);
+    }
+
+    const filename = path.basename(inputPath);
+    console.log(`Optimizing: ${filename}`);
+
+    const result = await optimizeEpub(inputPath, outputPath, opts);
+
+    console.log(`  Output: ${result.outputPath}`);
+    console.log(`  Size: ${formatSize(result.originalSize)} -> ${formatSize(result.optimizedSize)} (${result.reductionPercent}% reduction)`);
+}
+
+/**
+ * Collect EPUB files from a directory, optionally recursive
+ */
+function collectEpubFiles(dir, opts, basedir) {
+    basedir = basedir || dir;
+    let results = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const include = opts.include || '*.epub';
+    const exclude = opts.exclude || null;
+
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relPath = path.relative(basedir, fullPath);
+
+        if (entry.isDirectory() && opts.recursive) {
+            results = results.concat(collectEpubFiles(fullPath, opts, basedir));
+        } else if (entry.isFile()) {
+            if (!minimatch(entry.name, include)) continue;
+            if (exclude && minimatch(entry.name, exclude)) continue;
+            results.push({ absolute: fullPath, relative: relPath });
+        }
+    }
+
+    return results;
+}
+
+async function optimizeDirectory(inputDir, outputDir, opts) {
+    const files = collectEpubFiles(inputDir, opts, inputDir);
+
+    if (files.length === 0) {
+        console.error('No EPUB files found in directory');
+        process.exit(1);
+    }
+
+    const inPlace = !outputDir;
+    if (!outputDir) {
+        outputDir = inputDir;
+    } else {
+        outputDir = path.resolve(outputDir);
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+    }
+
+    console.log(`Optimizing ${files.length} EPUB file(s)...\n`);
+
+    let successCount = 0;
+    let failCount = 0;
+
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        // Preserve relative directory structure in output
+        let outputPath;
+        if (inPlace) {
+            // Add _optimized suffix to avoid overwriting originals
+            const ext = path.extname(file.relative);
+            const base = file.relative.slice(0, -ext.length);
+            outputPath = path.join(outputDir, `${base}_optimized${ext}`);
+        } else {
+            outputPath = path.join(outputDir, file.relative);
+        }
+
+        console.log(`[${i + 1}/${files.length}] ${file.relative}`);
+
+        try {
+            const result = await optimizeEpub(file.absolute, outputPath, opts);
+
+            console.log(`  Output: ${path.basename(result.outputPath)}`);
+            console.log(`  Size: ${formatSize(result.originalSize)} -> ${formatSize(result.optimizedSize)} (${result.reductionPercent}% reduction)\n`);
+            successCount++;
+
+        } catch (err) {
+            console.log(`  Error: ${err.message}\n`);
+            failCount++;
+        }
+    }
+
+    console.log(`\nOptimization complete: ${successCount} succeeded, ${failCount} failed`);
+}
+
 async function convertSingleFile(inputPath, outputPath, settings) {
     // Determine output path
     if (!outputPath) {