@puntoycoma/bulki 3.0.2 → 3.0.3

package/README.md

@@ -35,44 +35,69 @@ npm install -g @puntoycoma/bulki
 bulki
 ```
 
-Guided menu with presets:
-- **Web optimized** — WebP, quality 80, max 1920px
-- **Social media** — PNG, quality 85, max 1080px
-- **Custom** — you choose everything
+Guided step-by-step mode. Drag a folder (or several images) into the terminal window when it asks
+for a path — quotes, escaped spaces and trailing spaces are handled for you. You can also start it
+with a path: `bulki ~/Desktop/My\ Photos`.
+
+Presets:
+- **Web optimized** — WebP, quality 80, max 1920px wide
+- **Social media** — JPEG, quality 85, max 1080px wide
+- **Just make them smaller** — same format and size, quality 80
+- **Custom** — you choose format, quality and size
+
+Navigation: **Esc** goes back one step (nothing you chose is lost), **Ctrl+C** quits. A wrong path or
+number is rejected in place so you can fix it. Before starting you get a summary where you can change
+the images, settings or output folder; afterwards you can open the output folder or run again with
+different settings.
 
 ### CLI mode
 
 ```bash
-bulki compress ./photos                    # optimize with defaults
-bulki compress ./photos -f webp -q 80      # convert to WebP
-bulki compress ./photos -r 1920 -q 85      # resize to 1920px
-bulki compress hero.png -f avif -q 70      # single file to AVIF
+bulki compress ./photos                         # → ./bulki-output
+bulki compress ./photos -o ./web -f webp -q 80  # convert to WebP into ./web
+bulki compress "My Photos" -o "Web Ready" -r 1920
+bulki compress hero.png logo.png -f avif        # several files at once (globs work too)
 ```
 
 ---
 
 ## Compress
 
-Optimize one file or an entire directory. Preserves folder structure.
+Optimize files and/or folders. **Originals are never modified** — optimized copies are written to the
+output folder, mirroring the folder structure.
 
 ```bash
-bulki compress <path> [options]
+bulki compress <paths...> [options]
 ```
 
 | Option | Alias | Description | Default |
 |--------|-------|-------------|---------|
+| `--output <dir>` | `-o` | Folder where optimized images are written | `./bulki-output` |
 | `--quality <n>` | `-q` | Output quality (1-100) | `70` |
-| `--format <fmt>` | `-f` | `jpeg`, `png`, `webp`, `gif`, `avif` | original |
-| `--resize <width>` | `-r` | Max width in pixels | original |
-| `--destination <path>` | `-d` | Output base directory | `.` |
-| `--output-folder <name>` | `-o` | Output folder name | `bulki-output` |
-| `--concurrency <n>` | | Parallel operations (1-32) | auto |
-| `--exclude <patterns...>` | | Directory names to skip | none |
-| `--dry-run` | | Preview without writing | `false` |
-| `--verbose` | | Per-file details | `false` |
+| `--format <fmt>` | `-f` | `jpeg`, `png`, `webp`, `gif`, `avif` | keep original |
+| `--resize <width>` | `-r` | Max width in pixels (never enlarges) | original |
+| `--concurrency <n>` | | Images processed in parallel (1-32) | CPU count (max 8) |
+| `--exclude <names...>` | | Folder names to skip | none |
+| `--dry-run` | | Show what would be written, without writing | `false` |
+| `--verbose` | | One line per file | `false` |
 | `--json` | | Machine-readable JSON output | `false` |
 | `--max-size <size>` | | Fail if output exceeds limit (e.g., `200kb`, `1mb`) | none |
 
+The path you want to optimize is the argument (`bulki compress <path>`); `-o` is only where the
+results go. Paths with spaces must be quoted (`"My Photos"`) or escaped (`My\ Photos`) — or just
+drag the folder into the terminal.
+
+> **Upgrading from 3.0?** `-d/--destination <dir>` and `--output-folder <name>` still work
+> (`-d x` → `x/bulki-output`, `-d x -o name` → `x/name`) but are deprecated in favor of `-o <dir>`.
+
+Behaviour worth knowing:
+- Previous `bulki-output` folders inside the source are skipped, so running twice doesn't nest outputs.
+- If re-encoding would make an image bigger, the original bytes are copied instead.
+- EXIF orientation is applied (phone photos won't come out sideways); transparent PNG → JPEG gets a white background.
+- `photo.jpg` and `photo.png` converted to WebP become `photo.webp` and `photo-png.webp` (nothing is silently overwritten).
+- HEIC/HEIF photos (iPhone) are converted on macOS.
+- A broken image doesn't stop the batch: it's reported at the end and the exit code is `1`.
+
 Output preserves your folder structure:
 
 ```
@@ -136,7 +161,9 @@ Monitor a directory. Every time a new image appears, bulki optimizes it automati
 bulki watch <directory> [options]
 ```
 
-Same options as compress: `--quality`, `--format`, `--resize`, `--destination`.
+Same options as compress: `--output`, `--quality`, `--format`, `--resize`. Files are processed once
+they stop changing (large copies aren't read half-written), and edits to an existing image are
+re-optimized.
 
 ### Examples
 
@@ -145,7 +172,7 @@ Same options as compress: `--quality`, `--format`, `--resize`, `--destination`.
 bulki watch ./uploads -f webp -q 80
 
 # Watch with resize, output to a different folder
-bulki watch ./photos -r 1920 -q 85 -d ./optimized
+bulki watch ./photos -r 1920 -q 85 -o ./optimized
 ```
 
 ### Use cases

package/dist/bin/bulki.js

@@ -1,26 +1,33 @@
 #!/usr/bin/env node
 import {
-  VALID_FORMATS,
+  DEFAULTS,
+  PlanError,
+  UNSUPPORTED,
   buildJsonOutput,
-  collectImageFiles,
+  defaultConcurrency,
   detectFormat,
+  displayPath,
+  encodeImage,
   formatFileResult,
   formatSummary,
-  getFormatOptions,
   hookCommand,
-  optimizeImage,
+  parseInteger,
+  parsePathInput,
   parseSize,
-  processPool,
+  planJobs,
+  resolveOutputDir,
+  resolveUserPath,
+  runBatch,
+  validateEncodeSettings,
   validateOptions,
   watchCommand
-} from "../chunk-7TFBGWBB.js";
+} from "../chunk-YUAKNSBH.js";
 
 // src/bin/bulki.ts
 import { createRequire as createRequire2 } from "module";
 import { Command as Command4 } from "commander";
 
 // src/commands/compress.ts
-import path from "path";
 import { Command } from "commander";
 
 // src/output/progress.ts
@@ -41,297 +48,208 @@ function createProgressBar(total) {
 }
 
 // src/commands/compress.ts
-var compressCommand = new Command("compress").description("Compress images in a file or directory").argument("<path>", "File or directory to process").option("-q, --quality <n>", "Output quality (1-100)", (v) => parseInt(v, 10), 70).option("-f, --format <fmt>", "Output format (jpeg, png, webp, gif, avif)").option("-r, --resize <width>", "Resize to width (px)", (v) => parseInt(v, 10)).option("-d, --destination <path>", "Destination directory", ".").option("-o, --output-folder <name>", "Output subfolder name", "bulki-output").option("--concurrency <n>", "Number of parallel operations", (v) => parseInt(v, 10)).option("--exclude <patterns...>", "Directory names to exclude").option("--dry-run", "Show what would be processed without writing files").option("--verbose", "Show per-file output").option("--json", "Output results as JSON").option("--max-size <size>", "Maximum file size budget (e.g., 200kb, 1mb)").action(async (inputPath, opts) => {
+var compressCommand = new Command("compress").description(
+  "Compress images. Originals are never modified; optimized copies go to the output folder."
+).argument("<paths...>", "Images and/or folders to optimize (quote paths with spaces)").option("-o, --output <dir>", "Folder where optimized images are written", DEFAULTS.output).option("-q, --quality <n>", "Output quality (1-100)", parseInteger, DEFAULTS.quality).option("-f, --format <fmt>", "Convert to jpeg, png, webp, gif or avif (default: keep format)").option(
+  "-r, --resize <width>",
+  "Max width in px (smaller images are never enlarged)",
+  parseInteger
+).option("--concurrency <n>", "Images processed in parallel (1-32)", parseInteger).option("--exclude <names...>", "Folder names to skip").option("--dry-run", "Show what would be processed without writing files").option("--verbose", "Show one line per file").option("--json", "Output results as JSON").option("--max-size <size>", "Fail if any output is bigger than this (e.g. 200kb, 1mb)").option("-d, --destination <dir>", "Deprecated: base folder; output goes to <dir>/bulki-output").option("--output-folder <name>", "Deprecated: subfolder name inside --destination").addHelpText(
+  "after",
+  `
+Examples:
+  bulki compress ./photos                       \u2192 ./bulki-output
+  bulki compress ./photos -o ./optimized -f webp
+  bulki compress "My Photos" -o "Web Ready" -r 1920
+  bulki compress *.png -f avif`
+).action(async (inputPaths, opts, cmd) => {
+  const outputFromCli = cmd.getOptionValueSource("output") === "cli";
   let options;
   try {
-    options = validateOptions(opts);
+    options = validateOptions({ ...opts, output: outputFromCli ? opts.output : void 0 });
   } catch (err) {
-    console.error(err.message);
-    process.exit(1);
+    fail(err.message);
   }
-  const resolvedPath = path.resolve(inputPath);
-  let filePaths;
-  let isDirectory;
+  const inputs = inputPaths.map((p) => resolveUserPath(p));
+  let plan;
   try {
-    const collected = await collectImageFiles(resolvedPath, options.exclude);
-    filePaths = collected.files;
-    isDirectory = collected.isDirectory;
-  } catch {
-    console.error(`Path not found: ${resolvedPath}`);
-    process.exit(1);
+    plan = await planJobs({
+      inputs,
+      output: options.output,
+      format: options.format,
+      exclude: options.exclude
+    });
+  } catch (err) {
+    if (err instanceof PlanError) fail(err.message);
+    throw err;
   }
-  if (filePaths.length === 0) {
-    console.log("No images found to process.");
+  const log = options.json ? () => {
+  } : console.log;
+  for (const s of plan.skipped) console.error(`Skipped ${s.file}: ${s.reason}`);
+  if (plan.jobs.length === 0) {
+    if (options.json) console.log(JSON.stringify(buildJsonOutput([], [], 0, options.output)));
+    else log("No images found to process.");
     return;
   }
   if (options.dryRun) {
-    console.log(`Would process ${filePaths.length} image(s)`);
-    for (const f of filePaths) console.log(`  ${path.basename(f.path)}`);
+    log(`Would optimize ${plan.jobs.length} image(s) into ${displayPath(options.output)}`);
+    for (const job of plan.jobs) log(`  ${displayPath(job.input)} \u2192 ${displayPath(job.output)}`);
     return;
   }
-  const sourcePath = isDirectory ? resolvedPath : path.dirname(resolvedPath);
-  const startTime = performance.now();
-  const progress = !options.verbose && !options.json ? createProgressBar(filePaths.length) : null;
-  const errors = [];
-  const jsonErrors = [];
-  const processedResults = await processPool(
-    filePaths,
-    async (file) => {
-      try {
-        const result = await optimizeImage(file.path, {
-          ...options,
-          sourcePath,
-          detectedFormat: file.format
-        });
-        if (options.verbose && !options.json) {
-          console.log(formatFileResult(result));
-        }
-        progress?.tick();
-        return result;
-      } catch (err) {
-        errors.push(err);
-        jsonErrors.push({ file: file.path, message: err.message });
-        progress?.tick();
-        return null;
-      }
-    },
-    options.concurrency
-  );
-  const validResults = processedResults.filter((r) => r !== null);
-  const totalDuration = performance.now() - startTime;
+  const showBar = !options.verbose && !options.json && process.stdout.isTTY;
+  const progress = showBar ? createProgressBar(plan.jobs.length) : null;
+  const batch = await runBatch(plan.jobs, options, options.concurrency, (job, result, error) => {
+    progress?.tick();
+    if (!options.verbose || options.json) return;
+    if (result) console.log(formatFileResult(result));
+    else console.error(`\u2717 ${displayPath(job.input)}: ${error?.message}`);
+  });
+  const maxSize = options.maxSize;
+  const exceeded = maxSize ? batch.results.filter((r) => r.newSize > maxSize) : [];
   if (options.json) {
-    const output = buildJsonOutput(validResults, jsonErrors, totalDuration);
-    if (options.maxSize) {
-      for (const file of output.files) {
-        if (file.newSize > options.maxSize) {
-          file.exceeded = true;
-        }
-      }
+    const output = buildJsonOutput(batch.results, batch.errors, batch.duration, options.output);
+    if (maxSize) {
+      for (const f of output.files) if (f.newSize > maxSize) f.exceeded = true;
     }
     console.log(JSON.stringify(output));
   } else {
-    console.log(formatSummary(validResults, errors, totalDuration));
-  }
-  if (validResults.length === 0 && errors.length > 0) {
-    process.exit(1);
-  }
-  const maxSize = options.maxSize;
-  if (maxSize) {
-    const exceeded = validResults.filter((r) => r.newSize > maxSize);
-    if (exceeded.length > 0) {
-      if (!options.json) {
-        for (const r of exceeded) {
-          console.warn(`File exceeds size budget: ${r.outputPath}`);
-        }
-      }
-      process.exit(1);
+    console.log(formatSummary(batch.results, batch.errors, batch.duration));
+    if (!options.verbose) {
+      for (const e of batch.errors) console.error(`\u2717 ${displayPath(e.file)}: ${e.message}`);
     }
+    if (batch.results.length > 0) console.log(`Saved to ${displayPath(options.output)}`);
+    for (const r of exceeded) console.warn(`File exceeds size budget: ${r.outputPath}`);
   }
+  if (batch.errors.length > 0 || exceeded.length > 0) process.exitCode = 1;
 });
+function fail(message) {
+  console.error(`error: ${message}`);
+  process.exit(1);
+}
 
 // src/commands/mcp.ts
 import { createRequire } from "module";
-import { availableParallelism } from "os";
-import path2 from "path";
+import path from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { Command as Command2 } from "commander";
 import { z } from "zod";
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../../package.json");
+function text(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
 var mcpCommand = new Command2("mcp").description("Start MCP server for AI editor integration (Claude Code, Cursor, etc.)").action(async () => {
-  const server = new McpServer({
-    name: "bulki",
-    version
-  });
+  const server = new McpServer({ name: "bulki", version });
   server.tool(
     "compress",
-    "Compress and optimize images. Supports JPEG, PNG, WebP, GIF, AVIF.",
+    "Compress and optimize images (JPEG, PNG, WebP, GIF, AVIF). Originals are never modified; optimized copies are written to `output`.",
     {
       path: z.string().describe("File or directory path to compress"),
-      quality: z.number().min(1).max(100).default(70).describe("Output quality (1-100)"),
+      quality: z.number().int().min(1).max(100).default(70).describe("Output quality (1-100)"),
       format: z.enum(["jpeg", "png", "webp", "gif", "avif"]).optional().describe("Output format (omit to keep original)"),
-      resize: z.number().positive().optional().describe("Max width in pixels"),
-      destination: z.string().default(".").describe("Output directory"),
-      outputFolder: z.string().default("bulki-output").describe("Output folder name"),
+      resize: z.number().int().positive().optional().describe("Max width in pixels (never enlarges)"),
+      output: z.string().optional().describe("Folder where optimized images are written (default: ./bulki-output)"),
+      destination: z.string().optional().describe("Deprecated: base folder, use `output`"),
+      outputFolder: z.string().optional().describe("Deprecated: subfolder name, use `output`"),
       maxSize: z.string().optional().describe("Max file size budget (e.g., 200kb, 1mb)")
     },
     async (params) => {
-      if (params.outputFolder.includes("/") || params.outputFolder.includes("\\") || params.outputFolder.includes("..")) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                error: "Invalid outputFolder: must be a simple directory name"
-              })
-            }
-          ]
-        };
-      }
-      const resolvedPath = path2.resolve(params.path);
-      let filePaths;
-      let isDirectory;
       try {
-        const collected = await collectImageFiles(resolvedPath, []);
-        filePaths = collected.files;
-        isDirectory = collected.isDirectory;
-      } catch {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ error: `Path not found: ${resolvedPath}` })
-            }
-          ]
-        };
-      }
-      if (filePaths.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ files: [], summary: { totalFiles: 0 } })
-            }
-          ]
-        };
-      }
-      const sourcePath = isDirectory ? resolvedPath : path2.dirname(resolvedPath);
-      const startTime = performance.now();
-      const errors = [];
-      let maxSizeBytes;
-      if (params.maxSize) {
-        try {
-          maxSizeBytes = parseSize(params.maxSize);
-        } catch (err) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({ error: err.message })
-              }
-            ]
-          };
-        }
-      }
-      const processedResults = await processPool(
-        filePaths,
-        async (file) => {
-          try {
-            const result = await optimizeImage(file.path, {
-              quality: params.quality,
-              format: params.format,
-              resize: params.resize,
-              destination: params.destination,
-              outputFolder: params.outputFolder,
-              concurrency: 1,
-              exclude: [],
-              dryRun: false,
-              verbose: false,
-              json: false,
-              sourcePath,
-              detectedFormat: file.format
-            });
-            return result;
-          } catch (err) {
-            errors.push({ file: file.path, message: err.message });
-            return null;
-          }
-        },
-        Math.min(availableParallelism(), 8)
-      );
-      const results = processedResults.filter((r) => r !== null);
-      const totalDuration = performance.now() - startTime;
-      const output = buildJsonOutput(results, errors, totalDuration);
-      if (maxSizeBytes !== void 0) {
-        for (const file of output.files) {
-          if (file.newSize > maxSizeBytes) {
-            file.exceeded = true;
-          }
+        const maxSizeBytes = params.maxSize ? parseSize(params.maxSize) : void 0;
+        const output = resolveOutputDir(params);
+        const plan = await planJobs({
+          inputs: [resolveUserPath(params.path)],
+          output,
+          format: params.format
+        });
+        const settings = { quality: params.quality, format: params.format, resize: params.resize };
+        const batch = await runBatch(plan.jobs, settings, defaultConcurrency());
+        const result = buildJsonOutput(batch.results, batch.errors, batch.duration, output);
+        if (maxSizeBytes !== void 0) {
+          for (const file of result.files) if (file.newSize > maxSizeBytes) file.exceeded = true;
         }
+        return text(result);
+      } catch (err) {
+        return text({ error: err.message });
       }
-      return { content: [{ type: "text", text: JSON.stringify(output, null, 2) }] };
     }
   );
   server.tool(
     "detect",
     "Detect if a file is an image and identify its format",
-    {
-      path: z.string().describe("Path to the file")
-    },
+    { path: z.string().describe("Path to the file") },
     async (params) => {
-      const resolvedPath = path2.resolve(params.path);
-      const format = await detectFormat(resolvedPath);
-      const result = format ? { format, isImage: true } : { format: null, isImage: false };
-      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      const format = await detectFormat(path.resolve(resolveUserPath(params.path)));
+      if (format === UNSUPPORTED) return text({ format: "heic", isImage: true, supported: false });
+      return text(format ? { format, isImage: true } : { format: null, isImage: false });
     }
   );
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
+  await server.connect(new StdioServerTransport());
 });
 
 // src/commands/pipe.ts
 import { Command as Command3 } from "commander";
-import sharp from "sharp";
-var pipeCommand = new Command3("pipe").description("Read image from stdin, write optimized image to stdout").requiredOption("-f, --format <fmt>", "Output format (jpeg, png, webp, gif, avif)").option("-q, --quality <n>", "Quality (1-100)", (v) => parseInt(v, 10), 70).option("-r, --resize <width>", "Resize to width (px)", (v) => parseInt(v, 10)).action(async (opts) => {
-  const MAX_INPUT_SIZE = 100 * 1024 * 1024;
+var MAX_INPUT_SIZE = 100 * 1024 * 1024;
+var pipeCommand = new Command3("pipe").description("Read image from stdin, write optimized image to stdout").requiredOption("-f, --format <fmt>", "Output format (jpeg, png, webp, gif, avif)").option("-q, --quality <n>", "Quality (1-100)", parseInteger, DEFAULTS.quality).option("-r, --resize <width>", "Max width in px (never enlarges)", parseInteger).action(async (opts) => {
+  let settings;
+  try {
+    settings = validateEncodeSettings(opts);
+  } catch (err) {
+    return fail2(err.message);
+  }
   const chunks = [];
   let totalSize = 0;
   for await (const chunk of process.stdin) {
     totalSize += chunk.length;
-    if (totalSize > MAX_INPUT_SIZE) {
-      process.stderr.write("Error: input exceeds 100 MB limit\n");
-      process.exit(1);
-    }
+    if (totalSize > MAX_INPUT_SIZE) return fail2("input exceeds 100 MB limit");
     chunks.push(chunk);
   }
   const input = Buffer.concat(chunks);
-  if (input.length === 0) {
-    process.stderr.write("Error: no input received on stdin\n");
-    process.exit(1);
-  }
-  const format = opts.format;
-  const quality = opts.quality;
-  const resize = opts.resize;
-  if (!VALID_FORMATS.includes(format)) {
-    process.stderr.write(`Error: invalid format "${format}"
-`);
-    process.exit(1);
-  }
-  const outputFormat = format === "jpg" ? "jpeg" : format;
-  const formatOptions = getFormatOptions(quality);
+  if (input.length === 0) return fail2("no input received on stdin");
   try {
-    let pipeline = sharp(input);
-    if (resize) {
-      pipeline = pipeline.resize(resize);
-    }
-    pipeline = pipeline.toFormat(
-      outputFormat,
-      formatOptions[outputFormat] ?? {}
-    );
-    const outputBuffer = await pipeline.toBuffer();
-    process.stdout.write(outputBuffer);
+    const detected = sniff(input);
+    const { data } = await encodeImage(input, detected, settings);
+    process.stdout.write(data);
   } catch (err) {
-    process.stderr.write(`Error: ${err.message}
-`);
-    process.exit(1);
+    fail2(err.message);
   }
 });
+function sniff(buf) {
+  if (buf[0] === 255 && buf[1] === 216) return "jpeg";
+  if (buf[0] === 137 && buf.toString("latin1", 1, 4) === "PNG") return "png";
+  if (buf.toString("latin1", 0, 4) === "RIFF" && buf.toString("latin1", 8, 12) === "WEBP")
+    return "webp";
+  if (buf.toString("latin1", 0, 3) === "GIF") return "gif";
+  if (buf.toString("latin1", 4, 8) === "ftyp") {
+    const brand = buf.toString("latin1", 8, 12);
+    return brand === "avif" || brand === "avis" ? "avif" : UNSUPPORTED;
+  }
+  return "unknown";
+}
+function fail2(message) {
+  process.stderr.write(`Error: ${message}
+`);
+  process.exit(1);
+}
 
 // src/bin/bulki.ts
 var require3 = createRequire2(import.meta.url);
 var { version: version2 } = require3("../../package.json");
-if (process.argv.length <= 2) {
-  const { runInteractive } = await import("../interactive-HBGX4FD6.js");
-  await runInteractive();
+var args = process.argv.slice(2);
+var COMMANDS = /* @__PURE__ */ new Set(["compress", "hook", "mcp", "pipe", "watch", "help"]);
+var droppedPaths = args.length > 0 && !args[0].startsWith("-") && !COMMANDS.has(args[0]) ? parsePathInput(args.join(" ")) : null;
+if (args.length === 0 || droppedPaths?.ok) {
+  const { runInteractive } = await import("../interactive-MTL4CMVQ.js");
+  await runInteractive(droppedPaths?.ok ? droppedPaths.paths : void 0);
 } else {
   const program = new Command4();
-  program.name("bulki").description("Ultra-fast CLI image optimizer").version(version2);
+  program.name("bulki").description("Fast image optimizer. Run `bulki` with no arguments for the guided mode.").version(version2).showSuggestionAfterError();
   program.addCommand(compressCommand);
   program.addCommand(hookCommand);
   program.addCommand(mcpCommand);
   program.addCommand(pipeCommand);
   program.addCommand(watchCommand);
-  program.parse();
+  await program.parseAsync();
 }
 //# sourceMappingURL=bulki.js.map