cli.ts

#!/usr/bin/env node

import { parseArgs } from "util";
import { existsSync, mkdirSync, statSync, readdirSync, readFileSync, writeFileSync, globSync } from "fs";
import { join, basename, dirname, resolve, extname } from "path";
// @ts-ignore - generated by wasm-pack
import { process_image } from "./wasm/crispx.js";

function printUsage() {
  console.log(`
crispx - Optimize AI-generated pixel art images

Usage:
  crispx <input> [options]
  crispx <input...> -o <output-dir> [options]

Arguments:
  input               Image file, directory, or glob pattern (e.g. "images/*.png")

Options:
  -o, --output <path>       Output file or directory (default: <input>_crispx.png)
  --merge-threshold <n>     Color merge threshold, higher = fewer colors (default: 50)
  --colors <n>              Max colors via median-cut (optional)
  --edge-threshold <n>      Edge threshold 0.0-1.0 (default: auto)
  --max-size <n>            Max pixel size to check (default: auto)
  --debug                   Save debug visualizations alongside output
  -h, --help                Show this help
`);
}

function processImage(
  inputPath: string,
  outputPath: string,
  opts: {
    mergeThreshold: number;
    colors: number;
    edgeThreshold: number;
    maxSize: number;
    debug: boolean;
  }
): boolean {
  try {
    const pngData = new Uint8Array(readFileSync(inputPath));

    const result = process_image(
      pngData,
      opts.mergeThreshold,
      opts.colors,
      opts.edgeThreshold,
      opts.maxSize,
      opts.debug,
    );

    // Write output PNG
    const outDir = dirname(resolve(outputPath));
    mkdirSync(outDir, { recursive: true });
    writeFileSync(outputPath, new Uint8Array(result.png_data));

    const inputSize = (statSync(inputPath).size / 1024).toFixed(1);
    const outputSize = (result.png_data.length / 1024).toFixed(1);

    console.log(`  ${basename(inputPath)} → ${basename(outputPath)}`);
    console.log(`    ${inputSize}KB → ${outputSize}KB | grid: ${result.optimal_size}px | squares: ${result.num_squares} | output: ${result.grid_width}x${result.grid_height}`);

    // Write debug images
    if (result.debug) {
      const name = basename(outputPath, extname(outputPath));
      const debugDir = join(outDir, `${name}_debug`);
      mkdirSync(debugDir, { recursive: true });

      writeFileSync(join(debugDir, "edges.png"), new Uint8Array(result.debug.edges));
      writeFileSync(join(debugDir, "seeds.png"), new Uint8Array(result.debug.seeds));
      writeFileSync(join(debugDir, "coverage.png"), new Uint8Array(result.debug.coverage));
      writeFileSync(join(debugDir, "tiers.png"), new Uint8Array(result.debug.tiers));

      console.log(`    debug → ${basename(debugDir)}/`);
    }

    return true;
  } catch (err: any) {
    console.error(`  Error processing ${basename(inputPath)}: ${err.message}`);
    return false;
  }
}

function resolveInputFiles(patterns: string[]): string[] {
  const files: string[] = [];
  for (const pattern of patterns) {
    if (pattern.includes("*")) {
      for (const match of globSync(pattern)) {
        files.push(resolve(match));
      }
    } else if (existsSync(pattern)) {
      const stat = statSync(pattern);
      if (stat.isDirectory()) {
        for (const f of readdirSync(pattern)) {
          if (/\.(png|jpg|jpeg|webp|gif)$/i.test(f)) {
            files.push(resolve(join(pattern, f)));
          }
        }
      } else {
        files.push(resolve(pattern));
      }
    } else {
      console.error(`File not found: ${pattern}`);
    }
  }
  return files;
}

// --- Main ---

const { values, positionals } = parseArgs({
  args: process.argv.slice(2),
  options: {
    output: { type: "string", short: "o" },
    "merge-threshold": { type: "string" },
    colors: { type: "string" },
    "edge-threshold": { type: "string" },
    "max-size": { type: "string" },
    debug: { type: "boolean", default: false },
    help: { type: "boolean", short: "h", default: false },
  },
  allowPositionals: true,
});

if (values.help || positionals.length === 0) {
  printUsage();
  process.exit(values.help ? 0 : 1);
}

const inputFiles = resolveInputFiles(positionals);

if (inputFiles.length === 0) {
  console.error("No input files found.");
  process.exit(1);
}

const opts = {
  mergeThreshold: parseInt(values["merge-threshold"] ?? "50"),
  colors: values.colors ? parseInt(values.colors) : -1,           // -1 = no limit
  edgeThreshold: values["edge-threshold"] ? parseFloat(values["edge-threshold"]) : -1.0,  // -1 = auto
  maxSize: values["max-size"] ? parseInt(values["max-size"]) : -1, // -1 = auto
  debug: values.debug ?? false,
};

let successCount = 0;

for (const inputPath of inputFiles) {
  let outputPath: string;

  if (values.output) {
    if (inputFiles.length > 1 || (existsSync(values.output) && statSync(values.output).isDirectory())) {
      mkdirSync(values.output, { recursive: true });
      const name = basename(inputPath, extname(inputPath));
      outputPath = join(values.output, `${name}.png`);
    } else {
      mkdirSync(dirname(values.output), { recursive: true });
      outputPath = values.output;
    }
  } else {
    const dir = dirname(inputPath);
    const name = basename(inputPath, extname(inputPath));
    outputPath = join(dir, `${name}_crispx.png`);
  }

  if (processImage(inputPath, outputPath, opts)) {
    successCount++;
  }
}

if (inputFiles.length > 1) {
  console.log(`\nProcessed ${successCount}/${inputFiles.length} images.`);
}