@puntoycoma/bulki 3.0.2 → 3.0.4

package/dist/chunk-YUAKNSBH.js

@@ -0,0 +1,851 @@
+#!/usr/bin/env node
+
+// src/output/format-bytes.ts
+function formatBytes(bytes) {
+  if (bytes <= 0) return "0 B";
+  const GB = 1024 * 1024 * 1024;
+  const MB = 1024 * 1024;
+  const KB = 1024;
+  if (bytes >= GB) return `${(bytes / GB).toFixed(2)} GB`;
+  if (bytes >= MB) return `${(bytes / MB).toFixed(2)} MB`;
+  if (bytes >= KB) return `${(bytes / KB).toFixed(2)} KB`;
+  return `${bytes} B`;
+}
+
+// src/pipeline/filter.ts
+import fs from "fs/promises";
+import sharp from "sharp";
+var UNSUPPORTED = "unsupported";
+var PNG_MAGIC = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+var AVIF_BRANDS = /* @__PURE__ */ new Set(["avif", "avis"]);
+var HEIF_BRANDS = /* @__PURE__ */ new Set(["heic", "heix", "hevc", "hevx", "heim", "heis", "mif1", "msf1"]);
+async function detectFormat(filePath) {
+  const buffer = Buffer.alloc(12);
+  try {
+    const handle = await fs.open(filePath, "r");
+    try {
+      const { bytesRead } = await handle.read(buffer, 0, 12, 0);
+      if (bytesRead < 4) return null;
+    } finally {
+      await handle.close();
+    }
+  } catch {
+    return null;
+  }
+  if (buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) return "jpeg";
+  if (buffer.subarray(0, 8).equals(PNG_MAGIC)) return "png";
+  if (buffer.toString("latin1", 0, 4) === "RIFF" && buffer.toString("latin1", 8, 12) === "WEBP")
+    return "webp";
+  if (buffer.toString("latin1", 0, 3) === "GIF") return "gif";
+  if (buffer.toString("latin1", 4, 8) === "ftyp") {
+    const brand = buffer.toString("latin1", 8, 12);
+    if (AVIF_BRANDS.has(brand)) return "avif";
+    if (HEIF_BRANDS.has(brand)) {
+      try {
+        const meta = await sharp(filePath).metadata();
+        if (meta.format === "heif" && meta.compression === "av1") return "avif";
+      } catch {
+      }
+      return UNSUPPORTED;
+    }
+  }
+  return null;
+}
+
+// src/pipeline/optimize.ts
+import fs3 from "fs/promises";
+import path2 from "path";
+
+// src/concurrency/pool.ts
+async function processPool(items, processor, concurrency) {
+  const results = new Array(items.length);
+  const executing = /* @__PURE__ */ new Set();
+  let firstError;
+  let hasError = false;
+  for (let i = 0; i < items.length; i++) {
+    const index = i;
+    const p = processor(items[index]).then((result) => {
+      results[index] = result;
+    }).catch((err) => {
+      if (!hasError) {
+        hasError = true;
+        firstError = err;
+      }
+    }).finally(() => {
+      executing.delete(p);
+    });
+    executing.add(p);
+    if (executing.size >= concurrency) {
+      await Promise.race(executing);
+    }
+  }
+  await Promise.all(executing);
+  if (hasError) {
+    throw firstError;
+  }
+  return results;
+}
+
+// src/pipeline/encode.ts
+import { execFile } from "child_process";
+import fs2 from "fs/promises";
+import os from "os";
+import path from "path";
+import { promisify } from "util";
+import sharp2 from "sharp";
+sharp2.cache(false);
+var execFileAsync = promisify(execFile);
+var ANIMATED_OUTPUTS = /* @__PURE__ */ new Set(["gif", "webp"]);
+var ANIMATED_INPUTS = /* @__PURE__ */ new Set(["gif", "webp"]);
+function getFormatOptions(quality) {
+  return {
+    jpeg: { quality, mozjpeg: true },
+    // `quality` only has an effect together with `palette` (lossy quantisation, like TinyPNG)
+    png: { quality, palette: quality < 100, compressionLevel: 9, adaptiveFiltering: true },
+    webp: { quality },
+    avif: { quality },
+    gif: {}
+  };
+}
+function defaultOutputFormat(detectedFormat) {
+  return detectedFormat === UNSUPPORTED ? "jpeg" : detectedFormat;
+}
+function extensionFor(format) {
+  return format === "jpeg" ? ".jpg" : `.${format}`;
+}
+async function encodeImage(input, detectedFormat, settings, sourcePath) {
+  const outputFormat = settings.format ?? defaultOutputFormat(detectedFormat);
+  let source = input;
+  let sourceFormat = detectedFormat;
+  if (detectedFormat === UNSUPPORTED) {
+    source = await decodeHeic(input, sourcePath);
+    sourceFormat = "jpeg";
+  }
+  const animated = ANIMATED_INPUTS.has(sourceFormat) && ANIMATED_OUTPUTS.has(outputFormat);
+  let pipeline = sharp2(source, { animated, failOn: "error" });
+  if (!animated) pipeline = pipeline.autoOrient();
+  if (settings.resize !== void 0) {
+    pipeline = pipeline.resize({ width: settings.resize, withoutEnlargement: true });
+  }
+  if (outputFormat === "jpeg") pipeline = pipeline.flatten({ background: "#ffffff" });
+  const data = await pipeline.toFormat(outputFormat, getFormatOptions(settings.quality)[outputFormat]).toBuffer();
+  if (outputFormat === sourceFormat && detectedFormat !== UNSUPPORTED && data.length >= input.length) {
+    const fitsWidth = settings.resize === void 0 || ((await sharp2(input).metadata()).width ?? Number.POSITIVE_INFINITY) <= settings.resize;
+    if (fitsWidth) return { data: input, format: outputFormat, keptOriginal: true };
+  }
+  return { data, format: outputFormat, keptOriginal: false };
+}
+async function decodeHeic(input, sourcePath) {
+  if (process.platform !== "darwin") {
+    throw new Error(
+      "HEIC/HEIF photos are not supported on this system. Export them as JPEG first (or run bulki on macOS)."
+    );
+  }
+  const tmpDir = await fs2.mkdtemp(path.join(os.tmpdir(), "bulki-heic-"));
+  try {
+    let inPath = sourcePath;
+    if (!inPath) {
+      inPath = path.join(tmpDir, "input.heic");
+      await fs2.writeFile(inPath, input);
+    }
+    const outPath = path.join(tmpDir, "converted.jpg");
+    await execFileAsync("sips", [
+      "-s",
+      "format",
+      "jpeg",
+      "-s",
+      "formatOptions",
+      "best",
+      inPath,
+      "--out",
+      outPath
+    ]);
+    return await fs2.readFile(outPath);
+  } catch (err) {
+    throw new Error(`Could not convert HEIC photo: ${err.message.split("\n")[0]}`);
+  } finally {
+    await fs2.rm(tmpDir, { recursive: true, force: true });
+  }
+}
+
+// src/pipeline/optimize.ts
+async function optimizeImage(job, settings) {
+  const start = performance.now();
+  const input = await fs3.readFile(job.input);
+  const result = await encodeImage(input, job.detectedFormat, settings, job.input);
+  await fs3.mkdir(path2.dirname(job.output), { recursive: true });
+  const tmp = `${job.output}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    await fs3.writeFile(tmp, result.data);
+    await fs3.rename(tmp, job.output);
+  } catch (err) {
+    await fs3.rm(tmp, { force: true });
+    throw err;
+  }
+  return {
+    inputPath: job.input,
+    outputPath: job.output,
+    originalSize: input.length,
+    newSize: result.data.length,
+    format: result.format,
+    duration: performance.now() - start,
+    keptOriginal: result.keptOriginal
+  };
+}
+async function runBatch(jobs, settings, concurrency, onFileDone, signal) {
+  const start = performance.now();
+  const errors = [];
+  const outcomes = await processPool(
+    jobs,
+    async (job) => {
+      if (signal?.aborted) return null;
+      try {
+        const result = await optimizeImage(job, settings);
+        onFileDone?.(job, result);
+        return result;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        errors.push({ file: job.input, message: friendlyError(error) });
+        onFileDone?.(job, null, error);
+        return null;
+      }
+    },
+    concurrency
+  );
+  return {
+    results: outcomes.filter((r) => r !== null),
+    errors,
+    duration: performance.now() - start
+  };
+}
+function friendlyError(err) {
+  const code = err.code;
+  if (code === "EACCES" || code === "EPERM") return "permission denied";
+  if (code === "ENOSPC") return "disk is full";
+  if (code === "ENOENT") return "file disappeared before it could be read";
+  const msg = err.message.split("\n")[0];
+  if (/VipsJpeg|premature end|corrupt|bad seek|unexpected end/i.test(msg))
+    return `damaged image (${msg})`;
+  return msg;
+}
+
+// src/pipeline/paths.ts
+import fs4 from "fs";
+import os2 from "os";
+import path3 from "path";
+import { fileURLToPath } from "url";
+var isPosix = path3.sep === "/";
+function cleanPathInput(raw) {
+  let value = raw.trim();
+  while (value.length >= 2 && (value.startsWith("'") && value.endsWith("'") || value.startsWith('"') && value.endsWith('"'))) {
+    value = value.slice(1, -1).trim();
+  }
+  if (value.startsWith("file://")) {
+    try {
+      value = fileURLToPath(value);
+    } catch {
+    }
+  }
+  if (isPosix) value = value.replace(/\\(.)/g, "$1");
+  return expandHome(value);
+}
+function expandHome(value) {
+  if (value === "~") return os2.homedir();
+  if (value.startsWith("~/") || value.startsWith("~\\"))
+    return path3.join(os2.homedir(), value.slice(2));
+  return value;
+}
+function splitShellWords(raw) {
+  const words = [];
+  let current = "";
+  let quote = null;
+  let hasWord = false;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+      else if (ch === "\\" && quote === '"' && isPosix && i + 1 < raw.length) current += raw[++i];
+      else current += ch;
+    } else if (ch === "'" || ch === '"') {
+      quote = ch;
+      hasWord = true;
+    } else if (ch === "\\" && isPosix && i + 1 < raw.length) {
+      current += raw[++i];
+      hasWord = true;
+    } else if (/\s/.test(ch)) {
+      if (hasWord) words.push(current);
+      current = "";
+      hasWord = false;
+    } else {
+      current += ch;
+      hasWord = true;
+    }
+  }
+  if (hasWord) words.push(current);
+  return words.map(expandHome);
+}
+function resolveUserPath(raw, cwd = process.cwd()) {
+  return path3.resolve(cwd, cleanPathInput(raw));
+}
+function parsePathInput(raw, cwd = process.cwd()) {
+  if (!raw || raw.trim() === "") return { ok: false, error: "Please enter a path" };
+  const single = resolveUserPath(raw, cwd);
+  if (fs4.existsSync(single)) return { ok: true, paths: [single] };
+  const words = splitShellWords(raw.trim());
+  if (words.length > 1) {
+    const resolved = words.map((w) => path3.resolve(cwd, w));
+    const missing = resolved.filter((p) => !fs4.existsSync(p));
+    if (missing.length === 0) return { ok: true, paths: resolved };
+  }
+  return {
+    ok: false,
+    error: `Can't find "${single}". Check the spelling, or drag the folder into this window.`
+  };
+}
+function isInside(child, parent) {
+  const rel = path3.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path3.isAbsolute(rel);
+}
+function samePath(a, b) {
+  const ra = path3.resolve(a);
+  const rb = path3.resolve(b);
+  return process.platform === "linux" ? ra === rb : ra.toLowerCase() === rb.toLowerCase();
+}
+function commonDir(dirs) {
+  if (dirs.length === 0) return process.cwd();
+  let common = path3.resolve(dirs[0]);
+  for (const d of dirs.slice(1)) {
+    while (!isInside(path3.resolve(d), common)) {
+      const parent = path3.dirname(common);
+      if (parent === common) return common;
+      common = parent;
+    }
+  }
+  return common;
+}
+function displayPath(absPath) {
+  const home = os2.homedir();
+  if (absPath === home) return "~";
+  if (absPath.startsWith(home + path3.sep)) return `~${absPath.slice(home.length)}`;
+  return absPath;
+}
+
+// src/validation/options.ts
+import { availableParallelism } from "os";
+import path4 from "path";
+var DEFAULT_OUTPUT_FOLDER = "bulki-output";
+var DEFAULTS = {
+  quality: 70,
+  output: `./${DEFAULT_OUTPUT_FOLDER}`
+};
+var OUTPUT_FORMATS = ["jpeg", "png", "webp", "gif", "avif"];
+var VALID_FORMATS = ["jpeg", "jpg", "png", "webp", "gif", "avif"];
+function defaultConcurrency() {
+  return Math.max(1, Math.min(availableParallelism(), 8));
+}
+function parseSize(input) {
+  const match = /^(\d+(?:\.\d+)?)\s*(b|kb|mb)$/i.exec(input.trim());
+  if (!match) {
+    throw new Error(`Invalid size format: "${input}". Expected format like 200kb, 1mb, 500b`);
+  }
+  const value = Number(match[1]);
+  const unit = match[2].toLowerCase();
+  if (unit === "b") return value;
+  if (unit === "kb") return value * 1024;
+  return value * 1024 * 1024;
+}
+function parseInteger(value) {
+  return /^\s*-?\d+\s*$/.test(value) ? Number(value) : Number.NaN;
+}
+function normalizeFormat(format) {
+  if (format === void 0 || format === "") return void 0;
+  const f = format.toLowerCase();
+  if (!VALID_FORMATS.includes(f)) {
+    throw new Error(
+      `Invalid format: "${format}" is not a supported format. Use one of: ${OUTPUT_FORMATS.join(", ")}`
+    );
+  }
+  return f === "jpg" ? "jpeg" : f;
+}
+function validateEncodeSettings(raw) {
+  const quality = raw.quality ?? DEFAULTS.quality;
+  if (typeof quality !== "number" || !Number.isInteger(quality) || quality < 1 || quality > 100) {
+    throw new Error("Invalid quality: must be an integer between 1 and 100");
+  }
+  const format = normalizeFormat(raw.format);
+  const resize = raw.resize;
+  if (resize !== void 0) {
+    if (typeof resize !== "number" || !Number.isInteger(resize) || resize <= 0) {
+      throw new Error("Invalid resize: must be a positive integer (width in pixels)");
+    }
+  }
+  return { quality, format, resize };
+}
+function resolveOutputDir(raw, cwd = process.cwd()) {
+  const base = raw.destination !== void 0 ? path4.resolve(cwd, cleanPathInput(raw.destination)) : cwd;
+  if (raw.output !== void 0 && raw.output.trim() !== "") {
+    return path4.resolve(base, cleanPathInput(raw.output));
+  }
+  const folder = raw.outputFolder ?? DEFAULT_OUTPUT_FOLDER;
+  if (folder.includes("/") || folder.includes("\\") || folder.includes("..") || folder.trim() === "") {
+    throw new Error(
+      "Invalid outputFolder: must be a simple directory name. Use --output <path> to choose any folder."
+    );
+  }
+  return path4.resolve(base, folder);
+}
+function validateOptions(raw, cwd = process.cwd()) {
+  const settings = validateEncodeSettings(raw);
+  const concurrency = raw.concurrency ?? defaultConcurrency();
+  if (typeof concurrency !== "number" || !Number.isInteger(concurrency) || concurrency < 1 || concurrency > 32) {
+    throw new Error("Invalid concurrency: must be an integer between 1 and 32");
+  }
+  let maxSize;
+  if (raw.maxSize !== void 0) {
+    maxSize = parseSize(raw.maxSize);
+  }
+  return {
+    ...settings,
+    output: resolveOutputDir(raw, cwd),
+    concurrency,
+    exclude: raw.exclude ?? [],
+    dryRun: raw.dryRun ?? false,
+    verbose: raw.verbose ?? false,
+    json: raw.json ?? false,
+    maxSize
+  };
+}
+
+// src/pipeline/plan.ts
+import fs6 from "fs/promises";
+import path6 from "path";
+
+// src/pipeline/discover.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+async function* discoverFiles(dirPath, exclude = []) {
+  const entries = await fs5.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+    if (entry.isSymbolicLink()) continue;
+    const fullPath = path5.resolve(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      if (exclude.includes(entry.name) || entry.name === DEFAULT_OUTPUT_FOLDER) continue;
+      try {
+        yield* discoverFiles(fullPath, exclude);
+      } catch {
+      }
+    } else if (entry.isFile()) {
+      yield fullPath;
+    }
+  }
+}
+
+// src/pipeline/plan.ts
+var PlanError = class extends Error {
+};
+async function scanInputs(inputs, exclude = []) {
+  if (inputs.length === 0) throw new PlanError("No input path given");
+  const candidates = [];
+  const dirs = [];
+  for (const input of inputs) {
+    const stat = await fs6.stat(input).catch(() => null);
+    if (!stat) throw new PlanError(`Path not found: ${input}`);
+    if (stat.isDirectory()) {
+      dirs.push(input);
+      for await (const file of discoverFiles(input, exclude)) candidates.push(file);
+    } else {
+      dirs.push(path6.dirname(input));
+      candidates.push(input);
+    }
+  }
+  const unique = [...new Set(candidates)];
+  const formats = await processPool(unique, detectFormat, 32);
+  const images = unique.map((file, i) => ({ file, detectedFormat: formats[i] })).filter((img) => img.detectedFormat !== null).sort((a, b) => a.file.localeCompare(b.file));
+  return { inputs, sourceRoot: commonDir(dirs), images };
+}
+function assignOutputs(scan, output, format) {
+  if (samePath(output, scan.sourceRoot) || scan.inputs.some((i) => samePath(i, output))) {
+    throw new PlanError(
+      "The output folder is the same as the source folder \u2014 that would overwrite your originals. Choose a different output folder."
+    );
+  }
+  const jobs = [];
+  const skipped = [];
+  const taken = /* @__PURE__ */ new Set();
+  for (const { file, detectedFormat } of scan.images) {
+    if (isInside(file, output)) continue;
+    const target = format ?? defaultOutputFormat(detectedFormat);
+    const parsed = path6.parse(path6.relative(scan.sourceRoot, file));
+    const keepExt = format === void 0 && detectedFormat !== UNSUPPORTED;
+    const ext = keepExt ? parsed.ext : extensionFor(target);
+    let out = path6.join(output, parsed.dir, `${parsed.name}${ext}`);
+    if (taken.has(out.toLowerCase())) {
+      out = path6.join(
+        output,
+        parsed.dir,
+        `${parsed.name}-${parsed.ext.slice(1).toLowerCase()}${ext}`
+      );
+    }
+    if (taken.has(out.toLowerCase())) {
+      skipped.push({ file, reason: "another image already produces the same output name" });
+      continue;
+    }
+    taken.add(out.toLowerCase());
+    jobs.push({ input: file, detectedFormat, output: out });
+  }
+  return { sourceRoot: scan.sourceRoot, output, jobs, skipped };
+}
+async function planJobs({ inputs, output, format, exclude = [] }) {
+  return assignOutputs(await scanInputs(inputs, exclude), output, format);
+}
+
+// src/commands/hook.ts
+import { execFile as execFile2 } from "child_process";
+import fs7 from "fs/promises";
+import path7 from "path";
+import { promisify as promisify2 } from "util";
+import { Command } from "commander";
+var execFileAsync2 = promisify2(execFile2);
+var HOOK_MARKER = "# bulki-pre-commit-hook";
+var HOOK_END_MARKER = "# bulki-pre-commit-hook-end";
+var HOOK_SCRIPT = `#!/bin/sh
+${HOOK_MARKER}
+# Auto-optimize staged images before commit
+# Installed by: bulki hook install
+# Remove with: bulki hook uninstall
+
+STAGED=$(git diff --cached --name-only -z --diff-filter=ACM | tr '\\0' '\\n' | grep -iE '\\.(jpe?g|png|webp|gif|avif)$')
+
+if [ -z "$STAGED" ]; then
+  exit 0
+fi
+
+echo "bulki: optimizing staged images..."
+
+# Prefer a local/global install; npx on every image is slow
+if command -v bulki >/dev/null 2>&1; then
+  BULKI="bulki"
+elif [ -x ./node_modules/.bin/bulki ]; then
+  BULKI="./node_modules/.bin/bulki"
+else
+  BULKI="npx --yes @puntoycoma/bulki"
+fi
+
+tmpdir=$(mktemp -d)
+trap 'rm -rf "$tmpdir"' EXIT
+
+echo "$STAGED" | while IFS= read -r img; do
+  if [ -f "$img" ]; then
+    ext="\${img##*.}"
+    case "$(echo "$ext" | tr '[:upper:]' '[:lower:]')" in
+      jpg|jpeg) fmt="jpeg" ;;
+      png) fmt="png" ;;
+      webp) fmt="webp" ;;
+      gif) fmt="gif" ;;
+      avif) fmt="avif" ;;
+      *) continue ;;
+    esac
+    tmpfile="$tmpdir/$(basename "$img")"
+    if $BULKI pipe -f "$fmt" -q 80 < "$img" > "$tmpfile" 2>/dev/null; then
+      if [ -s "$tmpfile" ]; then
+        mv "$tmpfile" "$img"
+        git add "$img"
+      fi
+    fi
+  fi
+done
+
+echo "bulki: done"
+${HOOK_END_MARKER}
+`;
+var HookError = class extends Error {
+};
+async function installHook(cwd = process.cwd()) {
+  const hooksDir = await findHooksDir(cwd);
+  if (!hooksDir) {
+    throw new HookError("Not a git repository. Run this from inside a git project.");
+  }
+  const hookPath = path7.join(hooksDir, "pre-commit");
+  await fs7.mkdir(hooksDir, { recursive: true });
+  try {
+    const existing = await fs7.readFile(hookPath, "utf-8");
+    if (existing.includes(HOOK_MARKER)) {
+      console.log("bulki hook is already installed.");
+      return;
+    }
+    await fs7.appendFile(hookPath, `
+${HOOK_SCRIPT}`);
+    await fs7.chmod(hookPath, 493);
+    console.log("bulki hook appended to existing pre-commit hook.");
+  } catch {
+    await fs7.writeFile(hookPath, HOOK_SCRIPT, { mode: 493 });
+    console.log("bulki pre-commit hook installed.");
+  }
+  console.log("Staged images will be auto-optimized before each commit.");
+}
+async function uninstallHook(cwd = process.cwd()) {
+  const hooksDir = await findHooksDir(cwd);
+  if (!hooksDir) {
+    throw new HookError("Not a git repository.");
+  }
+  const hookPath = path7.join(hooksDir, "pre-commit");
+  try {
+    const content = await fs7.readFile(hookPath, "utf-8");
+    if (!content.includes(HOOK_MARKER)) {
+      console.log("No bulki hook found in pre-commit.");
+      return;
+    }
+    const lines = content.split("\n");
+    const markerIndex = lines.findIndex((l) => l.includes(HOOK_MARKER));
+    let endIndex = lines.findIndex((l) => l.includes(HOOK_END_MARKER));
+    if (endIndex === -1) endIndex = lines.length - 1;
+    const before = lines.slice(0, markerIndex).join("\n");
+    const after = lines.slice(endIndex + 1).join("\n");
+    const trimmed = `${before}
+${after}`.trim();
+    if (trimmed === "" || trimmed === "#!/bin/sh") {
+      await fs7.unlink(hookPath);
+      console.log("bulki pre-commit hook removed.");
+    } else {
+      await fs7.writeFile(hookPath, `${trimmed}
+`, { mode: 493 });
+      console.log("bulki section removed from pre-commit hook.");
+    }
+  } catch {
+    console.log("No pre-commit hook found.");
+  }
+}
+var hookCommand = new Command("hook").description(
+  "Manage git pre-commit hook for auto image optimization"
+);
+hookCommand.command("install").description("Install pre-commit hook to optimize images on commit").action(() => runOrExit(installHook));
+hookCommand.command("uninstall").description("Remove the bulki pre-commit hook").action(() => runOrExit(uninstallHook));
+async function runOrExit(fn) {
+  try {
+    await fn();
+  } catch (err) {
+    console.error(`error: ${err.message}`);
+    process.exit(1);
+  }
+}
+async function findHooksDir(startPath) {
+  try {
+    const { stdout } = await execFileAsync2("git", ["rev-parse", "--git-path", "hooks"], {
+      cwd: startPath
+    });
+    return path7.resolve(startPath, stdout.trim());
+  } catch {
+  }
+  let current = path7.resolve(startPath);
+  while (true) {
+    const gitPath = path7.join(current, ".git");
+    const stat = await fs7.stat(gitPath).catch(() => null);
+    if (stat?.isDirectory()) return path7.join(gitPath, "hooks");
+    const parent = path7.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+// src/commands/watch.ts
+import fs8 from "fs";
+import path9 from "path";
+import { Command as Command2 } from "commander";
+
+// src/output/results.ts
+import path8 from "path";
+function calcReduction(originalSize, newSize) {
+  return originalSize > 0 ? Math.round((1 - newSize / originalSize) * 100) : 0;
+}
+function formatFileResult(result) {
+  const filename = path8.basename(result.inputPath);
+  const original = formatBytes(result.originalSize);
+  const newSize = formatBytes(result.newSize);
+  const reduction = calcReduction(result.originalSize, result.newSize);
+  const pct = reduction < 0 ? `+${Math.abs(reduction)}%` : `${reduction}%`;
+  const note = result.keptOriginal ? " \u2014 already optimal, copied as-is" : "";
+  return `${filename} ${original} -> ${newSize} (${pct})${note}`;
+}
+function buildJsonOutput(results, errors, totalDuration, outputDir) {
+  const totalOriginal = results.reduce((sum, r) => sum + r.originalSize, 0);
+  const totalNew = results.reduce((sum, r) => sum + r.newSize, 0);
+  return {
+    ...outputDir ? { output: outputDir } : {},
+    files: results.map((r) => ({
+      input: r.inputPath,
+      output: r.outputPath,
+      originalSize: r.originalSize,
+      newSize: r.newSize,
+      reduction: calcReduction(r.originalSize, r.newSize),
+      format: r.format,
+      duration: r.duration,
+      ...r.keptOriginal ? { keptOriginal: true } : {}
+    })),
+    summary: {
+      totalFiles: results.length,
+      totalOriginalSize: totalOriginal,
+      totalNewSize: totalNew,
+      totalReduction: calcReduction(totalOriginal, totalNew),
+      duration: totalDuration,
+      errors: errors.length
+    },
+    errors
+  };
+}
+function formatSummary(results, errors, totalDuration) {
+  const totalOriginal = results.reduce((sum, r) => sum + r.originalSize, 0);
+  const totalNew = results.reduce((sum, r) => sum + r.newSize, 0);
+  const reduction = calcReduction(totalOriginal, totalNew);
+  const duration = `${(totalDuration / 1e3).toFixed(1)}s`;
+  const fileCount = results.length;
+  let summary = `${fileCount} ${fileCount === 1 ? "file" : "files"} | ${formatBytes(totalOriginal)} -> ${formatBytes(totalNew)} (${reduction}%) | ${duration}`;
+  if (errors.length > 0) {
+    summary += ` | ${errors.length} ${errors.length === 1 ? "error" : "errors"}`;
+  }
+  return summary;
+}
+
+// src/commands/watch.ts
+var SETTLE_MS = 400;
+async function startWatch(dir, opts) {
+  const root = path9.resolve(dir);
+  const stat = await fs8.promises.stat(root).catch(() => null);
+  if (!stat) throw new Error(`Path not found: ${root}`);
+  if (!stat.isDirectory()) throw new Error(`Watch path must be a folder: ${root}`);
+  if (samePath(root, opts.output)) {
+    throw new Error(
+      "The output folder is the same as the watched folder. Choose a different output folder."
+    );
+  }
+  const log = opts.log ?? console.log;
+  const logError = opts.logError ?? console.error;
+  const settings = {
+    quality: opts.quality,
+    format: opts.format,
+    resize: opts.resize
+  };
+  const timers = /* @__PURE__ */ new Map();
+  const queue = [];
+  const queued = /* @__PURE__ */ new Set();
+  let active = 0;
+  const maxActive = defaultConcurrency();
+  const pump = () => {
+    while (active < maxActive && queue.length > 0) {
+      const file = queue.shift();
+      queued.delete(file);
+      active++;
+      processFile(file).finally(() => {
+        active--;
+        pump();
+      });
+    }
+  };
+  const processFile = async (file) => {
+    const detectedFormat = await detectFormat(file);
+    if (!detectedFormat) return;
+    const rel = path9.relative(root, file);
+    const parsed = path9.parse(rel);
+    const ext = settings.format ? extensionFor(settings.format) : parsed.ext;
+    const target = settings.format ?? defaultOutputFormat(detectedFormat);
+    const output = path9.join(
+      opts.output,
+      parsed.dir,
+      `${parsed.name}${detectedFormat === "unsupported" && !settings.format ? extensionFor(target) : ext}`
+    );
+    try {
+      const result = await optimizeImage({ input: file, detectedFormat, output }, settings);
+      log(formatFileResult(result));
+    } catch (err) {
+      logError(`\u2717 ${rel}: ${friendlyError(err)}`);
+    }
+  };
+  const schedule = (file) => {
+    clearTimeout(timers.get(file));
+    timers.set(
+      file,
+      setTimeout(async () => {
+        timers.delete(file);
+        const s = await fs8.promises.stat(file).catch(() => null);
+        if (!s?.isFile() || queued.has(file)) return;
+        queue.push(file);
+        queued.add(file);
+        pump();
+      }, SETTLE_MS)
+    );
+  };
+  const watcher = fs8.watch(root, { recursive: true }, (_event, filename) => {
+    if (!filename) return;
+    const file = path9.resolve(root, filename.toString());
+    const rel = path9.relative(root, file);
+    if (isInside(file, opts.output)) return;
+    if (rel.split(path9.sep).some((part) => part.startsWith(".") || part === DEFAULT_OUTPUT_FOLDER))
+      return;
+    if (file.endsWith(".tmp")) return;
+    schedule(file);
+  });
+  watcher.on("error", (err) => logError(`Watcher error: ${err.message}`));
+  return {
+    output: opts.output,
+    close() {
+      watcher.close();
+      for (const t of timers.values()) clearTimeout(t);
+      timers.clear();
+    }
+  };
+}
+var watchCommand = new Command2("watch").description("Watch a folder and auto-optimize images as they appear").argument("<path>", "Folder to watch").option("-o, --output <dir>", "Folder where optimized images are written", DEFAULTS.output).option("-q, --quality <n>", "Output quality (1-100)", parseInteger, DEFAULTS.quality).option("-f, --format <fmt>", "Convert to jpeg, png, webp, gif or avif (default: keep format)").option("-r, --resize <width>", "Max width in px (never enlarges)", parseInteger).option("-d, --destination <dir>", "Deprecated: base folder; output goes to <dir>/bulki-output").option("--output-folder <name>", "Deprecated: subfolder name inside --destination").action(async (dirPath, opts, cmd) => {
+  try {
+    const settings = validateEncodeSettings(opts);
+    const outputFromCli = cmd.getOptionValueSource("output") === "cli";
+    const root = resolveUserPath(dirPath);
+    const output = resolveOutputDir({ ...opts, output: outputFromCli ? opts.output : void 0 });
+    const handle = await startWatch(root, { ...settings, output });
+    console.log(`Watching ${displayPath(root)} \u2192 ${displayPath(output)}`);
+    console.log("Press Ctrl+C to stop.\n");
+    process.once("SIGINT", () => {
+      handle.close();
+      console.log("\nWatch stopped.");
+      process.exit(0);
+    });
+  } catch (err) {
+    console.error(`error: ${err.message}`);
+    process.exit(1);
+  }
+});
+
+export {
+  formatBytes,
+  formatFileResult,
+  buildJsonOutput,
+  formatSummary,
+  UNSUPPORTED,
+  detectFormat,
+  encodeImage,
+  runBatch,
+  cleanPathInput,
+  resolveUserPath,
+  parsePathInput,
+  isInside,
+  samePath,
+  displayPath,
+  DEFAULT_OUTPUT_FOLDER,
+  DEFAULTS,
+  defaultConcurrency,
+  parseSize,
+  parseInteger,
+  validateEncodeSettings,
+  resolveOutputDir,
+  validateOptions,
+  PlanError,
+  scanInputs,
+  assignOutputs,
+  planJobs,
+  HookError,
+  installHook,
+  uninstallHook,
+  hookCommand,
+  startWatch,
+  watchCommand
+};
+//# sourceMappingURL=chunk-YUAKNSBH.js.map