@spark-apps/piclet 1.0.3 → 1.0.4

package/dist/cli.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/cli.ts
 import chalk17 from "chalk";
@@ -340,6 +346,58 @@ function startGuiServer(options) {
         res.json({ success: false, error: err.message });
       }
     });
+    app.post("/api/simplify-gif", async (req, res) => {
+      if (!options.onSimplifyGif) {
+        res.json({ success: false, error: "GIF simplification not supported" });
+        return;
+      }
+      try {
+        const skipFactor = req.body.skipFactor ?? 2;
+        const result = await options.onSimplifyGif(skipFactor);
+        if (result.success) {
+          options.imageInfo.filePath = result.filePath;
+          options.imageInfo.fileName = result.fileName;
+          options.imageInfo.width = result.width;
+          options.imageInfo.height = result.height;
+          options.imageInfo.frameCount = result.frameCount;
+        }
+        res.json(result);
+      } catch (err) {
+        res.json({ success: false, error: err.message });
+      }
+    });
+    app.post("/api/delete-frame", async (req, res) => {
+      if (!options.onDeleteFrame) {
+        res.json({ success: false, error: "Frame deletion not supported" });
+        return;
+      }
+      try {
+        const frameIndex = req.body.frameIndex;
+        const result = await options.onDeleteFrame(frameIndex);
+        if (result.success) {
+          options.imageInfo.frameCount = result.frameCount;
+        }
+        res.json(result);
+      } catch (err) {
+        res.json({ success: false, error: err.message });
+      }
+    });
+    app.post("/api/replace-frame", async (req, res) => {
+      if (!options.onReplaceFrame) {
+        res.json({ success: false, error: "Frame replacement not supported" });
+        return;
+      }
+      try {
+        const { frameIndex, imageData } = req.body;
+        const result = await options.onReplaceFrame(frameIndex, imageData);
+        if (result.success) {
+          options.imageInfo.frameCount = result.frameCount;
+        }
+        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" });
@@ -359,6 +417,11 @@ function startGuiServer(options) {
       try {
         const result = await options.onProcess(req.body);
         processResult = result.success;
+        if (result.outputPath) {
+          options.lastOutputPath = result.outputPath;
+        } else {
+          options.lastOutputPath = void 0;
+        }
         res.json(result);
       } catch (err) {
         processResult = false;
@@ -436,8 +499,41 @@ function startGuiServer(options) {
       }).unref();
       res.json({ success: true });
     });
+    app.get("/api/output-preview", (_req, res) => {
+      const outputPath = options.lastOutputPath;
+      if (!outputPath) {
+        res.json({ success: false, error: "No output file" });
+        return;
+      }
+      try {
+        const fs = __require("fs");
+        const path = __require("path");
+        if (!fs.existsSync(outputPath)) {
+          res.json({ success: false, error: "Output file not found" });
+          return;
+        }
+        const buffer = fs.readFileSync(outputPath);
+        const ext = path.extname(outputPath).toLowerCase();
+        const mimeTypes = {
+          ".png": "image/png",
+          ".jpg": "image/jpeg",
+          ".jpeg": "image/jpeg",
+          ".gif": "image/gif",
+          ".ico": "image/x-icon"
+        };
+        const mimeType = mimeTypes[ext] || "image/png";
+        res.json({
+          success: true,
+          imageData: `data:${mimeType};base64,${buffer.toString("base64")}`,
+          isGif: ext === ".gif"
+        });
+      } catch (err) {
+        res.json({ success: false, error: err.message });
+      }
+    });
     app.post("/api/open-folder", (_req, res) => {
-      const filePath = options.imageInfo.filePath;
+      const outputPath = options.lastOutputPath;
+      const filePath = outputPath || options.imageInfo.filePath;
       let winPath = filePath;
       const wslMatch = filePath.match(/^\/mnt\/([a-z])\/(.*)$/);
       if (wslMatch) {
@@ -445,8 +541,10 @@ function startGuiServer(options) {
         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}"`], {
+      const lastSep = Math.max(winPath.lastIndexOf("\\"), winPath.lastIndexOf("/"));
+      const dir = lastSep > 0 ? winPath.substring(0, lastSep) : winPath;
+      const explorerCmd = outputPath ? `explorer.exe /select,"${winPath}"` : `explorer.exe "${dir}"`;
+      spawn("powershell.exe", ["-WindowStyle", "Hidden", "-Command", explorerCmd], {
         detached: true,
         stdio: "ignore",
         windowsHide: true
@@ -549,7 +647,7 @@ function isGif(imagePath) {
   return imagePath.toLowerCase().endsWith(".gif");
 }
 function getGifOutputSuffix(outputPath) {
-  return isGif(outputPath) ? " -layers Optimize" : "";
+  return isGif(outputPath) ? " -dispose Background -layers OptimizePlus" : "";
 }
 function getCoalescePrefix(inputPath) {
   return isGif(inputPath) ? "-coalesce " : "";
@@ -688,6 +786,20 @@ async function removeBackgroundBorderOnly(inputPath, outputPath, color, fuzz) {
     return false;
   }
 }
+async function removeBackgroundEdgeAware(inputPath, outputPath, color, fuzz, featherAmount = 50) {
+  if (isGif(inputPath)) {
+    return removeBackgroundBorderOnly(inputPath, outputPath, color, fuzz);
+  }
+  try {
+    const featherRadius = 0.5 + featherAmount / 100 * 2.5;
+    await execAsync(
+      `convert "${inputPath}" -bordercolor "${color}" -border 1x1 -fill none -fuzz ${fuzz}% -draw "matte 0,0 floodfill" -shave 1x1 \\( +clone -alpha extract -blur 0x${featherRadius} \\) -compose CopyOpacity -composite "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return removeBackgroundBorderOnly(inputPath, outputPath, color, fuzz);
+  }
+}
 async function createIco(inputPath, outputPath, sizes = [256, 128, 64, 48, 32, 16]) {
   try {
     const sizeStr = sizes.join(",");
@@ -736,7 +848,13 @@ async function extractFirstFrame(inputPath, outputPath, frameIndex = 0) {
   }
   try {
     if (lowerPath.endsWith(".gif")) {
-      await execAsync(`convert "${inputPath}" -coalesce miff:- | convert "miff:-[${frameIndex}]" "${outputPath}"`);
+      if (frameIndex === 0) {
+        await execAsync(`convert "${inputPath}[0]" "${outputPath}"`);
+      } else {
+        await execAsync(
+          `convert "${inputPath}[0-${frameIndex}]" -coalesce -delete 0--2 "${outputPath}"`
+        );
+      }
     } else {
       await execAsync(`convert "${inputPath}[${frameIndex}]" "${outputPath}"`);
     }
@@ -764,7 +882,7 @@ async function extractAllFrames(inputPath, outputDir, baseName) {
   try {
     ensureDir(`${outputDir}/dummy`);
     await execAsync(
-      `convert "${inputPath}" -coalesce "${outputDir}/${baseName}-%04d.png"`
+      `convert "${inputPath}" -coalesce +adjoin "${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);
@@ -893,6 +1011,93 @@ async function replaceColor(inputPath, outputPath, fromColor, toColor, fuzz) {
     return false;
   }
 }
+async function deleteGifFrame(inputPath, outputPath, frameIndex) {
+  try {
+    const originalCount = await getFrameCount(inputPath);
+    if (originalCount <= 1) {
+      return { success: false };
+    }
+    if (frameIndex < 0 || frameIndex >= originalCount) {
+      return { success: false };
+    }
+    await execAsync(
+      `convert "${inputPath}" -coalesce -delete ${frameIndex} -dispose Background -layers OptimizePlus "${outputPath}"`
+    );
+    const newCount = await getFrameCount(outputPath);
+    return { success: true, frameCount: newCount };
+  } catch {
+    return { success: false };
+  }
+}
+async function replaceGifFrame(inputPath, outputPath, frameIndex, replacementPath) {
+  try {
+    const frameCount = await getFrameCount(inputPath);
+    if (frameIndex < 0 || frameIndex >= frameCount) {
+      return { success: false };
+    }
+    const dims = await getDimensions(inputPath);
+    if (!dims) return { success: false };
+    const tempReplacement = `${outputPath}.tmp.png`;
+    await execAsync(
+      `convert "${replacementPath}" -resize ${dims[0]}x${dims[1]}^ -gravity center -extent ${dims[0]}x${dims[1]} "${tempReplacement}"`
+    );
+    if (frameIndex === 0) {
+      await execAsync(
+        `convert "${tempReplacement}" \\( "${inputPath}" -coalesce \\) -delete 1 -dispose Background -layers OptimizePlus "${outputPath}"`
+      );
+    } else if (frameIndex === frameCount - 1) {
+      await execAsync(
+        `convert \\( "${inputPath}" -coalesce -delete -1 \\) "${tempReplacement}" -dispose Background -layers OptimizePlus "${outputPath}"`
+      );
+    } else {
+      await execAsync(
+        `convert \\( "${inputPath}" -coalesce \\) -delete ${frameIndex} "${outputPath}.frames.gif" && convert "${outputPath}.frames.gif[0-${frameIndex - 1}]" "${tempReplacement}" "${outputPath}.frames.gif[${frameIndex}-]" -dispose Background -layers OptimizePlus "${outputPath}" && rm -f "${outputPath}.frames.gif"`
+      );
+    }
+    try {
+      unlinkSync(tempReplacement);
+    } catch {
+    }
+    const newCount = await getFrameCount(outputPath);
+    return { success: true, frameCount: newCount };
+  } catch {
+    return { success: false };
+  }
+}
+async function simplifyGif(inputPath, outputPath, skipFactor) {
+  if (skipFactor < 2) {
+    if (inputPath !== outputPath) {
+      try {
+        copyFileSync(inputPath, outputPath);
+        const count2 = await getFrameCount(outputPath);
+        return { success: true, frameCount: count2 };
+      } catch {
+        return { success: false };
+      }
+    }
+    const count = await getFrameCount(inputPath);
+    return { success: true, frameCount: count };
+  }
+  try {
+    const originalCount = await getFrameCount(inputPath);
+    if (originalCount <= 1) {
+      copyFileSync(inputPath, outputPath);
+      return { success: true, frameCount: 1 };
+    }
+    const frameIndices = [];
+    for (let i = 0; i < originalCount; i += skipFactor) {
+      frameIndices.push(i);
+    }
+    const keepPattern = frameIndices.join(",");
+    await execAsync(
+      `convert "${inputPath}[${keepPattern}]" -coalesce -dispose Background -layers OptimizePlus "${outputPath}"`
+    );
+    const newCount = await getFrameCount(outputPath);
+    return { success: true, frameCount: newCount };
+  } catch {
+    return { success: false };
+  }
+}
 
 // src/lib/paths.ts
 import { basename, dirname as dirname4, extname, resolve } from "path";
@@ -2161,7 +2366,9 @@ async function generateCombinedPreview(input, borderColor, opts) {
           const rbOpts = opts.removebg;
           const out = makeTempPath("removebg");
           let success2 = false;
-          if (rbOpts.preserveInner && borderColor) {
+          if (rbOpts.edgeDetect && borderColor) {
+            success2 = await removeBackgroundEdgeAware(current, out, borderColor, rbOpts.fuzz, rbOpts.edgeStrength);
+          } else if (rbOpts.preserveInner && borderColor) {
             success2 = await removeBackgroundBorderOnly(current, out, borderColor, rbOpts.fuzz);
           }
           if (!success2 && borderColor) {
@@ -2245,6 +2452,7 @@ async function processCombined(input, borderColor, opts, logs) {
   const fileInfo = getFileInfo(input);
   const outputs = [];
   const temps = [];
+  let singleFilePath;
   const outputExt = fileInfo.extension.toLowerCase() === ".gif" ? ".gif" : ".png";
   const makeTempPath = (suffix) => {
     const p = `${fileInfo.dirname}/${fileInfo.filename}_${suffix}${outputExt}`;
@@ -2260,7 +2468,13 @@ async function processCombined(input, borderColor, opts, logs) {
         const rbOpts = opts.removebg;
         const out = makeTempPath("nobg");
         let success2 = false;
-        if (rbOpts.preserveInner && borderColor) {
+        if (rbOpts.edgeDetect && borderColor) {
+          logs.push({ type: "info", message: "Using edge feathering..." });
+          success2 = await removeBackgroundEdgeAware(current, out, borderColor, rbOpts.fuzz, rbOpts.edgeStrength);
+          if (!success2) {
+            logs.push({ type: "warn", message: "Edge feathering failed, trying standard removal" });
+          }
+        } else if (rbOpts.preserveInner && borderColor) {
           success2 = await removeBackgroundBorderOnly(current, out, borderColor, rbOpts.fuzz);
           if (!success2) {
             logs.push({ type: "warn", message: "Border-only failed, trying full removal" });
@@ -2272,7 +2486,7 @@ async function processCombined(input, borderColor, opts, logs) {
         if (!success2) {
           logs.push({ type: "error", message: "Background removal failed" });
           cleanup(...temps);
-          return [];
+          return { outputs: [] };
         }
         logs.push({ type: "success", message: "Background removed" });
         if (rbOpts.trim) {
@@ -2294,6 +2508,7 @@ async function processCombined(input, borderColor, opts, logs) {
           renameSync(current, finalOut);
           temps.splice(temps.indexOf(current), 1);
           outputs.push(basename7(finalOut));
+          singleFilePath = finalOut;
         }
         break;
       }
@@ -2311,7 +2526,7 @@ async function processCombined(input, borderColor, opts, logs) {
         if (!success2) {
           logs.push({ type: "error", message: "Scale failed" });
           cleanup(...temps);
-          return [];
+          return { outputs: [] };
         }
         const dims = await getDimensions(out);
         logs.push({ type: "success", message: `Scaled to ${dims?.[0]}\xD7${dims?.[1]}` });
@@ -2325,6 +2540,7 @@ async function processCombined(input, borderColor, opts, logs) {
           renameSync(current, finalOut);
           temps.splice(temps.indexOf(current), 1);
           outputs.push(basename7(finalOut));
+          singleFilePath = finalOut;
         }
         break;
       }
@@ -2333,7 +2549,7 @@ async function processCombined(input, borderColor, opts, logs) {
         const icOpts = opts.icons;
         if (!icOpts.ico && !icOpts.web && !icOpts.android && !icOpts.ios) {
           logs.push({ type: "error", message: "No output format selected" });
-          return [];
+          return { outputs: [] };
         }
         let iconSource = current;
         if (icOpts.trim && current === input) {
@@ -2358,7 +2574,7 @@ async function processCombined(input, borderColor, opts, logs) {
         if (!await scaleToSize(iconSource, srcTemp, maxSize)) {
           logs.push({ type: "error", message: "Failed to prepare icon source" });
           cleanup(...temps);
-          return [];
+          return { outputs: [] };
         }
         if (iconSource !== current && iconSource !== input) cleanup(iconSource);
         let totalCount = 0;
@@ -2443,7 +2659,7 @@ async function processCombined(input, borderColor, opts, logs) {
         const spOpts = opts.storepack;
         if (!spOpts.dimensions || spOpts.dimensions.length === 0) {
           logs.push({ type: "error", message: "No dimensions specified" });
-          return [];
+          return { outputs: [] };
         }
         const folderName = spOpts.presetName || "assets";
         const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_${folderName}`;
@@ -2472,7 +2688,7 @@ async function processCombined(input, borderColor, opts, logs) {
     }
   }
   cleanup(...temps);
-  return outputs;
+  return { outputs, singleFilePath };
 }
 async function runGUI6(inputRaw) {
   let currentInput = normalizePath(inputRaw);
@@ -2647,11 +2863,12 @@ async function runGUI6(inputRaw) {
           logs: [{ type: "error", message: "ImageMagick not found. Install: sudo apt install imagemagick" }]
         };
       }
-      const outputs = await processCombined(currentInput, currentBorderColor, toolOpts, logs);
-      if (outputs.length > 0) {
+      const result = await processCombined(currentInput, currentBorderColor, toolOpts, logs);
+      if (result.outputs.length > 0) {
         return {
           success: true,
-          output: outputs.join("\n"),
+          output: result.outputs.join("\n"),
+          outputPath: result.singleFilePath,
           logs
         };
       }
@@ -2691,6 +2908,64 @@ async function runGUI6(inputRaw) {
       const toolOpts = opts;
       if (!toolOpts.tools) toolOpts.tools = [];
       return generateFramePreview2(frameIndex, toolOpts);
+    },
+    onSimplifyGif: async (skipFactor) => {
+      try {
+        const tempPath = join7(tmpdir5(), `piclet-simplified-${Date.now()}.gif`);
+        const result = await simplifyGif(currentInput, tempPath, skipFactor);
+        if (!result.success) {
+          return { success: false, error: "Failed to simplify GIF" };
+        }
+        const newDims = await getDimensions(tempPath);
+        if (!newDims) {
+          cleanup(tempPath);
+          return { success: false, error: "Failed to read simplified GIF dimensions" };
+        }
+        currentInput = tempPath;
+        currentFrameCount = result.frameCount ?? 1;
+        return {
+          success: true,
+          filePath: tempPath,
+          fileName: basename7(currentInput),
+          width: newDims[0],
+          height: newDims[1],
+          frameCount: currentFrameCount
+        };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    },
+    onDeleteFrame: async (frameIndex) => {
+      try {
+        const tempPath = join7(tmpdir5(), `piclet-edited-${Date.now()}.gif`);
+        const result = await deleteGifFrame(currentInput, tempPath, frameIndex);
+        if (!result.success) {
+          return { success: false, error: "Failed to delete frame" };
+        }
+        currentInput = tempPath;
+        currentFrameCount = result.frameCount ?? 1;
+        return { success: true, frameCount: currentFrameCount };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    },
+    onReplaceFrame: async (frameIndex, imageData) => {
+      try {
+        const buffer = Buffer.from(imageData, "base64");
+        const tempImagePath = join7(tmpdir5(), `piclet-replace-${Date.now()}.png`);
+        writeFileSync2(tempImagePath, buffer);
+        const tempPath = join7(tmpdir5(), `piclet-edited-${Date.now()}.gif`);
+        const result = await replaceGifFrame(currentInput, tempPath, frameIndex, tempImagePath);
+        cleanup(tempImagePath);
+        if (!result.success) {
+          return { success: false, error: "Failed to replace frame" };
+        }
+        currentInput = tempPath;
+        currentFrameCount = result.frameCount ?? currentFrameCount;
+        return { success: true, frameCount: currentFrameCount };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
     }
   });
 }
@@ -2717,9 +2992,9 @@ async function processGifExport(input, borderColor, opts, logs) {
       let outputFile = frameFile;
       if (opts.tools && opts.tools.length > 0) {
         const processedLogs = [];
-        const outputs = await processCombined(frameFile, borderColor, opts, processedLogs);
+        const result = await processCombined(frameFile, borderColor, opts, processedLogs);
         logs.push(...processedLogs);
-        if (outputs.length === 0) {
+        if (result.outputs.length === 0) {
           cleanup(frameFile);
           return { success: false, error: "Processing failed", logs };
         }
@@ -2753,9 +3028,9 @@ async function processGifExport(input, borderColor, opts, 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 };
+      const result = await processCombined(input, borderColor, opts, logs);
+      if (result.outputs.length > 0) {
+        return { success: true, output: result.outputs.join("\n"), outputPath: result.singleFilePath, logs };
       }
       return { success: false, error: "Processing failed", logs };
     }
@@ -4458,9 +4733,22 @@ function registerInstallCommand(program2) {
         chalk7.yellow(`! Registered ${successCount}/${results.length} entries.`)
       );
     }
-    console.log(chalk7.bold("\nUsage:"));
+    console.log(chalk7.bold("\nContext Menu Usage:"));
     console.log("  Right-click any supported image in Windows Explorer.");
     console.log("  Multi-select supported for batch processing.");
+    console.log(chalk7.bold("\nCLI Usage:"));
+    console.log(chalk7.cyan("  piclet <image>") + chalk7.dim("         Open GUI editor"));
+    console.log(chalk7.cyan("  piclet makeicon <img>") + chalk7.dim("  Convert to .ico"));
+    console.log(chalk7.cyan("  piclet remove-bg <img>") + chalk7.dim(" Remove background"));
+    console.log(chalk7.cyan("  piclet scale <img>") + chalk7.dim("     Resize image"));
+    console.log(chalk7.cyan("  piclet iconpack <img>") + chalk7.dim("  Generate icon pack"));
+    console.log(chalk7.cyan("  piclet storepack <img>") + chalk7.dim(" Generate store assets"));
+    console.log(chalk7.cyan("  piclet transform <img>") + chalk7.dim(" Rotate/flip image"));
+    console.log(chalk7.cyan("  piclet filter <img>") + chalk7.dim("    Apply filters"));
+    console.log(chalk7.cyan("  piclet border <img>") + chalk7.dim("    Add border"));
+    console.log(chalk7.cyan("  piclet recolor <img>") + chalk7.dim("   Replace colors"));
+    console.log(chalk7.cyan("  piclet extract-frames <gif>") + chalk7.dim(" Extract GIF frames"));
+    console.log(chalk7.dim('\n  Run "piclet --help" for full documentation.'));
     console.log();
   });
 }