@spark-apps/piclet 1.0.1 → 1.0.3

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import chalk12 from "chalk";
+import chalk17 from "chalk";
 
 // src/cli/index.ts
-import chalk11 from "chalk";
+import chalk16 from "chalk";
 import { Command } from "commander";
 
 // src/lib/banner.ts
@@ -36,101 +36,25 @@ ${renderLogo()}`);
   }
 }
 
-// src/cli/commands/config.ts
-import chalk from "chalk";
-
-// src/lib/config.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, join } from "path";
-import { homedir } from "os";
-var DEFAULT_CONFIG = {
-  removeBg: {
-    fuzz: 10,
-    trim: true,
-    preserveInner: false,
-    makeSquare: false
-  },
-  rescale: {
-    defaultScale: 50,
-    makeSquare: false
-  },
-  iconpack: {
-    platforms: ["web", "android", "ios"]
-  }
-};
-function getConfigDir() {
-  return join(homedir(), ".config", "piclet");
-}
-function getConfigPath() {
-  return join(getConfigDir(), "config.json");
-}
-function loadConfig() {
-  const configPath = getConfigPath();
-  if (!existsSync(configPath)) {
-    return { ...DEFAULT_CONFIG };
-  }
-  try {
-    const content = readFileSync(configPath, "utf-8");
-    const loaded = JSON.parse(content);
-    return {
-      removeBg: { ...DEFAULT_CONFIG.removeBg, ...loaded.removeBg },
-      rescale: { ...DEFAULT_CONFIG.rescale, ...loaded.rescale },
-      iconpack: { ...DEFAULT_CONFIG.iconpack, ...loaded.iconpack }
-    };
-  } catch {
-    return { ...DEFAULT_CONFIG };
-  }
-}
-function resetConfig() {
-  const configPath = getConfigPath();
-  const configDir = dirname(configPath);
-  if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true });
-  }
-  writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
-}
-
-// src/cli/commands/config.ts
-function registerConfigCommand(program2) {
-  const configCmd = program2.command("config").description("Display current settings").action(() => {
-    const config7 = loadConfig();
-    console.log(chalk.white.bold("\n  PicLet Configuration"));
-    console.log(chalk.gray(`  ${getConfigPath()}
-`));
-    console.log(JSON.stringify(config7, null, 2));
-    console.log();
-  });
-  configCmd.command("reset").description("Restore defaults").action(() => {
-    resetConfig();
-    console.log(chalk.green("Configuration reset to defaults."));
-  });
-}
-
-// src/cli/commands/help.ts
-function registerHelpCommand(program2) {
-  program2.command("help").description("Show help").action(() => {
-    showHelp();
-  });
-}
-
-// src/cli/commands/iconpack.ts
-import chalk3 from "chalk";
+// src/cli/commands/border.ts
+import chalk2 from "chalk";
 
-// src/tools/iconpack.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync4 } from "fs";
-import { basename as basename2, dirname as dirname6 } from "path";
+// src/tools/border.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { tmpdir } from "os";
+import { basename as basename2, join as join3 } from "path";
 
 // src/lib/gui-server.ts
 import { spawn } from "child_process";
 import { createServer } from "http";
-import { dirname as dirname3, join as join3 } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 import { fileURLToPath } from "url";
 import express from "express";
 
 // src/lib/presets.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
 var BUILT_IN_PRESETS = [
   // ── Game Asset Stores ──
   {
@@ -258,24 +182,24 @@ var BUILT_IN_PRESETS = [
   }
 ];
 function getPresetsPath() {
-  const picletDir = join2(homedir2(), ".piclet");
-  return join2(picletDir, "presets.json");
+  const picletDir = join(homedir(), ".piclet");
+  return join(picletDir, "presets.json");
 }
 function ensurePresetsDir() {
   const presetsPath = getPresetsPath();
-  const dir = dirname2(presetsPath);
-  if (!existsSync2(dir)) {
-    mkdirSync2(dir, { recursive: true });
+  const dir = dirname(presetsPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
   }
 }
 function loadPresets() {
   const presetsPath = getPresetsPath();
   let userPresets = [];
-  if (existsSync2(presetsPath)) {
+  if (existsSync(presetsPath)) {
     try {
-      const data = readFileSync2(presetsPath, "utf-8");
-      const config7 = JSON.parse(data);
-      userPresets = config7.presets || [];
+      const data = readFileSync(presetsPath, "utf-8");
+      const config12 = JSON.parse(data);
+      userPresets = config12.presets || [];
     } catch {
     }
   }
@@ -290,20 +214,20 @@ function loadPresets() {
 }
 function savePresets(presets) {
   ensurePresetsDir();
-  const config7 = {
+  const config12 = {
     version: 1,
     presets
   };
-  writeFileSync2(getPresetsPath(), JSON.stringify(config7, null, 2));
+  writeFileSync(getPresetsPath(), JSON.stringify(config12, null, 2));
 }
 function savePreset(preset) {
   const presetsPath = getPresetsPath();
   let userPresets = [];
-  if (existsSync2(presetsPath)) {
+  if (existsSync(presetsPath)) {
     try {
-      const data = readFileSync2(presetsPath, "utf-8");
-      const config7 = JSON.parse(data);
-      userPresets = config7.presets || [];
+      const data = readFileSync(presetsPath, "utf-8");
+      const config12 = JSON.parse(data);
+      userPresets = config12.presets || [];
     } catch {
     }
   }
@@ -320,13 +244,13 @@ function deletePreset(id) {
     return { success: false, error: "Cannot delete built-in presets" };
   }
   const presetsPath = getPresetsPath();
-  if (!existsSync2(presetsPath)) {
+  if (!existsSync(presetsPath)) {
     return { success: false, error: "Preset not found" };
   }
   try {
-    const data = readFileSync2(presetsPath, "utf-8");
-    const config7 = JSON.parse(data);
-    const userPresets = config7.presets || [];
+    const data = readFileSync(presetsPath, "utf-8");
+    const config12 = JSON.parse(data);
+    const userPresets = config12.presets || [];
     const idx = userPresets.findIndex((p) => p.id === id);
     if (idx < 0) {
       return { success: false, error: "Preset not found" };
@@ -340,7 +264,7 @@ function deletePreset(id) {
 }
 
 // src/lib/gui-server.ts
-var __dirname2 = dirname3(fileURLToPath(import.meta.url));
+var __dirname2 = dirname2(fileURLToPath(import.meta.url));
 function signalReady() {
   spawn("powershell.exe", ["-WindowStyle", "Hidden", "-Command", "New-Item -Path $env:TEMP\\piclet-ready.tmp -ItemType File -Force | Out-Null"], {
     stdio: "ignore",
@@ -358,7 +282,7 @@ function openAppWindow(url) {
     stdio: "ignore",
     windowsHide: true
   }).unref();
-  setTimeout(signalReady, 500);
+  signalReady();
 }
 function startGuiServer(options) {
   return new Promise((resolve2) => {
@@ -373,12 +297,12 @@ function startGuiServer(options) {
     });
     let processResult = null;
     let server = null;
-    const guiDir = join3(__dirname2, "gui");
-    const iconsDir = join3(__dirname2, "icons");
+    const guiDir = join2(__dirname2, "gui");
+    const iconsDir = join2(__dirname2, "icons");
     app.use(express.static(guiDir));
     app.use("/icons", express.static(iconsDir));
     app.get("/favicon.ico", (_req, res) => {
-      res.sendFile(join3(iconsDir, "banana.ico"));
+      res.sendFile(join2(iconsDir, "banana.ico"));
     });
     app.get("/api/info", (_req, res) => {
       res.json({
@@ -386,9 +310,36 @@ function startGuiServer(options) {
         width: options.imageInfo.width,
         height: options.imageInfo.height,
         borderColor: options.imageInfo.borderColor,
+        frameCount: options.imageInfo.frameCount || 1,
         defaults: options.defaults
       });
     });
+    app.post("/api/frame-thumbnail", async (req, res) => {
+      if (!options.onFrameThumbnail) {
+        res.json({ success: false, error: "Frame thumbnails not supported" });
+        return;
+      }
+      try {
+        const frameIndex = req.body.frameIndex ?? 0;
+        const result = await options.onFrameThumbnail(frameIndex);
+        res.json(result);
+      } catch (err) {
+        res.json({ success: false, error: err.message });
+      }
+    });
+    app.post("/api/frame-preview", async (req, res) => {
+      if (!options.onFramePreview) {
+        res.json({ success: false, error: "Frame preview not supported" });
+        return;
+      }
+      try {
+        const { frameIndex, ...opts } = req.body;
+        const result = await options.onFramePreview(frameIndex ?? 0, opts);
+        res.json(result);
+      } catch (err) {
+        res.json({ success: false, error: err.message });
+      }
+    });
     app.post("/api/preview", async (req, res) => {
       if (!options.onPreview) {
         res.json({ success: false, error: "Preview not supported" });
@@ -485,6 +436,23 @@ function startGuiServer(options) {
       }).unref();
       res.json({ success: true });
     });
+    app.post("/api/open-folder", (_req, res) => {
+      const filePath = options.imageInfo.filePath;
+      let winPath = filePath;
+      const wslMatch = filePath.match(/^\/mnt\/([a-z])\/(.*)$/);
+      if (wslMatch) {
+        const drive = wslMatch[1].toUpperCase();
+        const rest = wslMatch[2].replace(/\//g, "\\");
+        winPath = `${drive}:\\${rest}`;
+      }
+      const dir = winPath.substring(0, winPath.lastIndexOf("\\")) || winPath.substring(0, winPath.lastIndexOf("/"));
+      spawn("powershell.exe", ["-WindowStyle", "Hidden", "-Command", `explorer.exe "${dir}"`], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+      }).unref();
+      res.json({ success: true });
+    });
     function shutdown() {
       setTimeout(() => {
         server?.close();
@@ -566,17 +534,26 @@ function clearLine() {
 
 // src/lib/magick.ts
 import { exec } from "child_process";
-import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, unlinkSync } from "fs";
-import { dirname as dirname4 } from "path";
+import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, unlinkSync } from "fs";
+import { dirname as dirname3 } from "path";
 import { promisify } from "util";
 var execAsync = promisify(exec);
-function getInputSelector(imagePath) {
+function getPreviewInputSelector(imagePath) {
   const lowerPath = imagePath.toLowerCase();
-  if (lowerPath.endsWith(".ico")) {
+  if (lowerPath.endsWith(".ico") || lowerPath.endsWith(".gif")) {
     return `"${imagePath}[0]"`;
   }
   return `"${imagePath}"`;
 }
+function isGif(imagePath) {
+  return imagePath.toLowerCase().endsWith(".gif");
+}
+function getGifOutputSuffix(outputPath) {
+  return isGif(outputPath) ? " -layers Optimize" : "";
+}
+function getCoalescePrefix(inputPath) {
+  return isGif(inputPath) ? "-coalesce " : "";
+}
 async function checkImageMagick() {
   try {
     await execAsync("command -v convert");
@@ -587,7 +564,7 @@ async function checkImageMagick() {
 }
 async function getDimensions(imagePath) {
   try {
-    const input = getInputSelector(imagePath);
+    const input = getPreviewInputSelector(imagePath);
     const { stdout } = await execAsync(
       `convert ${input} -ping -format "%w %h" info:`
     );
@@ -600,7 +577,7 @@ async function getDimensions(imagePath) {
 }
 async function getBorderColor(imagePath) {
   try {
-    const input = getInputSelector(imagePath);
+    const input = getPreviewInputSelector(imagePath);
     const { stdout } = await execAsync(
       `convert ${input} -format "%[pixel:u.p{0,0}]" info:`
     );
@@ -611,14 +588,15 @@ async function getBorderColor(imagePath) {
 }
 async function trim(inputPath, outputPath) {
   try {
-    const input = getInputSelector(inputPath);
-    await execAsync(`convert ${input} -trim +repage "${outputPath}"`);
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
+    await execAsync(`convert "${inputPath}" ${coalesce}-trim +repage${gifSuffix} "${outputPath}"`);
     return true;
   } catch {
     return false;
   }
 }
-async function squarify2(inputPath, outputPath) {
+async function squarify(inputPath, outputPath) {
   const dims = await getDimensions(inputPath);
   if (!dims) return false;
   const [width, height] = dims;
@@ -629,10 +607,11 @@ async function squarify2(inputPath, outputPath) {
     return true;
   }
   const size = Math.max(width, height);
-  const input = getInputSelector(inputPath);
+  const coalesce = getCoalescePrefix(inputPath);
+  const gifSuffix = getGifOutputSuffix(outputPath);
   try {
     await execAsync(
-      `convert ${input} -background none -gravity center -extent ${size}x${size} "${outputPath}"`
+      `convert "${inputPath}" ${coalesce}-background none -gravity center -extent ${size}x${size}${gifSuffix} "${outputPath}"`
     );
     return true;
   } catch {
@@ -651,8 +630,10 @@ async function scaleToSize(inputPath, outputPath, size) {
 }
 async function scaleWithPadding(inputPath, outputPath, width, height) {
   try {
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
     await execAsync(
-      `convert "${inputPath}" -resize ${width}x${height} -background none -gravity center -extent ${width}x${height} "${outputPath}"`
+      `convert "${inputPath}" ${coalesce}-resize ${width}x${height} -background none -gravity center -extent ${width}x${height}${gifSuffix} "${outputPath}"`
     );
     return true;
   } catch {
@@ -661,8 +642,10 @@ async function scaleWithPadding(inputPath, outputPath, width, height) {
 }
 async function resize(inputPath, outputPath, width, height) {
   try {
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
     await execAsync(
-      `convert "${inputPath}" -resize ${width}x${height}! "${outputPath}"`
+      `convert "${inputPath}" ${coalesce}-resize ${width}x${height}!${gifSuffix} "${outputPath}"`
     );
     return true;
   } catch {
@@ -671,8 +654,10 @@ async function resize(inputPath, outputPath, width, height) {
 }
 async function scaleFillCrop(inputPath, outputPath, width, height) {
   try {
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
     await execAsync(
-      `convert "${inputPath}" -resize ${width}x${height}^ -background none -gravity center -extent ${width}x${height} "${outputPath}"`
+      `convert "${inputPath}" ${coalesce}-resize ${width}x${height}^ -background none -gravity center -extent ${width}x${height}${gifSuffix} "${outputPath}"`
     );
     return true;
   } catch {
@@ -681,9 +666,10 @@ async function scaleFillCrop(inputPath, outputPath, width, height) {
 }
 async function removeBackground(inputPath, outputPath, color, fuzz) {
   try {
-    const input = getInputSelector(inputPath);
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
     await execAsync(
-      `convert ${input} -fuzz ${fuzz}% -transparent "${color}" "${outputPath}"`
+      `convert "${inputPath}" ${coalesce}-fuzz ${fuzz}% -transparent "${color}"${gifSuffix} "${outputPath}"`
     );
     return true;
   } catch {
@@ -692,9 +678,10 @@ async function removeBackground(inputPath, outputPath, color, fuzz) {
 }
 async function removeBackgroundBorderOnly(inputPath, outputPath, color, fuzz) {
   try {
-    const input = getInputSelector(inputPath);
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
     await execAsync(
-      `convert ${input} -bordercolor "${color}" -border 1x1 -fill none -fuzz ${fuzz}% -draw "matte 0,0 floodfill" -shave 1x1 "${outputPath}"`
+      `convert "${inputPath}" ${coalesce}-bordercolor "${color}" -border 1x1 -fill none -fuzz ${fuzz}% -draw "matte 0,0 floodfill" -shave 1x1${gifSuffix} "${outputPath}"`
     );
     return true;
   } catch {
@@ -721,19 +708,194 @@ async function createIcoFromMultiple(pngPaths, outputPath) {
     return false;
   }
 }
+function ensureDir(filePath) {
+  const dir = dirname3(filePath);
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+}
 function cleanup(...files) {
   for (const file of files) {
     try {
-      if (existsSync3(file)) {
+      if (existsSync2(file)) {
         unlinkSync(file);
       }
     } catch {
     }
   }
 }
+async function extractFirstFrame(inputPath, outputPath, frameIndex = 0) {
+  const lowerPath = inputPath.toLowerCase();
+  if (!lowerPath.endsWith(".gif") && !lowerPath.endsWith(".ico")) {
+    try {
+      copyFileSync(inputPath, outputPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  try {
+    if (lowerPath.endsWith(".gif")) {
+      await execAsync(`convert "${inputPath}" -coalesce miff:- | convert "miff:-[${frameIndex}]" "${outputPath}"`);
+    } else {
+      await execAsync(`convert "${inputPath}[${frameIndex}]" "${outputPath}"`);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isMultiFrame(imagePath) {
+  const lowerPath = imagePath.toLowerCase();
+  return lowerPath.endsWith(".gif") || lowerPath.endsWith(".ico");
+}
+async function getFrameCount(imagePath) {
+  try {
+    const { stdout } = await execAsync(
+      `identify -format "%n\\n" "${imagePath}" | head -1`
+    );
+    const count = parseInt(stdout.trim(), 10);
+    return Number.isNaN(count) ? 1 : count;
+  } catch {
+    return 1;
+  }
+}
+async function extractAllFrames(inputPath, outputDir, baseName) {
+  try {
+    ensureDir(`${outputDir}/dummy`);
+    await execAsync(
+      `convert "${inputPath}" -coalesce "${outputDir}/${baseName}-%04d.png"`
+    );
+    const { stdout } = await execAsync(`ls -1 "${outputDir}/${baseName}"-*.png 2>/dev/null || true`);
+    const files = stdout.trim().split("\n").filter((f) => f.length > 0);
+    return files;
+  } catch {
+    return [];
+  }
+}
+async function flipHorizontal(inputPath, outputPath) {
+  try {
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
+    await execAsync(
+      `convert "${inputPath}" ${coalesce}-flop${gifSuffix} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function flipVertical(inputPath, outputPath) {
+  try {
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
+    await execAsync(
+      `convert "${inputPath}" ${coalesce}-flip${gifSuffix} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function rotate(inputPath, outputPath, degrees) {
+  try {
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
+    await execAsync(
+      `convert "${inputPath}" ${coalesce}-rotate ${degrees} -background none${gifSuffix} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function filterGrayscale(inputPath, outputPath) {
+  try {
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
+    await execAsync(
+      `convert "${inputPath}" ${coalesce}-colorspace Gray${gifSuffix} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function filterSepia(inputPath, outputPath, intensity = 80) {
+  try {
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
+    await execAsync(
+      `convert "${inputPath}" ${coalesce}-sepia-tone ${intensity}%${gifSuffix} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function filterInvert(inputPath, outputPath) {
+  try {
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
+    await execAsync(
+      `convert "${inputPath}" ${coalesce}-negate${gifSuffix} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function filterVintage(inputPath, outputPath) {
+  try {
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
+    await execAsync(
+      `convert "${inputPath}" ${coalesce}-modulate 100,70,100 -fill "#704214" -colorize 15%${gifSuffix} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function filterVivid(inputPath, outputPath) {
+  try {
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
+    await execAsync(
+      `convert "${inputPath}" ${coalesce}-modulate 100,130,100${gifSuffix} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function addBorder(inputPath, outputPath, width, color) {
+  try {
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
+    await execAsync(
+      `convert "${inputPath}" ${coalesce}-bordercolor "${color}" -border ${width}${gifSuffix} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function replaceColor(inputPath, outputPath, fromColor, toColor, fuzz) {
+  try {
+    const coalesce = getCoalescePrefix(inputPath);
+    const gifSuffix = getGifOutputSuffix(outputPath);
+    await execAsync(
+      `convert "${inputPath}" ${coalesce}-fuzz ${fuzz}% -fill "${toColor}" -opaque "${fromColor}"${gifSuffix} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/lib/paths.ts
-import { basename, dirname as dirname5, extname, resolve } from "path";
+import { basename, dirname as dirname4, extname, resolve } from "path";
 function windowsToWsl(winPath) {
   if (winPath.startsWith("/mnt/")) {
     return winPath;
@@ -762,7 +924,7 @@ function normalizePath(inputPath) {
   return resolve(inputPath);
 }
 function getFileInfo(filePath) {
-  const dir = dirname5(filePath);
+  const dir = dirname4(filePath);
   const base = basename(filePath);
   const ext = extname(filePath);
   const name = base.slice(0, -ext.length);
@@ -798,6 +960,16 @@ function getOverride(message) {
   }
   return void 0;
 }
+async function text(message, defaultValue) {
+  if (useDefaults) return defaultValue ?? "";
+  const response = await prompts({
+    type: "text",
+    name: "value",
+    message,
+    initial: defaultValue
+  });
+  return response.value ?? defaultValue ?? "";
+}
 async function number(message, defaultValue, min, max) {
   const override = getOverride(message);
   if (override !== void 0) return Number(override);
@@ -865,38 +1037,557 @@ async function pauseOnError(message = "Press Enter to close...") {
   });
 }
 
-// src/tools/iconpack.ts
-var WEB_ICONS = [
-  { filename: "favicon-16x16.png", size: 16 },
-  { filename: "favicon-32x32.png", size: 32 },
-  { filename: "favicon-48x48.png", size: 48 },
-  { filename: "apple-touch-icon.png", size: 180 },
-  { filename: "android-chrome-192x192.png", size: 192 },
-  { filename: "android-chrome-512x512.png", size: 512 },
-  { filename: "mstile-150x150.png", size: 150 }
-];
-var ANDROID_ICONS = [
-  { filename: "mipmap-mdpi/ic_launcher.png", size: 48 },
-  { filename: "mipmap-hdpi/ic_launcher.png", size: 72 },
-  { filename: "mipmap-xhdpi/ic_launcher.png", size: 96 },
-  { filename: "mipmap-xxhdpi/ic_launcher.png", size: 144 },
-  { filename: "mipmap-xxxhdpi/ic_launcher.png", size: 192 },
-  { filename: "playstore-icon.png", size: 512 }
-];
-var IOS_ICONS = [
-  // 20pt - Notifications
-  { filename: "AppIcon-20.png", size: 20 },
-  { filename: "AppIcon-20@2x.png", size: 40 },
-  { filename: "AppIcon-20@3x.png", size: 60 },
-  // 29pt - Settings
-  { filename: "AppIcon-29.png", size: 29 },
-  { filename: "AppIcon-29@2x.png", size: 58 },
-  { filename: "AppIcon-29@3x.png", size: 87 },
-  // 40pt - Spotlight
-  { filename: "AppIcon-40.png", size: 40 },
-  { filename: "AppIcon-40@2x.png", size: 80 },
-  { filename: "AppIcon-40@3x.png", size: 120 },
-  // 60pt - iPhone App
+// src/tools/border.ts
+async function processImage(input, options) {
+  const fileInfo = getFileInfo(input);
+  const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
+  const output = `${fileInfo.dirname}/${fileInfo.filename}_border${outputExt}`;
+  wip(`Adding ${options.width}px ${options.color} border...`);
+  const success2 = await addBorder(input, output, options.width, options.color);
+  if (!success2) {
+    wipDone(false, "Border failed");
+    return false;
+  }
+  wipDone(true, "Border added");
+  const finalDims = await getDimensions(output);
+  console.log("");
+  if (finalDims) {
+    console.log(`Output: ${output} (${finalDims[0]}x${finalDims[1]})`);
+  } else {
+    console.log(`Output: ${output}`);
+  }
+  return true;
+}
+async function collectOptionsCLI() {
+  console.log("");
+  console.log(`${BOLD}Border Settings:${RESET}`);
+  console.log(`  ${DIM}Width: How thick the border should be (in pixels)${RESET}`);
+  console.log(`  ${DIM}Color: Hex color (#fff), named color (white), or rgb(...)${RESET}`);
+  console.log("");
+  let width = await number("Border width (px)", 10, 1, 200);
+  if (width < 1) {
+    width = 10;
+  }
+  console.log("");
+  let color = await text("Border color", "#ffffff");
+  if (!color) {
+    color = "#ffffff";
+  }
+  return { width, color };
+}
+async function run(inputRaw) {
+  if (!await checkImageMagick()) {
+    error("ImageMagick not found. Please install it:");
+    console.log("  sudo apt update && sudo apt install imagemagick");
+    await pauseOnError();
+    return false;
+  }
+  const input = normalizePath(inputRaw);
+  if (!existsSync3(input)) {
+    error(`File not found: ${input}`);
+    await pauseOnError();
+    return false;
+  }
+  header("PicLet Border");
+  wip("Analyzing image...");
+  const dims = await getDimensions(input);
+  if (!dims) {
+    wipDone(false, "Failed to read image");
+    return false;
+  }
+  wipDone(true, `Size: ${dims[0]}x${dims[1]}`);
+  const options = await collectOptionsCLI();
+  console.log("");
+  return processImage(input, options);
+}
+async function runGUI(inputRaw) {
+  const input = normalizePath(inputRaw);
+  if (!existsSync3(input)) {
+    error(`File not found: ${input}`);
+    return false;
+  }
+  const dims = await getDimensions(input);
+  if (!dims) {
+    error("Failed to read image dimensions");
+    return false;
+  }
+  return startGuiServer({
+    htmlFile: "border.html",
+    title: "PicLet - Border",
+    imageInfo: {
+      filePath: input,
+      fileName: basename2(input),
+      width: dims[0],
+      height: dims[1],
+      borderColor: null
+    },
+    defaults: {
+      width: 10,
+      color: "#ffffff"
+    },
+    onPreview: async (opts) => {
+      const width = opts.width ?? 10;
+      const color = opts.color ?? "#ffffff";
+      return generatePreview(input, { width, color });
+    },
+    onProcess: async (opts) => {
+      const logs = [];
+      if (!await checkImageMagick()) {
+        return {
+          success: false,
+          error: "ImageMagick not found",
+          logs: [{ type: "error", message: "ImageMagick not found. Install with: sudo apt install imagemagick" }]
+        };
+      }
+      logs.push({ type: "info", message: `Processing ${basename2(input)}...` });
+      const width = opts.width ?? 10;
+      const color = opts.color ?? "#ffffff";
+      const options = { width, color };
+      const fileInfo = getFileInfo(input);
+      const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
+      const output = `${fileInfo.dirname}/${fileInfo.filename}_border${outputExt}`;
+      logs.push({ type: "info", message: `Adding ${width}px border...` });
+      const success2 = await addBorder(input, output, width, color);
+      if (success2) {
+        logs.push({ type: "success", message: "Border added" });
+        const finalDims = await getDimensions(output);
+        const sizeStr = finalDims ? ` (${finalDims[0]}x${finalDims[1]})` : "";
+        return {
+          success: true,
+          output: `${basename2(output)}${sizeStr}`,
+          logs
+        };
+      }
+      logs.push({ type: "error", message: "Border failed" });
+      return {
+        success: false,
+        error: "Processing failed",
+        logs
+      };
+    }
+  });
+}
+async function generatePreview(input, options) {
+  const tempDir = tmpdir();
+  const timestamp = Date.now();
+  const tempSource = join3(tempDir, `piclet-preview-${timestamp}-src.png`);
+  const tempOutput = join3(tempDir, `piclet-preview-${timestamp}.png`);
+  try {
+    let previewInput = input;
+    if (isMultiFrame(input)) {
+      if (!await extractFirstFrame(input, tempSource)) {
+        return { success: false, error: "Failed to extract frame" };
+      }
+      previewInput = tempSource;
+    }
+    const success2 = await addBorder(previewInput, tempOutput, options.width, options.color);
+    if (!success2) {
+      cleanup(tempSource, tempOutput);
+      return { success: false, error: "Border failed" };
+    }
+    const buffer = readFileSync2(tempOutput);
+    const base64 = buffer.toString("base64");
+    const imageData = `data:image/png;base64,${base64}`;
+    const dims = await getDimensions(tempOutput);
+    cleanup(tempSource, tempOutput);
+    return {
+      success: true,
+      imageData,
+      width: dims?.[0],
+      height: dims?.[1]
+    };
+  } catch (err) {
+    cleanup(tempSource, tempOutput);
+    return { success: false, error: err.message };
+  }
+}
+var config = {
+  id: "border",
+  name: "Add Border",
+  icon: "border.ico",
+  extensions: [".png", ".jpg", ".jpeg", ".gif", ".bmp"]
+};
+
+// src/cli/utils.ts
+import { extname as extname3 } from "path";
+import { dirname as dirname9 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import chalk from "chalk";
+
+// src/tools/extract-frames.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename3, join as join4 } from "path";
+async function run2(inputRaw) {
+  if (!await checkImageMagick()) {
+    error("ImageMagick not found. Please install it:");
+    console.log("  sudo apt update && sudo apt install imagemagick");
+    await pauseOnError();
+    return false;
+  }
+  const input = normalizePath(inputRaw);
+  if (!existsSync4(input)) {
+    error(`File not found: ${input}`);
+    await pauseOnError();
+    return false;
+  }
+  header("PicLet Extract Frames");
+  wip("Analyzing GIF...");
+  const dims = await getDimensions(input);
+  if (!dims) {
+    wipDone(false, "Failed to read image");
+    return false;
+  }
+  const frameCount = await getFrameCount(input);
+  wipDone(true, `Size: ${dims[0]}x${dims[1]}, ${frameCount} frames`);
+  if (frameCount <= 1) {
+    info("Image has only 1 frame, nothing to extract");
+    return true;
+  }
+  console.log("");
+  console.log(`${BOLD}Extract Frames:${RESET}`);
+  console.log(`  ${DIM}This will create ${frameCount} PNG files${RESET}`);
+  console.log("");
+  const proceed = await confirm(`Extract ${frameCount} frames?`, true);
+  if (!proceed) {
+    info("Cancelled");
+    return false;
+  }
+  const fileInfo = getFileInfo(input);
+  const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_frames`;
+  console.log("");
+  wip("Extracting frames...");
+  mkdirSync3(outputDir, { recursive: true });
+  const frames = await extractAllFrames(input, outputDir, "frame");
+  if (frames.length === 0) {
+    wipDone(false, "Extraction failed");
+    return false;
+  }
+  wipDone(true, `Extracted ${frames.length} frames`);
+  console.log("");
+  success(`Output: ${outputDir}/`);
+  return true;
+}
+async function runGUI2(inputRaw) {
+  const input = normalizePath(inputRaw);
+  if (!existsSync4(input)) {
+    error(`File not found: ${input}`);
+    return false;
+  }
+  const dims = await getDimensions(input);
+  if (!dims) {
+    error("Failed to read image dimensions");
+    return false;
+  }
+  const frameCount = await getFrameCount(input);
+  const fileInfo = getFileInfo(input);
+  return startGuiServer({
+    htmlFile: "extract-frames.html",
+    title: "PicLet - Extract Frames",
+    imageInfo: {
+      filePath: input,
+      fileName: basename3(input),
+      width: dims[0],
+      height: dims[1],
+      borderColor: null
+    },
+    defaults: {
+      frameCount
+    },
+    onPreview: async (opts) => {
+      const frameIndex = opts.frameIndex ?? 0;
+      return generateFramePreview(input, frameIndex);
+    },
+    onProcess: async () => {
+      const logs = [];
+      if (!await checkImageMagick()) {
+        return {
+          success: false,
+          error: "ImageMagick not found",
+          logs: [{ type: "error", message: "ImageMagick not found. Install with: sudo apt install imagemagick" }]
+        };
+      }
+      logs.push({ type: "info", message: `Extracting ${frameCount} frames...` });
+      const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_frames`;
+      mkdirSync3(outputDir, { recursive: true });
+      const frames = await extractAllFrames(input, outputDir, "frame");
+      if (frames.length > 0) {
+        logs.push({ type: "success", message: `Extracted ${frames.length} frames` });
+        return {
+          success: true,
+          output: `${frames.length} frames -> ${fileInfo.filename}_frames/`,
+          logs
+        };
+      }
+      logs.push({ type: "error", message: "Extraction failed" });
+      return { success: false, error: "Extraction failed", logs };
+    }
+  });
+}
+async function generateFramePreview(input, frameIndex) {
+  const tempDir = tmpdir2();
+  const timestamp = Date.now();
+  const tempOutput = join4(tempDir, `piclet-frame-${timestamp}.png`);
+  try {
+    if (!await extractFirstFrame(input, tempOutput, frameIndex)) {
+      return { success: false, error: "Failed to extract frame" };
+    }
+    const buffer = readFileSync3(tempOutput);
+    const base64 = buffer.toString("base64");
+    const imageData = `data:image/png;base64,${base64}`;
+    const dims = await getDimensions(tempOutput);
+    cleanup(tempOutput);
+    return {
+      success: true,
+      imageData,
+      width: dims?.[0],
+      height: dims?.[1]
+    };
+  } catch (err) {
+    cleanup(tempOutput);
+    return { success: false, error: err.message };
+  }
+}
+var config2 = {
+  id: "extract-frames",
+  name: "Extract Frames",
+  icon: "extract.ico",
+  extensions: [".gif"]
+};
+
+// src/tools/filter.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+import { basename as basename4, join as join5 } from "path";
+var FILTER_LABELS = {
+  "grayscale": "Grayscale",
+  "sepia": "Sepia",
+  "invert": "Invert",
+  "vintage": "Vintage",
+  "vivid": "Vivid"
+};
+async function applyFilter(input, output, filter) {
+  switch (filter) {
+    case "grayscale":
+      return filterGrayscale(input, output);
+    case "sepia":
+      return filterSepia(input, output);
+    case "invert":
+      return filterInvert(input, output);
+    case "vintage":
+      return filterVintage(input, output);
+    case "vivid":
+      return filterVivid(input, output);
+    default:
+      return false;
+  }
+}
+async function processImage2(input, options) {
+  const fileInfo = getFileInfo(input);
+  const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
+  const output = `${fileInfo.dirname}/${fileInfo.filename}_${options.filter}${outputExt}`;
+  wip(`Applying ${FILTER_LABELS[options.filter]} filter...`);
+  const success2 = await applyFilter(input, output, options.filter);
+  if (!success2) {
+    wipDone(false, "Filter failed");
+    return false;
+  }
+  wipDone(true, FILTER_LABELS[options.filter]);
+  const finalDims = await getDimensions(output);
+  console.log("");
+  if (finalDims) {
+    console.log(`Output: ${output} (${finalDims[0]}x${finalDims[1]})`);
+  } else {
+    console.log(`Output: ${output}`);
+  }
+  return true;
+}
+async function collectOptionsCLI2() {
+  console.log("");
+  console.log(`${BOLD}Filter Options:${RESET}`);
+  console.log(`  ${DIM}1. Grayscale - Black and white${RESET}`);
+  console.log(`  ${DIM}2. Sepia - Warm brownish tint${RESET}`);
+  console.log(`  ${DIM}3. Invert - Negative colors${RESET}`);
+  console.log(`  ${DIM}4. Vintage - Desaturated warm tone${RESET}`);
+  console.log(`  ${DIM}5. Vivid - Increased saturation${RESET}`);
+  console.log("");
+  const filter = await select(
+    "Select filter",
+    [
+      { value: "grayscale", title: "Grayscale" },
+      { value: "sepia", title: "Sepia" },
+      { value: "invert", title: "Invert" },
+      { value: "vintage", title: "Vintage" },
+      { value: "vivid", title: "Vivid" }
+    ],
+    "grayscale"
+  );
+  return { filter: filter ?? "grayscale" };
+}
+async function run3(inputRaw) {
+  if (!await checkImageMagick()) {
+    error("ImageMagick not found. Please install it:");
+    console.log("  sudo apt update && sudo apt install imagemagick");
+    await pauseOnError();
+    return false;
+  }
+  const input = normalizePath(inputRaw);
+  if (!existsSync5(input)) {
+    error(`File not found: ${input}`);
+    await pauseOnError();
+    return false;
+  }
+  header("PicLet Filter");
+  wip("Analyzing image...");
+  const dims = await getDimensions(input);
+  if (!dims) {
+    wipDone(false, "Failed to read image");
+    return false;
+  }
+  wipDone(true, `Size: ${dims[0]}x${dims[1]}`);
+  const options = await collectOptionsCLI2();
+  console.log("");
+  return processImage2(input, options);
+}
+async function runGUI3(inputRaw) {
+  const input = normalizePath(inputRaw);
+  if (!existsSync5(input)) {
+    error(`File not found: ${input}`);
+    return false;
+  }
+  const dims = await getDimensions(input);
+  if (!dims) {
+    error("Failed to read image dimensions");
+    return false;
+  }
+  return startGuiServer({
+    htmlFile: "filter.html",
+    title: "PicLet - Filter",
+    imageInfo: {
+      filePath: input,
+      fileName: basename4(input),
+      width: dims[0],
+      height: dims[1],
+      borderColor: null
+    },
+    defaults: {
+      filter: "grayscale"
+    },
+    onPreview: async (opts) => {
+      const filter = opts.filter ?? "grayscale";
+      return generatePreview2(input, { filter });
+    },
+    onProcess: async (opts) => {
+      const logs = [];
+      if (!await checkImageMagick()) {
+        return {
+          success: false,
+          error: "ImageMagick not found",
+          logs: [{ type: "error", message: "ImageMagick not found. Install with: sudo apt install imagemagick" }]
+        };
+      }
+      logs.push({ type: "info", message: `Processing ${basename4(input)}...` });
+      const filter = opts.filter ?? "grayscale";
+      const options = { filter };
+      const fileInfo = getFileInfo(input);
+      const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
+      const output = `${fileInfo.dirname}/${fileInfo.filename}_${filter}${outputExt}`;
+      logs.push({ type: "info", message: `Applying ${FILTER_LABELS[filter]} filter...` });
+      const success2 = await applyFilter(input, output, filter);
+      if (success2) {
+        logs.push({ type: "success", message: "Filter applied" });
+        const finalDims = await getDimensions(output);
+        const sizeStr = finalDims ? ` (${finalDims[0]}x${finalDims[1]})` : "";
+        return {
+          success: true,
+          output: `${basename4(output)}${sizeStr}`,
+          logs
+        };
+      }
+      logs.push({ type: "error", message: "Filter failed" });
+      return {
+        success: false,
+        error: "Processing failed",
+        logs
+      };
+    }
+  });
+}
+async function generatePreview2(input, options) {
+  const tempDir = tmpdir3();
+  const timestamp = Date.now();
+  const tempSource = join5(tempDir, `piclet-preview-${timestamp}-src.png`);
+  const tempOutput = join5(tempDir, `piclet-preview-${timestamp}.png`);
+  try {
+    let previewInput = input;
+    if (isMultiFrame(input)) {
+      if (!await extractFirstFrame(input, tempSource)) {
+        return { success: false, error: "Failed to extract frame" };
+      }
+      previewInput = tempSource;
+    }
+    const success2 = await applyFilter(previewInput, tempOutput, options.filter);
+    if (!success2) {
+      cleanup(tempSource, tempOutput);
+      return { success: false, error: "Filter failed" };
+    }
+    const buffer = readFileSync4(tempOutput);
+    const base64 = buffer.toString("base64");
+    const imageData = `data:image/png;base64,${base64}`;
+    const dims = await getDimensions(tempOutput);
+    cleanup(tempSource, tempOutput);
+    return {
+      success: true,
+      imageData,
+      width: dims?.[0],
+      height: dims?.[1]
+    };
+  } catch (err) {
+    cleanup(tempSource, tempOutput);
+    return { success: false, error: err.message };
+  }
+}
+var config3 = {
+  id: "filter",
+  name: "Filter",
+  icon: "filter.ico",
+  extensions: [".png", ".jpg", ".jpeg", ".gif", ".bmp"]
+};
+
+// src/tools/iconpack.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { basename as basename5, dirname as dirname5 } from "path";
+var WEB_ICONS = [
+  { filename: "favicon-16x16.png", size: 16 },
+  { filename: "favicon-32x32.png", size: 32 },
+  { filename: "favicon-48x48.png", size: 48 },
+  { filename: "apple-touch-icon.png", size: 180 },
+  { filename: "android-chrome-192x192.png", size: 192 },
+  { filename: "android-chrome-512x512.png", size: 512 },
+  { filename: "mstile-150x150.png", size: 150 }
+];
+var ANDROID_ICONS = [
+  { filename: "mipmap-mdpi/ic_launcher.png", size: 48 },
+  { filename: "mipmap-hdpi/ic_launcher.png", size: 72 },
+  { filename: "mipmap-xhdpi/ic_launcher.png", size: 96 },
+  { filename: "mipmap-xxhdpi/ic_launcher.png", size: 144 },
+  { filename: "mipmap-xxxhdpi/ic_launcher.png", size: 192 },
+  { filename: "playstore-icon.png", size: 512 }
+];
+var IOS_ICONS = [
+  // 20pt - Notifications
+  { filename: "AppIcon-20.png", size: 20 },
+  { filename: "AppIcon-20@2x.png", size: 40 },
+  { filename: "AppIcon-20@3x.png", size: 60 },
+  // 29pt - Settings
+  { filename: "AppIcon-29.png", size: 29 },
+  { filename: "AppIcon-29@2x.png", size: 58 },
+  { filename: "AppIcon-29@3x.png", size: 87 },
+  // 40pt - Spotlight
+  { filename: "AppIcon-40.png", size: 40 },
+  { filename: "AppIcon-40@2x.png", size: 80 },
+  { filename: "AppIcon-40@3x.png", size: 120 },
+  // 60pt - iPhone App
   { filename: "AppIcon-60@2x.png", size: 120 },
   { filename: "AppIcon-60@3x.png", size: 180 },
   // 76pt - iPad App
@@ -914,8 +1605,8 @@ async function generateIcons(outputDir, sourceImg, icons) {
   for (const icon of icons) {
     current++;
     const outputPath = `${outputDir}/${icon.filename}`;
-    const subdir = dirname6(outputPath);
-    if (!existsSync4(subdir)) {
+    const subdir = dirname5(outputPath);
+    if (!existsSync6(subdir)) {
       mkdirSync4(subdir, { recursive: true });
     }
     clearLine();
@@ -953,7 +1644,7 @@ async function generateFavicon(outputDir, sourceImg) {
   wipDone(false, "favicon.ico failed");
   return false;
 }
-async function run(inputRaw) {
+async function run4(inputRaw) {
   if (!await checkImageMagick()) {
     error("ImageMagick not found. Please install it:");
     console.log("  sudo apt update && sudo apt install imagemagick");
@@ -961,7 +1652,7 @@ async function run(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync4(input)) {
+  if (!existsSync6(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -1009,7 +1700,7 @@ async function run(inputRaw) {
   wip("Preparing source image...");
   const tempSource = `${outputDir}/.source_1024.png`;
   const tempSquare = `${outputDir}/.temp_square.png`;
-  if (!await squarify2(input, tempSquare)) {
+  if (!await squarify(input, tempSquare)) {
     wipDone(false, "Failed to prepare source");
     return false;
   }
@@ -1066,9 +1757,9 @@ async function run(inputRaw) {
   }
   return totalFailed === 0;
 }
-async function runGUI(inputRaw) {
+async function runGUI4(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync4(input)) {
+  if (!existsSync6(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -1083,7 +1774,7 @@ async function runGUI(inputRaw) {
     title: "PicLet - Icon Pack",
     imageInfo: {
       filePath: input,
-      fileName: basename2(input),
+      fileName: basename5(input),
       width: dims[0],
       height: dims[1],
       borderColor: null
@@ -1118,7 +1809,7 @@ async function runGUI(inputRaw) {
       logs.push({ type: "info", message: "Preparing source image..." });
       const tempSource = `${outputDir}/.source_1024.png`;
       const tempSquare = `${outputDir}/.temp_square.png`;
-      if (!await squarify2(input, tempSquare)) {
+      if (!await squarify(input, tempSquare)) {
         return { success: false, error: "Failed to prepare source", logs };
       }
       if (!await scaleToSize(tempSquare, tempSource, 1024)) {
@@ -1172,8 +1863,8 @@ async function generateIconsSilent(outputDir, sourceImg, icons, _logs) {
   let failed = 0;
   for (const icon of icons) {
     const outputPath = `${outputDir}/${icon.filename}`;
-    const subdir = dirname6(outputPath);
-    if (!existsSync4(subdir)) {
+    const subdir = dirname5(outputPath);
+    if (!existsSync6(subdir)) {
       mkdirSync4(subdir, { recursive: true });
     }
     if (!await scaleToSize(sourceImg, outputPath, icon.size)) {
@@ -1196,24 +1887,18 @@ async function generateFaviconSilent(outputDir, sourceImg) {
   cleanup(temp16, temp32, temp48);
   return result;
 }
-var config = {
+var config4 = {
   id: "iconpack",
   name: "Icon Pack",
   icon: "iconpack.ico",
-  extensions: [".png", ".jpg", ".jpeg"]
+  extensions: [".png", ".jpg", ".jpeg", ".gif"]
 };
 
-// src/cli/utils.ts
-import { extname as extname3 } from "path";
-import { dirname as dirname9 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import chalk2 from "chalk";
-
 // src/tools/makeicon.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
-import { tmpdir } from "os";
-import { basename as basename3, join as join4 } from "path";
-async function run2(inputRaw) {
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { tmpdir as tmpdir4 } from "os";
+import { basename as basename6, join as join6 } from "path";
+async function run5(inputRaw) {
   if (!await checkImageMagick()) {
     error("ImageMagick not found. Please install it:");
     console.log("  sudo apt update && sudo apt install imagemagick");
@@ -1221,7 +1906,7 @@ async function run2(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync5(input)) {
+  if (!existsSync7(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -1247,7 +1932,7 @@ async function run2(inputRaw) {
   }
   wipDone(true, "Trimmed");
   wip("Making square...");
-  if (!await squarify2(tempTrimmed, tempSquare)) {
+  if (!await squarify(tempTrimmed, tempSquare)) {
     wipDone(false, "Square padding failed");
     cleanup(tempTrimmed, tempSquare);
     return false;
@@ -1291,7 +1976,7 @@ async function processForIcon(input, output, options, logs) {
   }
   if (options.makeSquare) {
     logs?.push({ type: "info", message: "Making square..." });
-    if (!await squarify2(currentInput, tempSquare)) {
+    if (!await squarify(currentInput, tempSquare)) {
       cleanup(tempTrimmed, tempSquare);
       return false;
     }
@@ -1316,12 +2001,12 @@ async function processForIcon(input, output, options, logs) {
   logs?.push({ type: "success", message: "Icon created" });
   return true;
 }
-async function generatePreview(input, options) {
-  const tempDir = tmpdir();
+async function generatePreview3(input, options) {
+  const tempDir = tmpdir4();
   const timestamp = Date.now();
-  const tempTrimmed = join4(tempDir, `piclet-preview-trimmed-${timestamp}.png`);
-  const tempSquare = join4(tempDir, `piclet-preview-square-${timestamp}.png`);
-  const tempOutput = join4(tempDir, `piclet-preview-${timestamp}.png`);
+  const tempTrimmed = join6(tempDir, `piclet-preview-trimmed-${timestamp}.png`);
+  const tempSquare = join6(tempDir, `piclet-preview-square-${timestamp}.png`);
+  const tempOutput = join6(tempDir, `piclet-preview-${timestamp}.png`);
   try {
     let currentInput = input;
     if (options.trim) {
@@ -1332,7 +2017,7 @@ async function generatePreview(input, options) {
       currentInput = tempTrimmed;
     }
     if (options.makeSquare) {
-      if (!await squarify2(currentInput, tempSquare)) {
+      if (!await squarify(currentInput, tempSquare)) {
         cleanup(tempTrimmed, tempSquare);
         return { success: false, error: "Square failed" };
       }
@@ -1345,7 +2030,7 @@ async function generatePreview(input, options) {
     }
     if (currentInput === tempSquare) cleanup(tempSquare);
     else if (currentInput === tempTrimmed) cleanup(tempTrimmed);
-    const buffer = readFileSync3(tempOutput);
+    const buffer = readFileSync5(tempOutput);
     const base64 = buffer.toString("base64");
     const imageData = `data:image/png;base64,${base64}`;
     const dims = await getDimensions(tempOutput);
@@ -1361,9 +2046,9 @@ async function generatePreview(input, options) {
     return { success: false, error: err.message };
   }
 }
-async function runGUI2(inputRaw) {
+async function runGUI5(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync5(input)) {
+  if (!existsSync7(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -1378,7 +2063,7 @@ async function runGUI2(inputRaw) {
     title: "PicLet - Make Icon",
     imageInfo: {
       filePath: input,
-      fileName: basename3(input),
+      fileName: basename6(input),
       width: dims[0],
       height: dims[1],
       borderColor: null
@@ -1392,7 +2077,7 @@ async function runGUI2(inputRaw) {
         trim: opts.trim ?? true,
         makeSquare: opts.makeSquare ?? true
       };
-      return generatePreview(input, options);
+      return generatePreview3(input, options);
     },
     onProcess: async (opts) => {
       const logs = [];
@@ -1420,40 +2105,46 @@ async function runGUI2(inputRaw) {
     }
   });
 }
-var config2 = {
+var config5 = {
   id: "makeicon",
   name: "Make Icon",
   icon: "makeicon.ico",
-  extensions: [".png"]
+  extensions: [".png", ".gif"]
 };
 
 // src/tools/piclet-main.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync4, renameSync, writeFileSync as writeFileSync3 } from "fs";
-import { tmpdir as tmpdir2 } from "os";
-import { basename as basename4, dirname as dirname7, extname as extname2, join as join5 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync6, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir as tmpdir5 } from "os";
+import { basename as basename7, dirname as dirname6, extname as extname2, join as join7 } from "path";
 var TOOL_ORDER = ["removebg", "scale", "icons", "storepack"];
 async function generateCombinedPreview(input, borderColor, opts) {
-  const tempDir = tmpdir2();
+  const tempDir = tmpdir5();
   const ts = Date.now();
   const temps = [];
   const makeTempPath = (suffix) => {
-    const p = join5(tempDir, `piclet-${ts}-${suffix}.png`);
+    const p = join7(tempDir, `piclet-${ts}-${suffix}.png`);
     temps.push(p);
     return p;
   };
   try {
     let current = input;
+    if (isMultiFrame(input)) {
+      const frameTemp = makeTempPath("frame");
+      if (await extractFirstFrame(input, frameTemp)) {
+        current = frameTemp;
+      }
+    }
     if (opts.original || opts.tools.length === 0) {
-      const dims2 = await getDimensions(input);
-      let previewPath2 = input;
+      const dims2 = await getDimensions(current);
+      let previewPath2 = current;
       if (dims2 && (dims2[0] > 512 || dims2[1] > 512)) {
         const scaled = makeTempPath("orig-preview");
         const targetSize = Math.min(512, Math.max(dims2[0], dims2[1]));
-        if (await scaleToSize(input, scaled, targetSize)) {
+        if (await scaleToSize(current, scaled, targetSize)) {
           previewPath2 = scaled;
         }
       }
-      const buffer2 = readFileSync4(previewPath2);
+      const buffer2 = readFileSync6(previewPath2);
       const finalDims2 = await getDimensions(previewPath2);
       cleanup(...temps);
       return {
@@ -1519,7 +2210,7 @@ async function generateCombinedPreview(input, borderColor, opts) {
           }
           if (icOpts.makeSquare) {
             const sqOut = makeTempPath("ic-sq");
-            if (await squarify2(current, sqOut)) {
+            if (await squarify(current, sqOut)) {
               current = sqOut;
             }
           }
@@ -1536,7 +2227,7 @@ async function generateCombinedPreview(input, borderColor, opts) {
         previewPath = scaled;
       }
     }
-    const buffer = readFileSync4(previewPath);
+    const buffer = readFileSync6(previewPath);
     const finalDims = await getDimensions(previewPath);
     cleanup(...temps);
     return {
@@ -1554,8 +2245,9 @@ async function processCombined(input, borderColor, opts, logs) {
   const fileInfo = getFileInfo(input);
   const outputs = [];
   const temps = [];
+  const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
   const makeTempPath = (suffix) => {
-    const p = `${fileInfo.dirname}/${fileInfo.filename}_${suffix}.png`;
+    const p = `${fileInfo.dirname}/${fileInfo.filename}_${suffix}${outputExt}`;
     temps.push(p);
     return p;
   };
@@ -1598,10 +2290,10 @@ async function processCombined(input, borderColor, opts, logs) {
           current = out;
         }
         if (activeTools.indexOf(tool) === activeTools.length - 1) {
-          const finalOut = `${fileInfo.dirname}/${fileInfo.filename}_nobg.png`;
+          const finalOut = `${fileInfo.dirname}/${fileInfo.filename}_nobg${outputExt}`;
           renameSync(current, finalOut);
           temps.splice(temps.indexOf(current), 1);
-          outputs.push(basename4(finalOut));
+          outputs.push(basename7(finalOut));
         }
         break;
       }
@@ -1629,10 +2321,10 @@ async function processCombined(input, borderColor, opts, logs) {
         }
         current = out;
         if (activeTools.indexOf(tool) === activeTools.length - 1) {
-          const finalOut = `${fileInfo.dirname}/${fileInfo.filename}_scaled${fileInfo.extension}`;
+          const finalOut = `${fileInfo.dirname}/${fileInfo.filename}_scaled${outputExt}`;
           renameSync(current, finalOut);
           temps.splice(temps.indexOf(current), 1);
-          outputs.push(basename4(finalOut));
+          outputs.push(basename7(finalOut));
         }
         break;
       }
@@ -1655,7 +2347,7 @@ async function processCombined(input, borderColor, opts, logs) {
         if (icOpts.makeSquare) {
           logs.push({ type: "info", message: "Making square..." });
           const sqOut = makeTempPath("ic-sq");
-          if (await squarify2(iconSource, sqOut)) {
+          if (await squarify(iconSource, sqOut)) {
             if (iconSource !== current && iconSource !== input) cleanup(iconSource);
             iconSource = sqOut;
             logs.push({ type: "success", message: "Made square" });
@@ -1675,7 +2367,7 @@ async function processCombined(input, borderColor, opts, logs) {
           const icoOut = `${fileInfo.dirname}/${fileInfo.filename}.ico`;
           if (await createIco(srcTemp, icoOut)) {
             logs.push({ type: "success", message: "ICO: 6 sizes (256, 128, 64, 48, 32, 16)" });
-            outputs.push(basename4(icoOut));
+            outputs.push(basename7(icoOut));
             totalCount += 6;
           } else {
             logs.push({ type: "warn", message: "ICO creation failed" });
@@ -1723,7 +2415,7 @@ async function processCombined(input, borderColor, opts, logs) {
             ];
             for (const i of androidIcons) {
               const p = `${androidDir}/${i.name}`;
-              mkdirSync5(dirname7(p), { recursive: true });
+              mkdirSync5(dirname6(p), { recursive: true });
               await scaleToSize(srcTemp, p, i.size);
               totalCount++;
             }
@@ -1759,7 +2451,7 @@ async function processCombined(input, borderColor, opts, logs) {
         let count = 0;
         for (const dim of spOpts.dimensions) {
           const filename = dim.filename || `${dim.width}x${dim.height}.png`;
-          const out = join5(outputDir, filename);
+          const out = join7(outputDir, filename);
           let success2 = false;
           switch (spOpts.scaleMode) {
             case "fill":
@@ -1782,9 +2474,9 @@ async function processCombined(input, borderColor, opts, logs) {
   cleanup(...temps);
   return outputs;
 }
-async function runGUI3(inputRaw) {
+async function runGUI6(inputRaw) {
   let currentInput = normalizePath(inputRaw);
-  if (!existsSync6(currentInput)) {
+  if (!existsSync8(currentInput)) {
     error(`File not found: ${currentInput}`);
     return false;
   }
@@ -1794,99 +2486,557 @@ async function runGUI3(inputRaw) {
     return false;
   }
   let currentBorderColor = await getBorderColor(currentInput);
+  let currentFrameCount = isMultiFrame(currentInput) ? await getFrameCount(currentInput) : 1;
   const presets = loadPresets();
+  async function generateFrameThumbnail(frameIndex) {
+    const tempDir = tmpdir5();
+    const tempOutput = join7(tempDir, `piclet-frame-${Date.now()}-${frameIndex}.png`);
+    try {
+      if (!await extractFirstFrame(currentInput, tempOutput, frameIndex)) {
+        return { success: false, error: "Failed to extract frame" };
+      }
+      const thumbOutput = join7(tempDir, `piclet-thumb-${Date.now()}-${frameIndex}.png`);
+      await scaleToSize(tempOutput, thumbOutput, 96);
+      const buffer = readFileSync6(thumbOutput);
+      cleanup(tempOutput, thumbOutput);
+      return {
+        success: true,
+        imageData: `data:image/png;base64,${buffer.toString("base64")}`
+      };
+    } catch (err) {
+      cleanup(tempOutput);
+      return { success: false, error: err.message };
+    }
+  }
+  async function generateFramePreview2(frameIndex, opts) {
+    const tempDir = tmpdir5();
+    const ts = Date.now();
+    const frameFile = join7(tempDir, `piclet-fp-${ts}-${frameIndex}.png`);
+    const temps = [frameFile];
+    try {
+      if (!await extractFirstFrame(currentInput, frameFile, frameIndex)) {
+        return { success: false, error: "Failed to extract frame" };
+      }
+      let current = frameFile;
+      const activeTools = ["removebg", "scale", "icons"].filter((t) => opts.tools.includes(t));
+      for (const tool of activeTools) {
+        const tempOut = join7(tempDir, `piclet-fp-${ts}-${frameIndex}-${tool}.png`);
+        temps.push(tempOut);
+        switch (tool) {
+          case "removebg": {
+            const rbOpts = opts.removebg;
+            let success2 = false;
+            if (rbOpts.preserveInner && currentBorderColor) {
+              success2 = await removeBackgroundBorderOnly(current, tempOut, currentBorderColor, rbOpts.fuzz);
+            }
+            if (!success2 && currentBorderColor) {
+              success2 = await removeBackground(current, tempOut, currentBorderColor, rbOpts.fuzz);
+            }
+            if (success2) {
+              if (rbOpts.trim) {
+                const trimOut = join7(tempDir, `piclet-fp-${ts}-${frameIndex}-trim.png`);
+                temps.push(trimOut);
+                if (await trim(tempOut, trimOut)) {
+                  current = trimOut;
+                } else {
+                  current = tempOut;
+                }
+              } else {
+                current = tempOut;
+              }
+            }
+            break;
+          }
+          case "scale": {
+            const scOpts = opts.scale;
+            if (scOpts.makeSquare) {
+              const max = Math.max(scOpts.width, scOpts.height);
+              if (await scaleWithPadding(current, tempOut, max, max)) {
+                current = tempOut;
+              }
+            } else {
+              if (await resize(current, tempOut, scOpts.width, scOpts.height)) {
+                current = tempOut;
+              }
+            }
+            break;
+          }
+          case "icons": {
+            const icOpts = opts.icons;
+            if (icOpts.trim) {
+              const trimOut = join7(tempDir, `piclet-fp-${ts}-${frameIndex}-ictrim.png`);
+              temps.push(trimOut);
+              if (await trim(current, trimOut)) {
+                current = trimOut;
+              }
+            }
+            if (icOpts.makeSquare) {
+              if (await squarify(current, tempOut)) {
+                current = tempOut;
+              }
+            }
+            break;
+          }
+        }
+      }
+      const thumbOut = join7(tempDir, `piclet-fp-${ts}-${frameIndex}-thumb.png`);
+      temps.push(thumbOut);
+      await scaleToSize(current, thumbOut, 96);
+      const buffer = readFileSync6(thumbOut);
+      cleanup(...temps);
+      return {
+        success: true,
+        imageData: `data:image/png;base64,${buffer.toString("base64")}`
+      };
+    } catch (err) {
+      cleanup(...temps);
+      return { success: false, error: err.message };
+    }
+  }
   return startGuiServer({
     htmlFile: "piclet.html",
     title: "PicLet",
     imageInfo: {
-      filePath: currentInput,
-      fileName: basename4(currentInput),
+      filePath: currentInput,
+      fileName: basename7(currentInput),
+      width: dims[0],
+      height: dims[1],
+      borderColor: currentBorderColor,
+      frameCount: currentFrameCount
+    },
+    defaults: {
+      // Return full preset data for the UI
+      presets: presets.map((p) => ({
+        id: p.id,
+        name: p.name,
+        description: p.description,
+        icons: p.icons
+      }))
+    },
+    onPreview: async (opts) => {
+      const toolOpts = opts;
+      if (!toolOpts.tools) {
+        toolOpts.tools = [];
+      }
+      if (isMultiFrame(currentInput) && typeof toolOpts.frameIndex === "number") {
+        const tempDir = tmpdir5();
+        const ts = Date.now();
+        const frameFile = join7(tempDir, `piclet-prev-${ts}.png`);
+        if (!await extractFirstFrame(currentInput, frameFile, toolOpts.frameIndex)) {
+          return { success: false, error: "Failed to extract frame" };
+        }
+        const result = await generateCombinedPreview(frameFile, currentBorderColor, toolOpts);
+        cleanup(frameFile);
+        return result;
+      }
+      return generateCombinedPreview(currentInput, currentBorderColor, toolOpts);
+    },
+    onProcess: async (opts) => {
+      const logs = [];
+      const toolOpts = opts;
+      if (toolOpts.exportMode && isMultiFrame(currentInput)) {
+        return processGifExport(currentInput, currentBorderColor, toolOpts, logs);
+      }
+      if (!toolOpts.tools || toolOpts.tools.length === 0) {
+        return { success: false, error: "No tools selected", logs };
+      }
+      if (!await checkImageMagick()) {
+        return {
+          success: false,
+          error: "ImageMagick not found",
+          logs: [{ type: "error", message: "ImageMagick not found. Install: sudo apt install imagemagick" }]
+        };
+      }
+      const outputs = await processCombined(currentInput, currentBorderColor, toolOpts, logs);
+      if (outputs.length > 0) {
+        return {
+          success: true,
+          output: outputs.join("\n"),
+          logs
+        };
+      }
+      return { success: false, error: "Processing failed", logs };
+    },
+    onLoadImage: async (data) => {
+      try {
+        const ext = extname2(data.fileName) || ".png";
+        const tempPath = join7(tmpdir5(), `piclet-load-${Date.now()}${ext}`);
+        const buffer = Buffer.from(data.data, "base64");
+        writeFileSync2(tempPath, buffer);
+        const newDims = await getDimensions(tempPath);
+        if (!newDims) {
+          cleanup(tempPath);
+          return { success: false, error: "Failed to read image dimensions" };
+        }
+        const newBorderColor = await getBorderColor(tempPath);
+        const newFrameCount = isMultiFrame(tempPath) ? await getFrameCount(tempPath) : 1;
+        currentInput = tempPath;
+        currentBorderColor = newBorderColor;
+        currentFrameCount = newFrameCount;
+        return {
+          success: true,
+          filePath: tempPath,
+          fileName: data.fileName,
+          width: newDims[0],
+          height: newDims[1],
+          borderColor: newBorderColor,
+          frameCount: newFrameCount
+        };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    },
+    onFrameThumbnail: generateFrameThumbnail,
+    onFramePreview: async (frameIndex, opts) => {
+      const toolOpts = opts;
+      if (!toolOpts.tools) toolOpts.tools = [];
+      return generateFramePreview2(frameIndex, toolOpts);
+    }
+  });
+}
+async function processGifExport(input, borderColor, opts, logs) {
+  if (!await checkImageMagick()) {
+    return {
+      success: false,
+      error: "ImageMagick not found",
+      logs: [{ type: "error", message: "ImageMagick not found" }]
+    };
+  }
+  const fileInfo = getFileInfo(input);
+  const tempDir = tmpdir5();
+  const ts = Date.now();
+  switch (opts.exportMode) {
+    case "frame": {
+      const frameIndex = opts.frameIndex ?? 0;
+      logs.push({ type: "info", message: `Exporting frame ${frameIndex + 1}...` });
+      const frameFile = join7(tempDir, `piclet-export-${ts}.png`);
+      if (!await extractFirstFrame(input, frameFile, frameIndex)) {
+        logs.push({ type: "error", message: "Failed to extract frame" });
+        return { success: false, error: "Failed to extract frame", logs };
+      }
+      let outputFile = frameFile;
+      if (opts.tools && opts.tools.length > 0) {
+        const processedLogs = [];
+        const outputs = await processCombined(frameFile, borderColor, opts, processedLogs);
+        logs.push(...processedLogs);
+        if (outputs.length === 0) {
+          cleanup(frameFile);
+          return { success: false, error: "Processing failed", logs };
+        }
+      }
+      const finalOutput = `${fileInfo.dirname}/${fileInfo.filename}_frame${frameIndex + 1}.png`;
+      if (outputFile === frameFile) {
+        renameSync(frameFile, finalOutput);
+      }
+      logs.push({ type: "success", message: `Exported frame ${frameIndex + 1}` });
+      return { success: true, output: basename7(finalOutput), logs };
+    }
+    case "all-frames": {
+      logs.push({ type: "info", message: "Extracting all frames..." });
+      const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_frames`;
+      mkdirSync5(outputDir, { recursive: true });
+      const frames = await extractAllFrames(input, outputDir, "frame");
+      if (frames.length === 0) {
+        logs.push({ type: "error", message: "Failed to extract frames" });
+        return { success: false, error: "Failed to extract frames", logs };
+      }
+      if (opts.tools && opts.tools.length > 0) {
+        logs.push({ type: "info", message: `Processing ${frames.length} frames...` });
+        for (let i = 0; i < frames.length; i++) {
+          const frameLogs = [];
+          await processCombined(frames[i], borderColor, opts, frameLogs);
+        }
+        logs.push({ type: "success", message: `Processed ${frames.length} frames` });
+      }
+      logs.push({ type: "success", message: `Exported ${frames.length} frames` });
+      return { success: true, output: `${frames.length} frames -> ${fileInfo.filename}_frames/`, logs };
+    }
+    case "gif": {
+      logs.push({ type: "info", message: "Processing GIF..." });
+      const outputs = await processCombined(input, borderColor, opts, logs);
+      if (outputs.length > 0) {
+        return { success: true, output: outputs.join("\n"), logs };
+      }
+      return { success: false, error: "Processing failed", logs };
+    }
+    default:
+      return { success: false, error: "Unknown export mode", logs };
+  }
+}
+var config6 = {
+  id: "piclet",
+  name: "PicLet",
+  icon: "banana.ico",
+  extensions: [".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico"]
+};
+
+// src/tools/recolor.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { tmpdir as tmpdir6 } from "os";
+import { basename as basename8, join as join8 } from "path";
+async function processImage3(input, options) {
+  const fileInfo = getFileInfo(input);
+  const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
+  const output = `${fileInfo.dirname}/${fileInfo.filename}_recolor${outputExt}`;
+  wip(`Replacing ${options.fromColor} with ${options.toColor}...`);
+  const success2 = await replaceColor(
+    input,
+    output,
+    options.fromColor,
+    options.toColor,
+    options.fuzz
+  );
+  if (!success2) {
+    wipDone(false, "Color replacement failed");
+    return false;
+  }
+  wipDone(true, "Color replaced");
+  const finalDims = await getDimensions(output);
+  console.log("");
+  if (finalDims) {
+    console.log(`Output: ${output} (${finalDims[0]}x${finalDims[1]})`);
+  } else {
+    console.log(`Output: ${output}`);
+  }
+  return true;
+}
+async function collectOptionsCLI3(detectedColor) {
+  console.log("");
+  console.log(`${BOLD}Color Replacement:${RESET}`);
+  console.log(`  ${DIM}Replace one color with another${RESET}`);
+  console.log(`  ${DIM}Colors can be hex (#fff), named (white), or rgb(...)${RESET}`);
+  console.log("");
+  const defaultFrom = detectedColor || "#ffffff";
+  let fromColor = await text("Color to replace", defaultFrom);
+  if (!fromColor) {
+    fromColor = defaultFrom;
+  }
+  console.log("");
+  let toColor = await text("New color", "#000000");
+  if (!toColor) {
+    toColor = "#000000";
+  }
+  console.log("");
+  console.log(`${BOLD}Fuzz Value:${RESET} Controls color matching sensitivity`);
+  console.log(`  ${DIM}0-10%   = Exact match only${RESET}`);
+  console.log(`  ${DIM}10-30%  = Similar colors${RESET}`);
+  console.log(`  ${DIM}30-50%  = Wider range${RESET}`);
+  console.log("");
+  let fuzz = await number("Fuzz value (0-100)", 10, 0, 100);
+  if (fuzz < 0 || fuzz > 100) {
+    fuzz = 10;
+  }
+  return { fromColor, toColor, fuzz };
+}
+async function run6(inputRaw) {
+  if (!await checkImageMagick()) {
+    error("ImageMagick not found. Please install it:");
+    console.log("  sudo apt update && sudo apt install imagemagick");
+    await pauseOnError();
+    return false;
+  }
+  const input = normalizePath(inputRaw);
+  if (!existsSync9(input)) {
+    error(`File not found: ${input}`);
+    await pauseOnError();
+    return false;
+  }
+  header("PicLet Recolor");
+  wip("Analyzing image...");
+  const dims = await getDimensions(input);
+  if (!dims) {
+    wipDone(false, "Failed to read image");
+    return false;
+  }
+  const borderColor = await getBorderColor(input);
+  wipDone(true, `Size: ${dims[0]}x${dims[1]}`);
+  if (borderColor) {
+    info(`Detected corner color: ${borderColor}`);
+  }
+  const options = await collectOptionsCLI3(borderColor);
+  console.log("");
+  return processImage3(input, options);
+}
+async function runGUI7(inputRaw) {
+  const input = normalizePath(inputRaw);
+  if (!existsSync9(input)) {
+    error(`File not found: ${input}`);
+    return false;
+  }
+  const dims = await getDimensions(input);
+  if (!dims) {
+    error("Failed to read image dimensions");
+    return false;
+  }
+  const borderColor = await getBorderColor(input);
+  return startGuiServer({
+    htmlFile: "recolor.html",
+    title: "PicLet - Recolor",
+    imageInfo: {
+      filePath: input,
+      fileName: basename8(input),
       width: dims[0],
       height: dims[1],
-      borderColor: currentBorderColor
+      borderColor
     },
     defaults: {
-      // Return full preset data for the UI
-      presets: presets.map((p) => ({
-        id: p.id,
-        name: p.name,
-        description: p.description,
-        icons: p.icons
-      }))
+      fromColor: borderColor || "#ffffff",
+      toColor: "#000000",
+      fuzz: 10
     },
     onPreview: async (opts) => {
-      const toolOpts = opts;
-      if (!toolOpts.tools) {
-        toolOpts.tools = [];
-      }
-      return generateCombinedPreview(currentInput, currentBorderColor, toolOpts);
+      const fromColor = opts.fromColor ?? "#ffffff";
+      const toColor = opts.toColor ?? "#000000";
+      const fuzz = opts.fuzz ?? 10;
+      return generatePreview4(input, { fromColor, toColor, fuzz });
     },
     onProcess: async (opts) => {
       const logs = [];
-      const toolOpts = opts;
-      if (!toolOpts.tools || toolOpts.tools.length === 0) {
-        return { success: false, error: "No tools selected", logs };
-      }
       if (!await checkImageMagick()) {
         return {
           success: false,
           error: "ImageMagick not found",
-          logs: [{ type: "error", message: "ImageMagick not found. Install: sudo apt install imagemagick" }]
+          logs: [{ type: "error", message: "ImageMagick not found. Install with: sudo apt install imagemagick" }]
         };
       }
-      const outputs = await processCombined(currentInput, currentBorderColor, toolOpts, logs);
-      if (outputs.length > 0) {
+      logs.push({ type: "info", message: `Processing ${basename8(input)}...` });
+      const fromColor = opts.fromColor ?? "#ffffff";
+      const toColor = opts.toColor ?? "#000000";
+      const fuzz = opts.fuzz ?? 10;
+      const options = { fromColor, toColor, fuzz };
+      const fileInfo = getFileInfo(input);
+      const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
+      const output = `${fileInfo.dirname}/${fileInfo.filename}_recolor${outputExt}`;
+      logs.push({ type: "info", message: `Replacing ${fromColor} \u2192 ${toColor}...` });
+      const success2 = await replaceColor(input, output, fromColor, toColor, fuzz);
+      if (success2) {
+        logs.push({ type: "success", message: "Color replaced" });
+        const finalDims = await getDimensions(output);
+        const sizeStr = finalDims ? ` (${finalDims[0]}x${finalDims[1]})` : "";
         return {
           success: true,
-          output: outputs.join("\n"),
+          output: `${basename8(output)}${sizeStr}`,
           logs
         };
       }
-      return { success: false, error: "Processing failed", logs };
-    },
-    onLoadImage: async (data) => {
-      try {
-        const ext = extname2(data.fileName) || ".png";
-        const tempPath = join5(tmpdir2(), `piclet-load-${Date.now()}${ext}`);
-        const buffer = Buffer.from(data.data, "base64");
-        writeFileSync3(tempPath, buffer);
-        const newDims = await getDimensions(tempPath);
-        if (!newDims) {
-          cleanup(tempPath);
-          return { success: false, error: "Failed to read image dimensions" };
-        }
-        const newBorderColor = await getBorderColor(tempPath);
-        currentInput = tempPath;
-        currentBorderColor = newBorderColor;
-        return {
-          success: true,
-          filePath: tempPath,
-          fileName: data.fileName,
-          width: newDims[0],
-          height: newDims[1],
-          borderColor: newBorderColor
-        };
-      } catch (err) {
-        return { success: false, error: err.message };
-      }
+      logs.push({ type: "error", message: "Color replacement failed" });
+      return {
+        success: false,
+        error: "Processing failed",
+        logs
+      };
     }
   });
 }
-var config3 = {
-  id: "piclet",
-  name: "PicLet",
-  icon: "banana.ico",
-  extensions: [".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico"]
+async function generatePreview4(input, options) {
+  const tempDir = tmpdir6();
+  const timestamp = Date.now();
+  const tempSource = join8(tempDir, `piclet-preview-${timestamp}-src.png`);
+  const tempOutput = join8(tempDir, `piclet-preview-${timestamp}.png`);
+  try {
+    let previewInput = input;
+    if (isMultiFrame(input)) {
+      if (!await extractFirstFrame(input, tempSource)) {
+        return { success: false, error: "Failed to extract frame" };
+      }
+      previewInput = tempSource;
+    }
+    const success2 = await replaceColor(
+      previewInput,
+      tempOutput,
+      options.fromColor,
+      options.toColor,
+      options.fuzz
+    );
+    if (!success2) {
+      cleanup(tempSource, tempOutput);
+      return { success: false, error: "Color replacement failed" };
+    }
+    const buffer = readFileSync7(tempOutput);
+    const base64 = buffer.toString("base64");
+    const imageData = `data:image/png;base64,${base64}`;
+    const dims = await getDimensions(tempOutput);
+    cleanup(tempSource, tempOutput);
+    return {
+      success: true,
+      imageData,
+      width: dims?.[0],
+      height: dims?.[1]
+    };
+  } catch (err) {
+    cleanup(tempSource, tempOutput);
+    return { success: false, error: err.message };
+  }
+}
+var config7 = {
+  id: "recolor",
+  name: "Recolor",
+  icon: "recolor.ico",
+  extensions: [".png", ".jpg", ".jpeg", ".gif", ".bmp"]
 };
 
 // src/tools/remove-bg.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5, renameSync as renameSync2 } from "fs";
-import { tmpdir as tmpdir3 } from "os";
-import { basename as basename5, join as join6 } from "path";
-async function processImage(input, borderColor, options) {
+import { existsSync as existsSync11, readFileSync as readFileSync9, renameSync as renameSync2 } from "fs";
+import { tmpdir as tmpdir7 } from "os";
+import { basename as basename9, join as join10 } from "path";
+
+// src/lib/config.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname7, join as join9 } from "path";
+import { homedir as homedir2 } from "os";
+var DEFAULT_CONFIG = {
+  removeBg: {
+    fuzz: 10,
+    trim: true,
+    preserveInner: false,
+    makeSquare: false
+  },
+  rescale: {
+    defaultScale: 50,
+    makeSquare: false
+  },
+  iconpack: {
+    platforms: ["web", "android", "ios"]
+  }
+};
+function getConfigDir() {
+  return join9(homedir2(), ".config", "piclet");
+}
+function getConfigPath() {
+  return join9(getConfigDir(), "config.json");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync10(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const content = readFileSync8(configPath, "utf-8");
+    const loaded = JSON.parse(content);
+    return {
+      removeBg: { ...DEFAULT_CONFIG.removeBg, ...loaded.removeBg },
+      rescale: { ...DEFAULT_CONFIG.rescale, ...loaded.rescale },
+      iconpack: { ...DEFAULT_CONFIG.iconpack, ...loaded.iconpack }
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function resetConfig() {
+  const configPath = getConfigPath();
+  const configDir = dirname7(configPath);
+  if (!existsSync10(configDir)) {
+    mkdirSync6(configDir, { recursive: true });
+  }
+  writeFileSync3(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
+}
+
+// src/tools/remove-bg.ts
+async function processImage4(input, borderColor, options) {
   const fileInfo = getFileInfo(input);
-  const output = `${fileInfo.dirname}/${fileInfo.filename}_nobg.png`;
-  const tempFile = `${fileInfo.dirname}/${fileInfo.filename}_temp.png`;
+  const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
+  const output = `${fileInfo.dirname}/${fileInfo.filename}_nobg${outputExt}`;
+  const tempFile = `${fileInfo.dirname}/${fileInfo.filename}_temp${outputExt}`;
   wip("Removing background...");
   let bgRemoved = false;
   if (options.preserveInner && borderColor) {
@@ -1923,8 +3073,8 @@ async function processImage(input, borderColor, options) {
   }
   if (options.makeSquare) {
     wip("Making square...");
-    const tempSquare = `${fileInfo.dirname}/${fileInfo.filename}_square_temp.png`;
-    if (await squarify2(output, tempSquare)) {
+    const tempSquare = `${fileInfo.dirname}/${fileInfo.filename}_square_temp${outputExt}`;
+    if (await squarify(output, tempSquare)) {
       renameSync2(tempSquare, output);
       wipDone(true, "Made square");
     } else {
@@ -1941,7 +3091,7 @@ async function processImage(input, borderColor, options) {
   }
   return true;
 }
-async function collectOptionsCLI() {
+async function collectOptionsCLI4() {
   console.log("");
   console.log(`${BOLD}Fuzz Value:${RESET} Controls color matching strictness`);
   console.log(`  ${DIM}0-10%   = Only exact or very similar colors${RESET}`);
@@ -1971,7 +3121,7 @@ async function collectOptionsCLI() {
   );
   return { fuzz, doTrim, preserveInner, makeSquare };
 }
-async function run3(inputRaw) {
+async function run7(inputRaw) {
   if (!await checkImageMagick()) {
     error("ImageMagick not found. Please install it:");
     console.log("  sudo apt update && sudo apt install imagemagick");
@@ -1979,7 +3129,7 @@ async function run3(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync7(input)) {
+  if (!existsSync11(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -1996,13 +3146,13 @@ async function run3(inputRaw) {
   if (borderColor) {
     info(`Detected border color: ${borderColor}`);
   }
-  const options = await collectOptionsCLI();
+  const options = await collectOptionsCLI4();
   console.log("");
-  return processImage(input, borderColor, options);
+  return processImage4(input, borderColor, options);
 }
-async function runGUI4(inputRaw) {
+async function runGUI8(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync7(input)) {
+  if (!existsSync11(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -2012,14 +3162,14 @@ async function runGUI4(inputRaw) {
     return false;
   }
   const borderColor = await getBorderColor(input);
-  const config7 = loadConfig();
-  const defaults = config7.removeBg;
+  const config12 = loadConfig();
+  const defaults = config12.removeBg;
   return startGuiServer({
     htmlFile: "remove-bg.html",
     title: "PicLet - Remove Background",
     imageInfo: {
       filePath: input,
-      fileName: basename5(input),
+      fileName: basename9(input),
       width: dims[0],
       height: dims[1],
       borderColor
@@ -2037,7 +3187,7 @@ async function runGUI4(inputRaw) {
         preserveInner: opts.preserveInner ?? defaults.preserveInner,
         makeSquare: opts.makeSquare ?? defaults.makeSquare
       };
-      return generatePreview2(input, borderColor, options);
+      return generatePreview5(input, borderColor, options);
     },
     onProcess: async (opts) => {
       const logs = [];
@@ -2048,7 +3198,7 @@ async function runGUI4(inputRaw) {
           logs: [{ type: "error", message: "ImageMagick not found. Install with: sudo apt install imagemagick" }]
         };
       }
-      logs.push({ type: "info", message: `Processing ${basename5(input)}...` });
+      logs.push({ type: "info", message: `Processing ${basename9(input)}...` });
       const options = {
         fuzz: opts.fuzz ?? defaults.fuzz,
         doTrim: opts.trim ?? defaults.trim,
@@ -2064,7 +3214,7 @@ async function runGUI4(inputRaw) {
         const sizeStr = finalDims ? ` (${finalDims[0]}x${finalDims[1]})` : "";
         return {
           success: true,
-          output: `${basename5(output)}${sizeStr}`,
+          output: `${basename9(output)}${sizeStr}`,
           logs
         };
       }
@@ -2078,8 +3228,9 @@ async function runGUI4(inputRaw) {
 }
 async function processImageSilent(input, borderColor, options, logs) {
   const fileInfo = getFileInfo(input);
-  const output = `${fileInfo.dirname}/${fileInfo.filename}_nobg.png`;
-  const tempFile = `${fileInfo.dirname}/${fileInfo.filename}_temp.png`;
+  const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
+  const output = `${fileInfo.dirname}/${fileInfo.filename}_nobg${outputExt}`;
+  const tempFile = `${fileInfo.dirname}/${fileInfo.filename}_temp${outputExt}`;
   let bgRemoved = false;
   if (options.preserveInner && borderColor) {
     bgRemoved = await removeBackgroundBorderOnly(
@@ -2115,8 +3266,8 @@ async function processImageSilent(input, borderColor, options, logs) {
   }
   if (options.makeSquare) {
     logs.push({ type: "info", message: "Making square..." });
-    const tempSquare = `${fileInfo.dirname}/${fileInfo.filename}_square_temp.png`;
-    if (await squarify2(output, tempSquare)) {
+    const tempSquare = `${fileInfo.dirname}/${fileInfo.filename}_square_temp${outputExt}`;
+    if (await squarify(output, tempSquare)) {
       renameSync2(tempSquare, output);
       logs.push({ type: "success", message: "Made square" });
     } else {
@@ -2126,20 +3277,29 @@ async function processImageSilent(input, borderColor, options, logs) {
   }
   return true;
 }
-async function generatePreview2(input, borderColor, options) {
-  const tempDir = tmpdir3();
+async function generatePreview5(input, borderColor, options) {
+  const tempDir = tmpdir7();
   const timestamp = Date.now();
-  const tempFile = join6(tempDir, `piclet-preview-${timestamp}.png`);
-  const tempOutput = join6(tempDir, `piclet-preview-${timestamp}-out.png`);
+  const tempSource = join10(tempDir, `piclet-preview-${timestamp}-src.png`);
+  const tempFile = join10(tempDir, `piclet-preview-${timestamp}.png`);
+  const tempOutput = join10(tempDir, `piclet-preview-${timestamp}-out.png`);
   try {
+    let previewInput = input;
+    if (isMultiFrame(input)) {
+      if (!await extractFirstFrame(input, tempSource)) {
+        return { success: false, error: "Failed to extract frame" };
+      }
+      previewInput = tempSource;
+    }
     let bgRemoved = false;
     if (options.preserveInner && borderColor) {
-      bgRemoved = await removeBackgroundBorderOnly(input, tempFile, borderColor, options.fuzz);
+      bgRemoved = await removeBackgroundBorderOnly(previewInput, tempFile, borderColor, options.fuzz);
     }
     if (!bgRemoved && borderColor) {
-      bgRemoved = await removeBackground(input, tempFile, borderColor, options.fuzz);
+      bgRemoved = await removeBackground(previewInput, tempFile, borderColor, options.fuzz);
     }
     if (!bgRemoved) {
+      cleanup(tempSource);
       return { success: false, error: "Background removal failed" };
     }
     let currentFile = tempFile;
@@ -2150,17 +3310,17 @@ async function generatePreview2(input, borderColor, options) {
       }
     }
     if (options.makeSquare) {
-      const squareFile = join6(tempDir, `piclet-preview-${timestamp}-sq.png`);
-      if (await squarify2(currentFile, squareFile)) {
+      const squareFile = join10(tempDir, `piclet-preview-${timestamp}-sq.png`);
+      if (await squarify(currentFile, squareFile)) {
         cleanup(currentFile);
         currentFile = squareFile;
       }
     }
-    const buffer = readFileSync5(currentFile);
+    const buffer = readFileSync9(currentFile);
     const base64 = buffer.toString("base64");
     const imageData = `data:image/png;base64,${base64}`;
     const dims = await getDimensions(currentFile);
-    cleanup(currentFile, tempFile, tempOutput);
+    cleanup(currentFile, tempFile, tempOutput, tempSource);
     return {
       success: true,
       imageData,
@@ -2168,22 +3328,22 @@ async function generatePreview2(input, borderColor, options) {
       height: dims?.[1]
     };
   } catch (err) {
-    cleanup(tempFile, tempOutput);
+    cleanup(tempFile, tempOutput, tempSource);
     return { success: false, error: err.message };
   }
 }
-var config4 = {
+var config8 = {
   id: "remove-bg",
   name: "Remove Background",
   icon: "removebg.ico",
-  extensions: [".png", ".jpg", ".jpeg", ".ico"]
+  extensions: [".png", ".jpg", ".jpeg", ".ico", ".gif"]
 };
 
 // src/tools/rescale.ts
-import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
-import { tmpdir as tmpdir4 } from "os";
-import { basename as basename6, join as join7 } from "path";
-async function run4(inputRaw) {
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
+import { tmpdir as tmpdir8 } from "os";
+import { basename as basename10, join as join11 } from "path";
+async function run8(inputRaw) {
   if (!await checkImageMagick()) {
     error("ImageMagick not found. Please install it:");
     console.log("  sudo apt update && sudo apt install imagemagick");
@@ -2191,7 +3351,7 @@ async function run4(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync8(input)) {
+  if (!existsSync12(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -2252,7 +3412,7 @@ async function run4(inputRaw) {
   } else {
     scaled = await resize(input, output, targetW, targetH);
   }
-  if (!scaled || !existsSync8(output)) {
+  if (!scaled || !existsSync12(output)) {
     wipDone(false, "Scaling failed");
     return false;
   }
@@ -2266,9 +3426,9 @@ async function run4(inputRaw) {
   success(`Output: ${output}`);
   return true;
 }
-async function runGUI5(inputRaw) {
+async function runGUI9(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync8(input)) {
+  if (!existsSync12(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -2283,7 +3443,7 @@ async function runGUI5(inputRaw) {
     title: "PicLet - Scale Image",
     imageInfo: {
       filePath: input,
-      fileName: basename6(input),
+      fileName: basename10(input),
       width: dims[0],
       height: dims[1],
       borderColor: null
@@ -2297,7 +3457,7 @@ async function runGUI5(inputRaw) {
         height: opts.height ?? Math.round(dims[1] / 2),
         makeSquare: opts.makeSquare ?? false
       };
-      return generatePreview3(input, options);
+      return generatePreview6(input, options);
     },
     onProcess: async (opts) => {
       const logs = [];
@@ -2322,13 +3482,13 @@ async function runGUI5(inputRaw) {
       } else {
         scaled = await resize(input, output, options.width, options.height);
       }
-      if (scaled && existsSync8(output)) {
+      if (scaled && existsSync12(output)) {
         const finalDims = await getDimensions(output);
         const sizeStr = finalDims ? ` (${finalDims[0]}x${finalDims[1]})` : "";
         logs.push({ type: "success", message: "Scaled successfully" });
         return {
           success: true,
-          output: `${basename6(output)}${sizeStr}`,
+          output: `${basename10(output)}${sizeStr}`,
           logs
         };
       }
@@ -2337,11 +3497,19 @@ async function runGUI5(inputRaw) {
     }
   });
 }
-async function generatePreview3(input, options) {
-  const tempDir = tmpdir4();
+async function generatePreview6(input, options) {
+  const tempDir = tmpdir8();
   const timestamp = Date.now();
-  const tempOutput = join7(tempDir, `piclet-preview-${timestamp}.png`);
+  const tempSource = join11(tempDir, `piclet-preview-${timestamp}-src.png`);
+  const tempOutput = join11(tempDir, `piclet-preview-${timestamp}.png`);
   try {
+    let previewInput = input;
+    if (isMultiFrame(input)) {
+      if (!await extractFirstFrame(input, tempSource)) {
+        return { success: false, error: "Failed to extract frame" };
+      }
+      previewInput = tempSource;
+    }
     let scaled = false;
     let targetW = options.width;
     let targetH = options.height;
@@ -2349,18 +3517,19 @@ async function generatePreview3(input, options) {
       const maxDim = Math.max(targetW, targetH);
       targetW = maxDim;
       targetH = maxDim;
-      scaled = await scaleWithPadding(input, tempOutput, targetW, targetH);
+      scaled = await scaleWithPadding(previewInput, tempOutput, targetW, targetH);
     } else {
-      scaled = await resize(input, tempOutput, targetW, targetH);
+      scaled = await resize(previewInput, tempOutput, targetW, targetH);
     }
-    if (!scaled || !existsSync8(tempOutput)) {
+    if (!scaled || !existsSync12(tempOutput)) {
+      cleanup(tempSource);
       return { success: false, error: "Scaling failed" };
     }
-    const buffer = readFileSync6(tempOutput);
+    const buffer = readFileSync10(tempOutput);
     const base64 = buffer.toString("base64");
     const imageData = `data:image/png;base64,${base64}`;
     const dims = await getDimensions(tempOutput);
-    cleanup(tempOutput);
+    cleanup(tempSource, tempOutput);
     return {
       success: true,
       imageData,
@@ -2368,11 +3537,11 @@ async function generatePreview3(input, options) {
       height: dims?.[1]
     };
   } catch (err) {
-    cleanup(tempOutput);
+    cleanup(tempSource, tempOutput);
     return { success: false, error: err.message };
   }
 }
-var config5 = {
+var config9 = {
   id: "rescale",
   name: "Scale Image",
   icon: "rescale.ico",
@@ -2380,8 +3549,8 @@ var config5 = {
 };
 
 // src/tools/storepack.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
-import { basename as basename7, join as join8 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync7 } from "fs";
+import { basename as basename11, join as join12 } from "path";
 async function scaleImage(input, output, width, height, mode) {
   switch (mode) {
     case "fill":
@@ -2398,7 +3567,7 @@ async function generatePresetImages(sourceImg, outputDir, preset, scaleMode = "f
   const total = preset.icons.length;
   for (let i = 0; i < total; i++) {
     const icon = preset.icons[i];
-    const outputPath = join8(outputDir, icon.filename);
+    const outputPath = join12(outputDir, icon.filename);
     if (logs) {
       logs.push({ type: "info", message: `[${i + 1}/${total}] ${icon.filename}` });
     } else {
@@ -2426,7 +3595,7 @@ async function generatePresetImages(sourceImg, outputDir, preset, scaleMode = "f
   }
   return failed;
 }
-async function run5(inputRaw) {
+async function run9(inputRaw) {
   if (!await checkImageMagick()) {
     error("ImageMagick not found. Please install it:");
     console.log("  sudo apt update && sudo apt install imagemagick");
@@ -2434,7 +3603,7 @@ async function run5(inputRaw) {
     return false;
   }
   const input = normalizePath(inputRaw);
-  if (!existsSync9(input)) {
+  if (!existsSync13(input)) {
     error(`File not found: ${input}`);
     await pauseOnError();
     return false;
@@ -2462,11 +3631,11 @@ async function run5(inputRaw) {
     return false;
   }
   const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_${preset.id}`;
-  mkdirSync6(outputDir, { recursive: true });
+  mkdirSync7(outputDir, { recursive: true });
   info(`Output: ${outputDir}`);
   console.log("");
   wip("Preparing source...");
-  const tempSource = join8(outputDir, ".source.png");
+  const tempSource = join12(outputDir, ".source.png");
   if (!await squarify(input, tempSource)) {
     wipDone(false, "Failed to prepare source");
     return false;
@@ -2482,12 +3651,187 @@ async function run5(inputRaw) {
   } else {
     error(`${failed}/${preset.icons.length} images failed`);
   }
-  info(`Output: ${outputDir}`);
-  return failed === 0;
+  info(`Output: ${outputDir}`);
+  return failed === 0;
+}
+async function runGUI10(inputRaw) {
+  const input = normalizePath(inputRaw);
+  if (!existsSync13(input)) {
+    error(`File not found: ${input}`);
+    return false;
+  }
+  const dims = await getDimensions(input);
+  if (!dims) {
+    error("Failed to read image dimensions");
+    return false;
+  }
+  const fileInfo = getFileInfo(input);
+  const presets = loadPresets();
+  return startGuiServer({
+    htmlFile: "storepack.html",
+    title: "PicLet - Store Pack",
+    imageInfo: {
+      filePath: input,
+      fileName: basename11(input),
+      width: dims[0],
+      height: dims[1],
+      borderColor: null
+    },
+    defaults: {
+      presets: presets.map((p) => ({
+        id: p.id,
+        name: p.name,
+        description: p.description,
+        icons: p.icons
+      }))
+    },
+    onProcess: async (opts) => {
+      const logs = [];
+      if (!await checkImageMagick()) {
+        return {
+          success: false,
+          error: "ImageMagick not found",
+          logs: [{ type: "error", message: "ImageMagick not found" }]
+        };
+      }
+      const presetId = opts.preset;
+      const scaleMode = opts.scaleMode || "fit";
+      const preset = presets.find((p) => p.id === presetId);
+      if (!preset) {
+        return {
+          success: false,
+          error: "Preset not found",
+          logs: [{ type: "error", message: "No preset selected" }]
+        };
+      }
+      const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_${preset.id}`;
+      mkdirSync7(outputDir, { recursive: true });
+      logs.push({ type: "info", message: `Output: ${outputDir}` });
+      logs.push({ type: "info", message: `Scale mode: ${scaleMode}` });
+      logs.push({ type: "info", message: `Generating ${preset.icons.length} images...` });
+      const failed = await generatePresetImages(input, outputDir, preset, scaleMode, logs);
+      if (failed === 0) {
+        logs.push({ type: "success", message: `All ${preset.icons.length} images generated` });
+        return {
+          success: true,
+          output: `${preset.icons.length} images saved to ${fileInfo.filename}_${preset.id}/`,
+          logs
+        };
+      }
+      return {
+        success: false,
+        error: `${failed} image(s) failed`,
+        logs
+      };
+    }
+  });
+}
+var config10 = {
+  id: "storepack",
+  name: "Store Pack",
+  icon: "storepack.ico",
+  extensions: [".png", ".jpg", ".jpeg", ".gif"]
+};
+
+// src/tools/transform.ts
+import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
+import { tmpdir as tmpdir9 } from "os";
+import { basename as basename12, join as join13 } from "path";
+var TRANSFORM_LABELS = {
+  "flip-h": "Flip Horizontal",
+  "flip-v": "Flip Vertical",
+  "rotate-90": "Rotate 90\xB0",
+  "rotate-180": "Rotate 180\xB0",
+  "rotate-270": "Rotate 270\xB0"
+};
+async function processImage5(input, options) {
+  const fileInfo = getFileInfo(input);
+  const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
+  const suffix = options.transform.replace("-", "");
+  const output = `${fileInfo.dirname}/${fileInfo.filename}_${suffix}${outputExt}`;
+  wip(`Applying ${TRANSFORM_LABELS[options.transform]}...`);
+  let success2 = false;
+  switch (options.transform) {
+    case "flip-h":
+      success2 = await flipHorizontal(input, output);
+      break;
+    case "flip-v":
+      success2 = await flipVertical(input, output);
+      break;
+    case "rotate-90":
+      success2 = await rotate(input, output, 90);
+      break;
+    case "rotate-180":
+      success2 = await rotate(input, output, 180);
+      break;
+    case "rotate-270":
+      success2 = await rotate(input, output, 270);
+      break;
+  }
+  if (!success2) {
+    wipDone(false, "Transform failed");
+    return false;
+  }
+  wipDone(true, TRANSFORM_LABELS[options.transform]);
+  const finalDims = await getDimensions(output);
+  console.log("");
+  if (finalDims) {
+    console.log(`Output: ${output} (${finalDims[0]}x${finalDims[1]})`);
+  } else {
+    console.log(`Output: ${output}`);
+  }
+  return true;
+}
+async function collectOptionsCLI5() {
+  console.log("");
+  console.log(`${BOLD}Transform Options:${RESET}`);
+  console.log(`  ${DIM}1. Flip Horizontal (mirror)${RESET}`);
+  console.log(`  ${DIM}2. Flip Vertical${RESET}`);
+  console.log(`  ${DIM}3. Rotate 90\xB0 clockwise${RESET}`);
+  console.log(`  ${DIM}4. Rotate 180\xB0${RESET}`);
+  console.log(`  ${DIM}5. Rotate 270\xB0 clockwise${RESET}`);
+  console.log("");
+  const transform = await select(
+    "Select transform",
+    [
+      { value: "flip-h", title: "Flip Horizontal" },
+      { value: "flip-v", title: "Flip Vertical" },
+      { value: "rotate-90", title: "Rotate 90\xB0" },
+      { value: "rotate-180", title: "Rotate 180\xB0" },
+      { value: "rotate-270", title: "Rotate 270\xB0" }
+    ],
+    "flip-h"
+  );
+  return { transform: transform ?? "flip-h" };
+}
+async function run10(inputRaw) {
+  if (!await checkImageMagick()) {
+    error("ImageMagick not found. Please install it:");
+    console.log("  sudo apt update && sudo apt install imagemagick");
+    await pauseOnError();
+    return false;
+  }
+  const input = normalizePath(inputRaw);
+  if (!existsSync14(input)) {
+    error(`File not found: ${input}`);
+    await pauseOnError();
+    return false;
+  }
+  header("PicLet Transform");
+  wip("Analyzing image...");
+  const dims = await getDimensions(input);
+  if (!dims) {
+    wipDone(false, "Failed to read image");
+    return false;
+  }
+  wipDone(true, `Size: ${dims[0]}x${dims[1]}`);
+  const options = await collectOptionsCLI5();
+  console.log("");
+  return processImage5(input, options);
 }
-async function runGUI6(inputRaw) {
+async function runGUI11(inputRaw) {
   const input = normalizePath(inputRaw);
-  if (!existsSync9(input)) {
+  if (!existsSync14(input)) {
     error(`File not found: ${input}`);
     return false;
   }
@@ -2496,25 +3840,22 @@ async function runGUI6(inputRaw) {
     error("Failed to read image dimensions");
     return false;
   }
-  const fileInfo = getFileInfo(input);
-  const presets = loadPresets();
   return startGuiServer({
-    htmlFile: "storepack.html",
-    title: "PicLet - Store Pack",
+    htmlFile: "transform.html",
+    title: "PicLet - Transform",
     imageInfo: {
       filePath: input,
-      fileName: basename7(input),
+      fileName: basename12(input),
       width: dims[0],
       height: dims[1],
       borderColor: null
     },
     defaults: {
-      presets: presets.map((p) => ({
-        id: p.id,
-        name: p.name,
-        description: p.description,
-        icons: p.icons
-      }))
+      transform: "flip-h"
+    },
+    onPreview: async (opts) => {
+      const transform = opts.transform ?? "flip-h";
+      return generatePreview7(input, { transform });
     },
     onProcess: async (opts) => {
       const logs = [];
@@ -2522,67 +3863,136 @@ async function runGUI6(inputRaw) {
         return {
           success: false,
           error: "ImageMagick not found",
-          logs: [{ type: "error", message: "ImageMagick not found" }]
+          logs: [{ type: "error", message: "ImageMagick not found. Install with: sudo apt install imagemagick" }]
         };
       }
-      const presetId = opts.preset;
-      const scaleMode = opts.scaleMode || "fit";
-      const preset = presets.find((p) => p.id === presetId);
-      if (!preset) {
-        return {
-          success: false,
-          error: "Preset not found",
-          logs: [{ type: "error", message: "No preset selected" }]
-        };
+      logs.push({ type: "info", message: `Processing ${basename12(input)}...` });
+      const transform = opts.transform ?? "flip-h";
+      const options = { transform };
+      const fileInfo = getFileInfo(input);
+      const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
+      const suffix = transform.replace("-", "");
+      const output = `${fileInfo.dirname}/${fileInfo.filename}_${suffix}${outputExt}`;
+      logs.push({ type: "info", message: `Applying ${TRANSFORM_LABELS[transform]}...` });
+      let success2 = false;
+      switch (transform) {
+        case "flip-h":
+          success2 = await flipHorizontal(input, output);
+          break;
+        case "flip-v":
+          success2 = await flipVertical(input, output);
+          break;
+        case "rotate-90":
+          success2 = await rotate(input, output, 90);
+          break;
+        case "rotate-180":
+          success2 = await rotate(input, output, 180);
+          break;
+        case "rotate-270":
+          success2 = await rotate(input, output, 270);
+          break;
       }
-      const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_${preset.id}`;
-      mkdirSync6(outputDir, { recursive: true });
-      logs.push({ type: "info", message: `Output: ${outputDir}` });
-      logs.push({ type: "info", message: `Scale mode: ${scaleMode}` });
-      logs.push({ type: "info", message: `Generating ${preset.icons.length} images...` });
-      const failed = await generatePresetImages(input, outputDir, preset, scaleMode, logs);
-      if (failed === 0) {
-        logs.push({ type: "success", message: `All ${preset.icons.length} images generated` });
+      if (success2) {
+        logs.push({ type: "success", message: "Transform applied" });
+        const finalDims = await getDimensions(output);
+        const sizeStr = finalDims ? ` (${finalDims[0]}x${finalDims[1]})` : "";
         return {
           success: true,
-          output: `${preset.icons.length} images saved to ${fileInfo.filename}_${preset.id}/`,
+          output: `${basename12(output)}${sizeStr}`,
           logs
         };
       }
+      logs.push({ type: "error", message: "Transform failed" });
       return {
         success: false,
-        error: `${failed} image(s) failed`,
+        error: "Processing failed",
         logs
       };
     }
   });
 }
-var config6 = {
-  id: "storepack",
-  name: "Store Pack",
-  icon: "storepack.ico",
-  extensions: [".png", ".jpg", ".jpeg"]
+async function generatePreview7(input, options) {
+  const tempDir = tmpdir9();
+  const timestamp = Date.now();
+  const tempSource = join13(tempDir, `piclet-preview-${timestamp}-src.png`);
+  const tempOutput = join13(tempDir, `piclet-preview-${timestamp}.png`);
+  try {
+    let previewInput = input;
+    if (isMultiFrame(input)) {
+      if (!await extractFirstFrame(input, tempSource)) {
+        return { success: false, error: "Failed to extract frame" };
+      }
+      previewInput = tempSource;
+    }
+    let success2 = false;
+    switch (options.transform) {
+      case "flip-h":
+        success2 = await flipHorizontal(previewInput, tempOutput);
+        break;
+      case "flip-v":
+        success2 = await flipVertical(previewInput, tempOutput);
+        break;
+      case "rotate-90":
+        success2 = await rotate(previewInput, tempOutput, 90);
+        break;
+      case "rotate-180":
+        success2 = await rotate(previewInput, tempOutput, 180);
+        break;
+      case "rotate-270":
+        success2 = await rotate(previewInput, tempOutput, 270);
+        break;
+    }
+    if (!success2) {
+      cleanup(tempSource, tempOutput);
+      return { success: false, error: "Transform failed" };
+    }
+    const buffer = readFileSync11(tempOutput);
+    const base64 = buffer.toString("base64");
+    const imageData = `data:image/png;base64,${base64}`;
+    const dims = await getDimensions(tempOutput);
+    cleanup(tempSource, tempOutput);
+    return {
+      success: true,
+      imageData,
+      width: dims?.[0],
+      height: dims?.[1]
+    };
+  } catch (err) {
+    cleanup(tempSource, tempOutput);
+    return { success: false, error: err.message };
+  }
+}
+var config11 = {
+  id: "transform",
+  name: "Transform",
+  icon: "transform.ico",
+  extensions: [".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico"]
 };
 
 // src/cli/tools.ts
 var tools = [
-  { config: config2, run: run2, runGUI: runGUI2 },
-  { config: config4, run: run3, runGUI: runGUI4 },
-  { config: config5, run: run4, runGUI: runGUI5 },
+  { config: config5, run: run5, runGUI: runGUI5 },
+  { config: config8, run: run7, runGUI: runGUI8 },
+  { config: config9, run: run8, runGUI: runGUI9 },
+  { config: config4, run: run4, runGUI: runGUI4 },
+  { config: config10, run: run9, runGUI: runGUI10 },
+  { config: config11, run: run10, runGUI: runGUI11 },
+  { config: config3, run: run3, runGUI: runGUI3 },
   { config, run, runGUI },
-  { config: config6, run: run5, runGUI: runGUI6 }
+  { config: config7, run: run6, runGUI: runGUI7 },
+  { config: config2, run: run2, runGUI: runGUI2 }
 ];
 var picletTool = {
-  config: config3,
-  runGUI: runGUI3
+  config: config6,
+  runGUI: runGUI6
 };
 function getTool(id) {
   return tools.find((t) => t.config.id === id);
 }
 function getAllExtensions() {
   const extensions = /* @__PURE__ */ new Set();
-  for (const { config: config7 } of tools) {
-    for (const ext of config7.extensions) {
+  for (const { config: config12 } of tools) {
+    for (const ext of config12.extensions) {
       extensions.add(ext);
     }
   }
@@ -2616,17 +4026,17 @@ function validateExtensions(files, allowedExtensions) {
 async function runToolOnFiles(toolId, files, useYes) {
   const tool = getTool(toolId);
   if (!tool) {
-    console.error(chalk2.red(`Tool not found: ${toolId}`));
+    console.error(chalk.red(`Tool not found: ${toolId}`));
     return false;
   }
   const { valid, invalid } = validateExtensions(files, tool.config.extensions);
   if (invalid.length > 0) {
-    console.error(chalk2.red("Invalid file types:"));
+    console.error(chalk.red("Invalid file types:"));
     for (const file of invalid) {
-      console.error(chalk2.red(`  \u2717 ${file}`));
+      console.error(chalk.red(`  \u2717 ${file}`));
     }
     console.error(
-      chalk2.yellow(
+      chalk.yellow(
         `
 Supported extensions: ${tool.config.extensions.join(", ")}`
       )
@@ -2641,7 +4051,7 @@ Supported extensions: ${tool.config.extensions.join(", ")}`
   for (let i = 0; i < valid.length; i++) {
     const file = valid[i];
     if (valid.length > 1) {
-      console.log(chalk2.cyan(`
+      console.log(chalk.cyan(`
 [${i + 1}/${valid.length}] ${file}`));
     }
     const success2 = await tool.run(file);
@@ -2650,21 +4060,126 @@ Supported extensions: ${tool.config.extensions.join(", ")}`
   return allSuccess;
 }
 
+// src/cli/commands/border.ts
+function registerBorderCommand(program2) {
+  program2.command("border <files...>").description("Add solid color border to images").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use GUI for options").action(async (files, options) => {
+    if (options.gui) {
+      const { valid, invalid } = validateExtensions(files, config.extensions);
+      if (invalid.length > 0) {
+        console.error(chalk2.red("Invalid file types:"));
+        for (const file of invalid) {
+          console.error(chalk2.red(`  - ${file}`));
+        }
+      }
+      if (valid.length === 0) {
+        process.exit(1);
+      }
+      const result = await runGUI(valid[0]);
+      process.exit(result ? 0 : 1);
+    }
+    const success2 = await runToolOnFiles(
+      "border",
+      files,
+      options.yes ?? false
+    );
+    process.exit(success2 ? 0 : 1);
+  });
+}
+
+// src/cli/commands/config.ts
+import chalk3 from "chalk";
+function registerConfigCommand(program2) {
+  const configCmd = program2.command("config").description("Display current settings").action(() => {
+    const config12 = loadConfig();
+    console.log(chalk3.white.bold("\n  PicLet Configuration"));
+    console.log(chalk3.gray(`  ${getConfigPath()}
+`));
+    console.log(JSON.stringify(config12, null, 2));
+    console.log();
+  });
+  configCmd.command("reset").description("Restore defaults").action(() => {
+    resetConfig();
+    console.log(chalk3.green("Configuration reset to defaults."));
+  });
+}
+
+// src/cli/commands/extract-frames.ts
+import chalk4 from "chalk";
+function registerExtractFramesCommand(program2) {
+  program2.command("extract-frames <files...>").alias("frames").description("Extract frames from animated GIF").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use GUI for options").action(async (files, options) => {
+    if (options.gui) {
+      const { valid, invalid } = validateExtensions(files, config2.extensions);
+      if (invalid.length > 0) {
+        console.error(chalk4.red("Invalid file types:"));
+        for (const file of invalid) {
+          console.error(chalk4.red(`  - ${file}`));
+        }
+      }
+      if (valid.length === 0) {
+        process.exit(1);
+      }
+      const result = await runGUI2(valid[0]);
+      process.exit(result ? 0 : 1);
+    }
+    const success2 = await runToolOnFiles(
+      "extract-frames",
+      files,
+      options.yes ?? false
+    );
+    process.exit(success2 ? 0 : 1);
+  });
+}
+
+// src/cli/commands/filter.ts
+import chalk5 from "chalk";
+function registerFilterCommand(program2) {
+  program2.command("filter <files...>").description("Apply color filters (grayscale, sepia, etc.)").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use GUI for options").action(async (files, options) => {
+    if (options.gui) {
+      const { valid, invalid } = validateExtensions(files, config3.extensions);
+      if (invalid.length > 0) {
+        console.error(chalk5.red("Invalid file types:"));
+        for (const file of invalid) {
+          console.error(chalk5.red(`  - ${file}`));
+        }
+      }
+      if (valid.length === 0) {
+        process.exit(1);
+      }
+      const result = await runGUI3(valid[0]);
+      process.exit(result ? 0 : 1);
+    }
+    const success2 = await runToolOnFiles(
+      "filter",
+      files,
+      options.yes ?? false
+    );
+    process.exit(success2 ? 0 : 1);
+  });
+}
+
+// src/cli/commands/help.ts
+function registerHelpCommand(program2) {
+  program2.command("help").description("Show help").action(() => {
+    showHelp();
+  });
+}
+
 // src/cli/commands/iconpack.ts
+import chalk6 from "chalk";
 function registerIconpackCommand(program2) {
   program2.command("iconpack <files...>").description("Generate icon sets for Web, Android, iOS").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use GUI for options").action(async (files, options) => {
     if (options.gui) {
-      const { valid, invalid } = validateExtensions(files, config.extensions);
+      const { valid, invalid } = validateExtensions(files, config4.extensions);
       if (invalid.length > 0) {
-        console.error(chalk3.red("Invalid file types:"));
+        console.error(chalk6.red("Invalid file types:"));
         for (const file of invalid) {
-          console.error(chalk3.red(`  - ${file}`));
+          console.error(chalk6.red(`  - ${file}`));
         }
       }
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI(valid[0]);
+      const result = await runGUI4(valid[0]);
       process.exit(result ? 0 : 1);
     }
     const success2 = await runToolOnFiles(
@@ -2677,11 +4192,11 @@ function registerIconpackCommand(program2) {
 }
 
 // src/cli/commands/install.ts
-import chalk4 from "chalk";
+import chalk7 from "chalk";
 
 // src/lib/registry.ts
 import { exec as exec2 } from "child_process";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { dirname as dirname10 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { promisify as promisify2 } from "util";
@@ -2690,7 +4205,7 @@ function isWSL() {
   return process.platform === "linux" && (process.env.WSL_DISTRO_NAME !== void 0 || process.env.WSLENV !== void 0);
 }
 function isWSLInteropEnabled() {
-  return existsSync10("/proc/sys/fs/binfmt_misc/WSLInterop");
+  return existsSync15("/proc/sys/fs/binfmt_misc/WSLInterop");
 }
 async function addRegistryKey(keyPath, valueName, value, type = "REG_SZ") {
   const valueArg = valueName ? `/v "${valueName}"` : "/ve";
@@ -2732,7 +4247,7 @@ async function deleteRegistryKey(keyPath) {
 
 // src/cli/registry.ts
 import { writeFile } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join14 } from "path";
 async function registerUnifiedMenu(extension, iconsDir, launcherPath) {
   const basePath = `HKCU\\Software\\Classes\\SystemFileAssociations\\${extension}\\shell\\PicLet`;
   const iconsDirWin = wslToWindows(iconsDir);
@@ -2752,13 +4267,13 @@ async function unregisterMenuForExtension(extension) {
   const results = [];
   const basePath = getMenuBasePath(extension);
   const extensionTools = getToolsForExtension(extension);
-  for (const { config: config7 } of extensionTools) {
-    const toolPath = `${basePath}\\shell\\${config7.id}`;
+  for (const { config: config12 } of extensionTools) {
+    const toolPath = `${basePath}\\shell\\${config12.id}`;
     await deleteRegistryKey(`${toolPath}\\command`);
     const success2 = await deleteRegistryKey(toolPath);
     results.push({
       extension,
-      toolName: config7.name,
+      toolName: config12.name,
       success: success2
     });
   }
@@ -2768,8 +4283,8 @@ async function unregisterMenuForExtension(extension) {
 }
 async function registerAllTools() {
   const distDir = getDistDir();
-  const iconsDir = join9(distDir, "icons");
-  const launcherPath = join9(distDir, "launcher.vbs");
+  const iconsDir = join14(distDir, "icons");
+  const launcherPath = join14(distDir, "launcher.vbs");
   const results = [];
   for (const extension of picletTool.config.extensions) {
     const result = await registerUnifiedMenu(extension, iconsDir, launcherPath);
@@ -2777,6 +4292,57 @@ async function registerAllTools() {
   }
   return results;
 }
+var LEGACY_TOOL_NAMES = [
+  // Old direct menu items (various naming conventions)
+  "Scale Image",
+  "Resize Image",
+  "Eale Image",
+  // Corrupted entry
+  "Remove Background",
+  "Remove BG",
+  "RemoveBG",
+  "Make Icon",
+  "MakeIcon",
+  "Icon Pack",
+  "IconPack",
+  "Store Pack",
+  "StorePack",
+  "PicLet - Scale",
+  "PicLet - Remove BG",
+  "PicLet - Make Icon",
+  "PicLet - Icon Pack",
+  "PicLet Scale",
+  "PicLet RemoveBG",
+  // Tool IDs that might have been used as menu names
+  "makeicon",
+  "remove-bg",
+  "removebg",
+  "rescale",
+  "scale",
+  "iconpack",
+  "storepack",
+  "transform",
+  "filter",
+  "border",
+  "recolor"
+];
+var ALL_IMAGE_EXTENSIONS = [".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".webp", ".tiff", ".tif"];
+async function cleanupLegacyEntries() {
+  const removed = [];
+  const failed = [];
+  for (const ext of ALL_IMAGE_EXTENSIONS) {
+    const shellBase = `HKCU\\Software\\Classes\\SystemFileAssociations\\${ext}\\shell`;
+    for (const legacyName of LEGACY_TOOL_NAMES) {
+      const keyPath = `${shellBase}\\${legacyName}`;
+      await deleteRegistryKey(`${keyPath}\\command`);
+      const success2 = await deleteRegistryKey(keyPath);
+      if (success2) {
+        removed.push(`${ext} \u2192 ${legacyName}`);
+      }
+    }
+  }
+  return { removed, failed };
+}
 async function unregisterAllTools() {
   const results = [];
   const allExts = /* @__PURE__ */ new Set([...getAllExtensions(), ...picletTool.config.extensions]);
@@ -2794,8 +4360,8 @@ function escapeRegValue(value) {
 }
 function generateRegContent() {
   const distDir = getDistDir();
-  const iconsDir = join9(distDir, "icons");
-  const launcherPath = join9(distDir, "launcher.vbs");
+  const iconsDir = join14(distDir, "icons");
+  const launcherPath = join14(distDir, "launcher.vbs");
   const iconsDirWin = wslToWindows(iconsDir);
   const launcherWin = wslToWindows(launcherPath);
   const lines = ["Windows Registry Editor Version 5.00", ""];
@@ -2821,18 +4387,25 @@ function generateUninstallRegContent() {
     lines.push(`[-${basePath}]`);
     lines.push("");
   }
+  for (const ext of ALL_IMAGE_EXTENSIONS) {
+    for (const legacyName of LEGACY_TOOL_NAMES) {
+      const keyPath = `HKEY_CURRENT_USER\\Software\\Classes\\SystemFileAssociations\\${ext}\\shell\\${legacyName}`;
+      lines.push(`[-${keyPath}]`);
+    }
+    lines.push("");
+  }
   return lines.join("\r\n");
 }
 async function generateRegFile() {
   const distDir = getDistDir();
-  const regPath = join9(distDir, "piclet-install.reg");
+  const regPath = join14(distDir, "piclet-install.reg");
   const content = generateRegContent();
   await writeFile(regPath, content, "utf-8");
   return regPath;
 }
 async function generateUninstallRegFile() {
   const distDir = getDistDir();
-  const regPath = join9(distDir, "piclet-uninstall.reg");
+  const regPath = join14(distDir, "piclet-uninstall.reg");
   const content = generateUninstallRegContent();
   await writeFile(regPath, content, "utf-8");
   return regPath;
@@ -2842,50 +4415,50 @@ async function generateUninstallRegFile() {
 function registerInstallCommand(program2) {
   program2.command("install").description("Install Windows shell context menu integration").action(async () => {
     showBanner();
-    console.log(chalk4.bold("Installing...\n"));
+    console.log(chalk7.bold("Installing...\n"));
     if (!isWSL()) {
       console.log(
-        chalk4.yellow("! Not running in WSL. Registry integration skipped.")
+        chalk7.yellow("! Not running in WSL. Registry integration skipped.")
       );
       console.log(
-        chalk4.yellow('! Run "piclet install" from WSL to add context menu.')
+        chalk7.yellow('! Run "piclet install" from WSL to add context menu.')
       );
       return;
     }
     if (!isWSLInteropEnabled()) {
-      console.log(chalk4.yellow("WSL Interop not available. Generating registry file...\n"));
+      console.log(chalk7.yellow("WSL Interop not available. Generating registry file...\n"));
       const regPath = await generateRegFile();
       const winPath = wslToWindows(regPath);
-      console.log(chalk4.green("\u2713 Generated registry file:"));
-      console.log(chalk4.cyan(`  ${winPath}
+      console.log(chalk7.green("\u2713 Generated registry file:"));
+      console.log(chalk7.cyan(`  ${winPath}
 `));
-      console.log(chalk4.bold("To install, either:"));
-      console.log(chalk4.dim("  1. Double-click the .reg file in Windows Explorer"));
-      console.log(chalk4.dim(`  2. Run in elevated PowerShell: reg import "${winPath}"`));
+      console.log(chalk7.bold("To install, either:"));
+      console.log(chalk7.dim("  1. Double-click the .reg file in Windows Explorer"));
+      console.log(chalk7.dim(`  2. Run in elevated PowerShell: reg import "${winPath}"`));
       console.log();
       return;
     }
-    console.log(chalk4.dim("Removing old entries..."));
+    console.log(chalk7.dim("Removing old entries..."));
     await unregisterAllTools();
     console.log();
     const results = await registerAllTools();
     const allSuccess = results.every((r) => r.success);
-    for (const { config: config7 } of tools) {
-      const extList = config7.extensions.join(", ");
-      console.log(`${chalk4.green("\u2713")} ${config7.name} ${chalk4.dim(`[${extList}]`)}`);
+    for (const { config: config12 } of tools) {
+      const extList = config12.extensions.join(", ");
+      console.log(`${chalk7.green("\u2713")} ${config12.name} ${chalk7.dim(`[${extList}]`)}`);
     }
     console.log();
     if (allSuccess) {
       console.log(
-        chalk4.green(`\u2713 Registered ${tools.length} tools for context menu.`)
+        chalk7.green(`\u2713 Registered ${tools.length} tools for context menu.`)
       );
     } else {
       const successCount = results.filter((r) => r.success).length;
       console.log(
-        chalk4.yellow(`! Registered ${successCount}/${results.length} entries.`)
+        chalk7.yellow(`! Registered ${successCount}/${results.length} entries.`)
       );
     }
-    console.log(chalk4.bold("\nUsage:"));
+    console.log(chalk7.bold("\nUsage:"));
     console.log("  Right-click any supported image in Windows Explorer.");
     console.log("  Multi-select supported for batch processing.");
     console.log();
@@ -2893,21 +4466,21 @@ function registerInstallCommand(program2) {
 }
 
 // src/cli/commands/makeicon.ts
-import chalk5 from "chalk";
+import chalk8 from "chalk";
 function registerMakeiconCommand(program2) {
   program2.command("makeicon <files...>").description("Convert PNG to multi-resolution ICO file").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use GUI for confirmation").action(async (files, options) => {
     if (options.gui) {
-      const { valid, invalid } = validateExtensions(files, config2.extensions);
+      const { valid, invalid } = validateExtensions(files, config5.extensions);
       if (invalid.length > 0) {
-        console.error(chalk5.red("Invalid file types:"));
+        console.error(chalk8.red("Invalid file types:"));
         for (const file of invalid) {
-          console.error(chalk5.red(`  - ${file}`));
+          console.error(chalk8.red(`  - ${file}`));
         }
       }
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI2(valid[0]);
+      const result = await runGUI5(valid[0]);
       process.exit(result ? 0 : 1);
     }
     const success2 = await runToolOnFiles(
@@ -2920,13 +4493,13 @@ function registerMakeiconCommand(program2) {
 }
 
 // src/cli/commands/piclet.ts
-import chalk6 from "chalk";
+import chalk9 from "chalk";
 function registerPicletCommand(program2) {
   program2.command("piclet <file>").description("Open unified PicLet window with all tools").option("-g, --gui", "Use GUI (default)").action(async (file) => {
     const { valid, invalid } = validateExtensions([file], picletTool.config.extensions);
     if (invalid.length > 0) {
-      console.error(chalk6.red(`Invalid file type: ${file}`));
-      console.error(chalk6.yellow(`Supported: ${picletTool.config.extensions.join(", ")}`));
+      console.error(chalk9.red(`Invalid file type: ${file}`));
+      console.error(chalk9.yellow(`Supported: ${picletTool.config.extensions.join(", ")}`));
       process.exit(1);
     }
     const result = await picletTool.runGUI(valid[0]);
@@ -2934,22 +4507,49 @@ function registerPicletCommand(program2) {
   });
 }
 
+// src/cli/commands/recolor.ts
+import chalk10 from "chalk";
+function registerRecolorCommand(program2) {
+  program2.command("recolor <files...>").alias("replace-color").description("Replace one color with another").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use GUI for options").action(async (files, options) => {
+    if (options.gui) {
+      const { valid, invalid } = validateExtensions(files, config7.extensions);
+      if (invalid.length > 0) {
+        console.error(chalk10.red("Invalid file types:"));
+        for (const file of invalid) {
+          console.error(chalk10.red(`  - ${file}`));
+        }
+      }
+      if (valid.length === 0) {
+        process.exit(1);
+      }
+      const result = await runGUI7(valid[0]);
+      process.exit(result ? 0 : 1);
+    }
+    const success2 = await runToolOnFiles(
+      "recolor",
+      files,
+      options.yes ?? false
+    );
+    process.exit(success2 ? 0 : 1);
+  });
+}
+
 // src/cli/commands/remove-bg.ts
-import chalk7 from "chalk";
+import chalk11 from "chalk";
 function registerRemoveBgCommand(program2) {
   program2.command("remove-bg <files...>").alias("removebg").description("Remove solid background from image").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use TUI (terminal GUI) for options").option("-f, --fuzz <percent>", "Fuzz tolerance 0-100 (default: 10)").option("-t, --trim", "Trim transparent edges (default: true)").option("--no-trim", "Do not trim transparent edges").option("-p, --preserve-inner", "Preserve inner areas of same color").option("-s, --square", "Make output square with padding").action(async (files, options) => {
     if (options.gui) {
-      const { valid, invalid } = validateExtensions(files, config4.extensions);
+      const { valid, invalid } = validateExtensions(files, config8.extensions);
       if (invalid.length > 0) {
-        console.error(chalk7.red("Invalid file types:"));
+        console.error(chalk11.red("Invalid file types:"));
         for (const file of invalid) {
-          console.error(chalk7.red(`  - ${file}`));
+          console.error(chalk11.red(`  - ${file}`));
         }
       }
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI4(valid[0]);
+      const result = await runGUI8(valid[0]);
       process.exit(result ? 0 : 1);
     }
     if (options.fuzz !== void 0) {
@@ -2975,21 +4575,21 @@ function registerRemoveBgCommand(program2) {
 }
 
 // src/cli/commands/scale.ts
-import chalk8 from "chalk";
+import chalk12 from "chalk";
 function registerScaleCommand(program2) {
   program2.command("scale <files...>").alias("rescale").description("Resize image with optional padding").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use GUI for options").action(async (files, options) => {
     if (options.gui) {
-      const { valid, invalid } = validateExtensions(files, config5.extensions);
+      const { valid, invalid } = validateExtensions(files, config9.extensions);
       if (invalid.length > 0) {
-        console.error(chalk8.red("Invalid file types:"));
+        console.error(chalk12.red("Invalid file types:"));
         for (const file of invalid) {
-          console.error(chalk8.red(`  - ${file}`));
+          console.error(chalk12.red(`  - ${file}`));
         }
       }
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI5(valid[0]);
+      const result = await runGUI9(valid[0]);
       process.exit(result ? 0 : 1);
     }
     const success2 = await runToolOnFiles(
@@ -3002,21 +4602,21 @@ function registerScaleCommand(program2) {
 }
 
 // src/cli/commands/storepack.ts
-import chalk9 from "chalk";
+import chalk13 from "chalk";
 function registerStorepackCommand(program2) {
   program2.command("storepack <files...>").description("Generate assets for app stores (Windows, Unity, Steam, etc.)").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use GUI for options").action(async (files, options) => {
     if (options.gui) {
-      const { valid, invalid } = validateExtensions(files, config6.extensions);
+      const { valid, invalid } = validateExtensions(files, config10.extensions);
       if (invalid.length > 0) {
-        console.error(chalk9.red("Invalid file types:"));
+        console.error(chalk13.red("Invalid file types:"));
         for (const file of invalid) {
-          console.error(chalk9.red(`  - ${file}`));
+          console.error(chalk13.red(`  - ${file}`));
         }
       }
       if (valid.length === 0) {
         process.exit(1);
       }
-      const result = await runGUI6(valid[0]);
+      const result = await runGUI10(valid[0]);
       process.exit(result ? 0 : 1);
     }
     const success2 = await runToolOnFiles(
@@ -3028,67 +4628,104 @@ function registerStorepackCommand(program2) {
   });
 }
 
+// src/cli/commands/transform.ts
+import chalk14 from "chalk";
+function registerTransformCommand(program2) {
+  program2.command("transform <files...>").alias("flip").description("Flip or rotate images").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use GUI for options").action(async (files, options) => {
+    if (options.gui) {
+      const { valid, invalid } = validateExtensions(files, config11.extensions);
+      if (invalid.length > 0) {
+        console.error(chalk14.red("Invalid file types:"));
+        for (const file of invalid) {
+          console.error(chalk14.red(`  - ${file}`));
+        }
+      }
+      if (valid.length === 0) {
+        process.exit(1);
+      }
+      const result = await runGUI11(valid[0]);
+      process.exit(result ? 0 : 1);
+    }
+    const success2 = await runToolOnFiles(
+      "transform",
+      files,
+      options.yes ?? false
+    );
+    process.exit(success2 ? 0 : 1);
+  });
+}
+
 // src/cli/commands/uninstall.ts
-import chalk10 from "chalk";
+import chalk15 from "chalk";
 function registerUninstallCommand(program2) {
   program2.command("uninstall").description("Remove Windows shell context menu integration").action(async () => {
     showBanner();
-    console.log(chalk10.bold("Uninstalling...\n"));
+    console.log(chalk15.bold("Uninstalling...\n"));
     if (!isWSL()) {
       console.log(
-        chalk10.yellow("! Not running in WSL. Registry cleanup skipped.")
+        chalk15.yellow("! Not running in WSL. Registry cleanup skipped.")
       );
       console.log(
-        chalk10.yellow(
+        chalk15.yellow(
           '! Run "piclet uninstall" from WSL to remove context menu.'
         )
       );
       return;
     }
     if (!isWSLInteropEnabled()) {
-      console.log(chalk10.yellow("WSL Interop not available. Generating registry file...\n"));
+      console.log(chalk15.yellow("WSL Interop not available. Generating registry file...\n"));
       const regPath = await generateUninstallRegFile();
       const winPath = wslToWindows(regPath);
-      console.log(chalk10.green("\u2713 Generated uninstall registry file:"));
-      console.log(chalk10.cyan(`  ${winPath}
+      console.log(chalk15.green("\u2713 Generated uninstall registry file:"));
+      console.log(chalk15.cyan(`  ${winPath}
 `));
-      console.log(chalk10.bold("To uninstall, either:"));
-      console.log(chalk10.dim("  1. Double-click the .reg file in Windows Explorer"));
-      console.log(chalk10.dim(`  2. Run in elevated PowerShell: reg import "${winPath}"`));
+      console.log(chalk15.bold("To uninstall, either:"));
+      console.log(chalk15.dim("  1. Double-click the .reg file in Windows Explorer"));
+      console.log(chalk15.dim(`  2. Run in elevated PowerShell: reg import "${winPath}"`));
       console.log();
       return;
     }
+    console.log(chalk15.dim("Cleaning up legacy entries...\n"));
+    const legacyResult = await cleanupLegacyEntries();
+    if (legacyResult.removed.length > 0) {
+      console.log(chalk15.yellow(`Removed ${legacyResult.removed.length} legacy entries:`));
+      for (const entry of legacyResult.removed) {
+        console.log(`  ${chalk15.green("\u2713")} ${entry}`);
+      }
+      console.log();
+    }
     const results = await unregisterAllTools();
     const removedCount = results.filter((r) => r.success).length;
     for (const result of results) {
       if (result.success) {
         console.log(
-          `${chalk10.green("\u2713")} Removed: ${result.extension} \u2192 ${result.toolName}`
+          `${chalk15.green("\u2713")} Removed: ${result.extension} \u2192 ${result.toolName}`
         );
       } else {
         console.log(
-          `${chalk10.gray("-")} Skipped: ${result.extension} \u2192 ${result.toolName}`
+          `${chalk15.gray("-")} Skipped: ${result.extension} \u2192 ${result.toolName}`
         );
       }
     }
+    const totalRemoved = removedCount + legacyResult.removed.length;
     console.log();
     console.log(
-      chalk10.green(
-        `\u2713 Cleanup complete. Removed ${removedCount}/${results.length} entries.`
+      chalk15.green(
+        `\u2713 Cleanup complete. Removed ${totalRemoved} entries total.`
       )
     );
-    console.log(chalk10.dim("\nThanks for using PicLet!\n"));
+    console.log(chalk15.dim("\nThanks for using PicLet!\n"));
   });
 }
 
 // src/cli/index.ts
 function showHelp() {
   showBanner();
-  const dim = chalk11.gray;
-  const cmd = chalk11.cyan;
-  const arg = chalk11.yellow;
-  const opt = chalk11.green;
-  const head = chalk11.white.bold;
+  const dim = chalk16.gray;
+  const cmd = chalk16.cyan;
+  const arg = chalk16.yellow;
+  const opt = chalk16.green;
+  const head = chalk16.white.bold;
   console.log(
     `  ${head("Usage:")} piclet ${cmd("<command>")} ${arg("<file>")} ${opt("[options]")}`
   );
@@ -3108,6 +4745,21 @@ function showHelp() {
   console.log(
     `    ${cmd("scale")} ${arg("<file>")}      Resize image with optional padding`
   );
+  console.log(
+    `    ${cmd("transform")} ${arg("<file>")}  Flip or rotate images`
+  );
+  console.log(
+    `    ${cmd("filter")} ${arg("<file>")}     Apply color filters (grayscale, sepia)`
+  );
+  console.log(
+    `    ${cmd("border")} ${arg("<file>")}     Add solid color border`
+  );
+  console.log(
+    `    ${cmd("recolor")} ${arg("<file>")}    Replace one color with another`
+  );
+  console.log(
+    `    ${cmd("frames")} ${arg("<file>")}      Extract frames from animated GIF`
+  );
   console.log(
     `    ${cmd("iconpack")} ${arg("<file>")}   Generate icon sets for Web/Android/iOS`
   );
@@ -3152,6 +4804,11 @@ function createProgram() {
   registerMakeiconCommand(program2);
   registerRemoveBgCommand(program2);
   registerScaleCommand(program2);
+  registerTransformCommand(program2);
+  registerFilterCommand(program2);
+  registerBorderCommand(program2);
+  registerRecolorCommand(program2);
+  registerExtractFramesCommand(program2);
   registerIconpackCommand(program2);
   registerStorepackCommand(program2);
   registerPicletCommand(program2);
@@ -3162,7 +4819,7 @@ function createProgram() {
 // src/cli.ts
 var program = createProgram();
 program.parseAsync(process.argv).catch((error2) => {
-  console.error(chalk12.red(`Error: ${error2.message}`));
+  console.error(chalk17.red(`Error: ${error2.message}`));
   process.exit(1);
 });
 //# sourceMappingURL=cli.js.map