@qrdx/cli 0.0.3 → 0.0.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Ritesh Bucha and QRdx contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,45 +1,64 @@
 # @qrdx/cli
 
-QR code generator CLI for developers. Generate styled, scannable QR codes as SVG or PNG — fully non-interactive, CI-friendly.
+QR code generator CLI for developers. Generate styled, scannable QR codes as SVG, PNG or vector EPS. It runs non-interactively in scripts and CI, and guides you with prompts when run in a terminal. It renders with the same [`qrdx`](https://www.npmjs.com/package/qrdx) library as the [QRdx](https://qrdx.dev) web app.
+
+> [!NOTE]
+> This README documents `@qrdx/cli` 0.0.5, the version in this repository. npm still has 0.0.4, so `npx @qrdx/cli` runs 0.0.4 until 0.0.5 is published. 0.0.4 has the qrdx 0.0.46 styles and no `--format` or `--frame` options, and it writes SVG into a file named `qr.eps`. For EPS today, use the [image API](https://qrdx.dev/docs/developers/image-api): `curl -o qr.eps "https://api.qrdx.dev/v1/qr?data=https://example.com&format=eps"`. For frames, download from the [playground](https://qrdx.dev/playground). Run `npm view @qrdx/cli version` to see what npm installs.
 
 ## Install
 
-```bash
-# Install the qrdx library package (includes the CLI binary)
-npm install -g qrdx
+Run without installing:
 
-# Or install the standalone CLI package
-npm install -g @qrdx/cli
+```bash
+npx @qrdx/cli generate "https://example.com" -o qr.svg
 ```
 
-Or run without installing:
+Or install globally, which gives you the `qrdx` command:
 
 ```bash
-npx qrdx generate "https://example.com" -o qr.svg
+npm install -g @qrdx/cli
+qrdx generate "https://example.com" -o qr.svg
 ```
 
+PNG output uses [sharp](https://sharp.pixelplumbing.com). It is an optional dependency that npm installs automatically when your platform supports it; if it is missing, SVG and EPS output still work and the CLI tells you how to fix PNG.
+
+> The `qrdx` npm package is the React library. The CLI lives only in `@qrdx/cli`.
+
 ## Usage
 
 ```bash
 qrdx generate <data> [options]
 ```
 
+`gen` and `g` are aliases for `generate`, and `qrdx <data>` works too.
+
 **Options**
 
 | Flag | Short | Default | Description |
 |------|-------|---------|-------------|
-| `--output` | `-o` | — | Output path — extension sets format (`.svg` or `.png`) |
-| `--size` | | `512` | Output pixel size |
+| `--output` | `-o` | `qr.svg` | Output path; the extension sets the format (`.svg`, `.png` or `.eps`) |
+| `--format` | | from the extension | `svg`, `png` or `eps`, for a file name without an extension |
+| `--size` | | `512` | Output size: pixels for SVG and PNG, points (72 per inch) for EPS |
 | `--level` | `-l` | `Q` | Error correction: `L` `M` `Q` `H` |
 | `--body` | | `square` | Body dot pattern |
 | `--eye` | | `square` | Corner eye pattern |
 | `--dot` | | `square` | Corner dot pattern |
-| `--fg` | | `#000000` | Foreground color |
-| `--bg` | | `#ffffff` | Background color |
-| `--eye-color` | | — | Corner eye color override |
-| `--dot-color` | | — | Corner dot color override |
-| `--logo` | | — | Center logo URL |
+| `--fg` | | `#000000` | Foreground color (hex or JSON gradient) |
+| `--bg` | | `#ffffff` | Background color (hex or JSON gradient) |
+| `--eye-color` | | matches `--fg` | Corner eye color (hex or JSON gradient) |
+| `--dot-color` | | matches `--fg` | Corner dot color (hex or JSON gradient) |
+| `--logo` | | — | Center logo image URL (use with `--level H`) |
+| `--no-logo` | | — | Skip the logo prompt in interactive mode |
 | `--margin` | | `0` | Quiet zone margin (modules) |
+| `--template` | | — | Decorative template: `Arrow` `StandardBox` `SquareBorder` `StrikedBox` `Halloween` |
+| `--frame` | | — | Call-to-action frame: <!-- catalogue:FRAME_STYLES -->`none`, `banner-bottom`, `banner-top`, `border`, `rounded-border`, `speech-bubble`, `banner-top-bottom`, `speech-bubble-top`, `chat-bubble`, `circle`, `polaroid`, `phone`, `ticket`, `badge`, `envelope`, `tag`, `menu-card`, `sticker`, `gradient-border`, `focus`<!-- /catalogue --> |
+| `--frame-text` | | `Scan me` | Frame label, up to 24 characters (`""` hides it) |
+| `--frame-color` | | `#000000` | Frame color (hex) |
+| `--frame-text-color` | | white on banners | Frame label color (hex) |
+| `--help` | `-h` | | Show all options |
+| `--version` | `-v` | | Show the version |
+
+Invalid values (unknown pattern, template, frame, level, size, output extension, malformed gradient JSON, frame text over 24 characters or a non-hex frame color) exit with code `1` and a message listing the accepted values. `--frame-text` or a frame color without `--frame` uses `banner-bottom`. A frame adds space around the code, so the file is larger than `--size`.
 
 ## Examples
 
@@ -50,6 +69,9 @@ qrdx generate "https://qrdx.dev" -o qr.svg
 # High-res PNG for print
 qrdx generate "https://qrdx.dev" -o qr.png --size 2048 --level H
 
+# Vector EPS for a print shop or Illustrator, 2 inches wide
+qrdx generate "https://qrdx.dev" -o qr.eps --size 144
+
 # Branded style
 qrdx generate "https://qrdx.dev" \
   --body circle --eye rounded \
@@ -59,7 +81,17 @@ qrdx generate "https://qrdx.dev" \
 # With center logo
 qrdx generate "https://qrdx.dev" \
   --logo "https://qrdx.dev/logo.png" --level H \
-  -o logo-qr.svg
+  -o logo-qr.png
+
+# Gradient foreground
+qrdx generate "https://qrdx.dev" -o gradient.svg \
+  --fg '{"type":"linear","stops":[{"color":"#6366f1","offset":0},{"color":"#ec4899","offset":100}],"angle":135}'
+
+# Template
+qrdx generate "https://qrdx.dev" --template Arrow -o arrow.svg
+
+# "Scan me" frame
+qrdx generate "https://qrdx.dev/menu" --frame banner-bottom --frame-text "Scan for the menu" -o menu.png
 
 # Wi-Fi QR
 qrdx generate "WIFI:T:WPA;S:MyNetwork;P:MyPassword;;" -o wifi.svg
@@ -70,25 +102,47 @@ qrdx generate
 
 ## Patterns
 
-**Body** (`--body`): `square` `circle` `circle-large` `diamond` `circle-mixed` `pacman` `rounded` `small-square` `vertical-line`
+**Body** (`--body`): <!-- catalogue:BODY_PATTERN -->`circle`, `circle-large`, `square`, `diamond`, `circle-mixed`, `pacman`, `rounded`, `small-square`, `vertical-line`, `horizontal-line`, `liquid`, `liquid-horizontal`, `liquid-vertical`, `classy`, `classy-rounded`, `leaf`, `plus`, `hexagon`, `star`, `heart`, `random-dots`, `mosaic`, `octagon`<!-- /catalogue -->
+
+**Eye** (`--eye`): <!-- catalogue:CORNER_EYE_PATTERNS -->`square`, `rounded`, `gear`, `circle`, `diya`, `extra-rounded`, `message`, `pointy`, `leaf`, `drop`, `octagon`, `bevel`, `squircle`, `cushion`, `shield`, `petal`, `leaf-reverse`<!-- /catalogue -->
+
+**Dot** (`--dot`): <!-- catalogue:CORNER_EYE_DOT_PATTERNS -->`square`, `rounded`, `circle`, `message`, `message-reverse`, `diya`, `diya-reverse`, `rounded-triangle`, `leaf`, `drop`, `plus`, `cross-rounded`, `hexagon`, `octagon`, `flower`, `heart`, `squircle`, `dots`, `extra-rounded`, `leaf-reverse`, `drop-reverse`<!-- /catalogue -->
+
+See them all at [qrdx.dev/docs/styles](https://qrdx.dev/docs/styles). Every option decodes in our tests; `square` and `rounded` eyes scan most reliably, and `circle` eyes may be missed by strict scanners. Curly eyes and diamond, star and banner dots were retired because they don't scan reliably.
+
+## Gradients
+
+Pass a JSON object to `--fg`, `--bg`, `--eye-color` or `--dot-color`:
+
+```bash
+# Linear (angle in degrees: 0 = left→right, 90 = top→bottom)
+--fg '{"type":"linear","stops":[{"color":"#6366f1","offset":0},{"color":"#ec4899","offset":100}],"angle":135}'
+
+# Radial
+--bg '{"type":"radial","stops":[{"color":"#fef9c3","offset":0},{"color":"#fde047","offset":100}]}'
+```
+
+Each gradient needs at least 2 stops; `offset` is a percentage from 0 to 100.
 
-**Eye** (`--eye`): `square` `rounded` `gear` `circle` `diya` `extra-rounded` `message` `pointy` `curly`
+## EPS
 
-**Dot** (`--dot`): `square` `rounded` `circle` `diamond` `message` `message-reverse` `diya` `diya-reverse` `rounded-triangle` `star` `banner`
+`.eps` files are vector PostScript (EPSF-3.0) for print shops and design tools. `--size` is the width in points, so `--size 144` is 2 inches. Linear and radial gradients print as smooth PostScript Level 3 shadings, and there is no transparency. PNG and JPEG logos are embedded; other logo formats are converted with sharp when it is installed, and otherwise left out with a warning.
 
 ## Interactive mode
 
-When run in a TTY without flags, `qrdx generate` starts a guided prompt flow — output path, then optionally advanced customizations (patterns, colors, logo).
+When run in a TTY without an output path or data, `qrdx generate` starts a guided prompt flow: data, output path, then optional customizations (patterns, colors, template, logo, margin). In CI (`CI=true`) or when stdin/stdout is not a TTY it never prompts.
 
 ## Requirements
 
-Node.js ≥ 18
+Node.js ≥ 22
 
 ## Links
 
-- [qrdx.dev](https://qrdx.dev) — web app
-- [github.com/qrdx/qrdx](https://github.com/qrdx/qrdx) — source
+- [CLI docs](https://qrdx.dev/docs/developers/cli)
+- [qrdx.dev](https://qrdx.dev): the web app, with static and dynamic QR codes, hosted pages and scan analytics
+- [Image API](https://qrdx.dev/docs/developers/image-api) and [MCP server](https://qrdx.dev/docs/developers/mcp): QR codes over HTTP or from AI assistants, with nothing to install
+- [github.com/bucharitesh/qrdx](https://github.com/bucharitesh/qrdx): the source
 
 ## License
 
-MIT
+[MIT](./LICENSE) © Ritesh Bucha and QRdx contributors. Versions before 0.0.5 were published under AGPL-3.0-or-later.

package/dist/index.js

@@ -1,39 +1,90 @@
 #!/usr/bin/env node
-'use strict';
-
-var fs = require('fs');
-var path = require('path');
-var p = require('@clack/prompts');
-var qrdx = require('qrdx');
-var react = require('react');
-var server = require('react-dom/server');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var p__namespace = /*#__PURE__*/_interopNamespace(p);
+import { readFileSync, createReadStream, writeFileSync } from 'fs';
+import { join, extname } from 'path';
+import * as readline from 'readline';
+import * as p from '@clack/prompts';
+import { BODY_PATTERN, CORNER_EYE_PATTERNS, CORNER_EYE_DOT_PATTERNS, getTemplateIds, FRAME_STYLES, DEFAULT_FRAME_TEXT, FRAME_TEXT_MAX_LENGTH, DEFAULT_MARGIN, getFrameDimensions, colorConfigSchema, errorLevelSchema, QRCodeSVG, svgToEPS } from 'qrdx';
+import { readFile } from 'fs/promises';
+import { createElement } from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
 
+var OUTPUT_FORMATS = ["svg", "png", "eps"];
 function buildSVGString(props) {
-  const element = react.createElement(qrdx.QRCodeSVG, {
+  const element = createElement(QRCodeSVG, {
     size: props.size ?? 512,
     ...props
   });
-  return server.renderToStaticMarkup(element);
+  return renderToStaticMarkup(element);
+}
+async function loadLogo(src) {
+  if (src.startsWith("data:")) {
+    const comma = src.indexOf(",");
+    const payload = src.slice(comma + 1);
+    return src.slice(0, comma).endsWith(";base64") ? Buffer.from(payload, "base64") : Buffer.from(decodeURIComponent(payload));
+  }
+  if (/^https?:\/\//i.test(src)) {
+    const res = await fetch(src);
+    if (!res.ok) {
+      throw new Error(
+        `Could not download logo (${res.status} ${res.statusText}): ${src}`
+      );
+    }
+    return Buffer.from(await res.arrayBuffer());
+  }
+  return readFile(src);
+}
+async function logoAsEmbeddableDataUrl(src) {
+  const bytes = await loadLogo(src);
+  if (bytes[0] === 137 && bytes[1] === 80) {
+    return `data:image/png;base64,${bytes.toString("base64")}`;
+  }
+  if (bytes[0] === 255 && bytes[1] === 216) {
+    return `data:image/jpeg;base64,${bytes.toString("base64")}`;
+  }
+  try {
+    const mod = await import('sharp');
+    const sharp = mod.default;
+    const png = await sharp(bytes).png().toBuffer();
+    return `data:image/png;base64,${png.toString("base64")}`;
+  } catch {
+    return null;
+  }
+}
+async function buildEPSString(props) {
+  const src = props.imageSettings?.src;
+  let epsProps = props;
+  if (src && props.imageSettings) {
+    const dataUrl = await logoAsEmbeddableDataUrl(src);
+    if (dataUrl) {
+      epsProps = {
+        ...props,
+        imageSettings: { ...props.imageSettings, src: dataUrl }
+      };
+    } else {
+      console.warn(
+        "The logo could not be converted for EPS (PNG or JPEG work best), so it was left out."
+      );
+    }
+  }
+  return await svgToEPS(buildSVGString(epsProps));
+}
+async function findLogoBox(sharp, svgString) {
+  const imageTag = svgString.match(/<image\b[^>]*?(?:\/>|><\/image>)/)?.[0];
+  if (!imageTag) {
+    return null;
+  }
+  const markerTag = imageTag.replace(/^<image\b/, '<rect class="qrdx-logo-box"').replace(/\shref="[^"]*"/, "").replace(/(?:\/>|><\/image>)$/, ' fill="#000"/>');
+  const markerSvg = svgString.replace(imageTag, markerTag).replace(
+    /<svg\b[^>]*>/,
+    (open) => `${open}<style>*{visibility:hidden}.qrdx-logo-box{visibility:visible}</style>`
+  );
+  const { info } = await sharp(Buffer.from(markerSvg, "utf-8")).png().trim().toBuffer({ resolveWithObject: true });
+  return {
+    left: -(info.trimOffsetLeft ?? 0),
+    top: -(info.trimOffsetTop ?? 0),
+    width: info.width,
+    height: info.height
+  };
 }
 async function saveOutput(options) {
   const { outputPath, format, ...qrProps } = options;
@@ -41,13 +92,34 @@ async function saveOutput(options) {
   if (format === "svg") {
     const svgContent = `<?xml version="1.0" encoding="UTF-8"?>
 ${svgString}`;
-    fs.writeFileSync(outputPath, svgContent, "utf-8");
+    writeFileSync(outputPath, svgContent, "utf-8");
+    return;
+  }
+  if (format === "eps") {
+    writeFileSync(outputPath, await buildEPSString(qrProps), "utf-8");
     return;
   }
-  const sharp = (await import('sharp')).default;
+  let sharp;
+  try {
+    const mod = await import('sharp');
+    sharp = mod.default;
+  } catch {
+    throw new Error(
+      "PNG output needs the sharp package (native binaries). It is optional and may not have installed; use SVG or reinstall: https://sharp.pixelplumbing.com/install"
+    );
+  }
   const svgBuffer = Buffer.from(svgString, "utf-8");
   const size = qrProps.size ?? 512;
-  await sharp(svgBuffer).resize(size, size).png().toFile(outputPath);
+  const { width, height } = getFrameDimensions(size, qrProps.frame);
+  const qrImage = sharp(svgBuffer).resize(Math.round(width), Math.round(height)).png();
+  const logoSrc = qrProps.imageSettings?.src;
+  const box = logoSrc ? await findLogoBox(sharp, svgString) : null;
+  if (!(logoSrc && box)) {
+    await qrImage.toFile(outputPath);
+    return;
+  }
+  const logo = await sharp(await loadLogo(logoSrc)).resize(box.width, box.height, { fit: "fill" }).png().toBuffer();
+  await sharp(await qrImage.toBuffer()).composite([{ input: logo, left: box.left, top: box.top }]).png().toFile(outputPath);
 }
 
 // src/commands/generate.ts
@@ -55,79 +127,217 @@ var RESET = "\x1B[0m";
 var TEXT = "\x1B[38;5;145m";
 var GREEN = "\x1B[38;5;114m";
 var DIM = "\x1B[38;5;102m";
+var HEX_COLOR = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var MAX_PNG_SIZE = 1e4;
 function parseColorFlag(value) {
   const trimmed = value.trim();
-  if (trimmed.startsWith("{")) {
+  if (!trimmed.startsWith("{")) {
+    return trimmed;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw new Error(`Invalid gradient JSON: ${trimmed}`);
+  }
+  const result = colorConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new Error(
+      `Invalid gradient: ${trimmed}
+Expected {"type":"linear"|"radial"|"angular","stops":[{"color":"#hex","offset":0-100}, ...]} with at least 2 stops.`
+    );
+  }
+  return result.data;
+}
+function assertOneOf(flag, value, allowed) {
+  if (value !== void 0 && !allowed.includes(value)) {
+    throw new Error(
+      `Invalid ${flag} "${value}". Expected one of: ${allowed.join(", ")}`
+    );
+  }
+}
+function parseIntegerFlag(flag, value, min) {
+  const parsed = Number(value);
+  if (!(value && Number.isInteger(parsed) && parsed >= min)) {
+    throw new Error(
+      `Invalid ${flag} "${value ?? ""}". Expected a whole number \u2265 ${min}.`
+    );
+  }
+  return parsed;
+}
+function assertHexColor(flag, value) {
+  if (value !== void 0 && !HEX_COLOR.test(value)) {
+    throw new Error(
+      `Invalid ${flag} "${value}". Expected a hex color like #000000.`
+    );
+  }
+}
+function requireValue(flag, value) {
+  if (value === void 0 || /^--?[a-z]/i.test(value)) {
+    throw new Error(`${flag} needs a value. Run qrdx --help to see options.`);
+  }
+  return value;
+}
+function frameFromFlags(flags) {
+  const style = flags.frame ?? (flags.frameText !== void 0 || flags.frameColor !== void 0 || flags.frameTextColor !== void 0 ? "banner-bottom" : void 0);
+  if (!style || style === "none") {
+    return void 0;
+  }
+  return {
+    style,
+    ...flags.frameText !== void 0 && { text: flags.frameText },
+    ...flags.frameColor && { color: flags.frameColor },
+    ...flags.frameTextColor && { textColor: flags.frameTextColor }
+  };
+}
+function validateFlags(flags) {
+  assertOneOf("--level", flags.level, errorLevelSchema.options);
+  assertOneOf("--body", flags.body, BODY_PATTERN);
+  assertOneOf("--eye", flags.eye, CORNER_EYE_PATTERNS);
+  assertOneOf("--dot", flags.dot, CORNER_EYE_DOT_PATTERNS);
+  assertOneOf(
+    "--template",
+    flags.template,
+    getTemplateIds().filter((id) => id !== "default")
+  );
+  assertOneOf("--frame", flags.frame, FRAME_STYLES);
+  if (flags.frameText !== void 0 && flags.frameText.length > FRAME_TEXT_MAX_LENGTH) {
+    throw new Error(
+      `Invalid --frame-text "${flags.frameText}". Use ${FRAME_TEXT_MAX_LENGTH} characters or fewer.`
+    );
+  }
+  assertHexColor("--frame-color", flags.frameColor);
+  assertHexColor("--frame-text-color", flags.frameTextColor);
+  assertOneOf("--format", flags.format, OUTPUT_FORMATS);
+  if (flags.output !== void 0) {
+    const ext = extname(flags.output).toLowerCase();
+    if (!["", ".svg", ".png", ".eps"].includes(ext)) {
+      throw new Error(
+        `Unsupported output format "${ext}". Use a .svg, .png or .eps file name.`
+      );
+    }
+    if (ext && flags.format && ext !== `.${flags.format}`) {
+      throw new Error(
+        `--format ${flags.format} does not match the output file "${flags.output}". Use a .${flags.format} file name or drop --format.`
+      );
+    }
+  }
+  const isPng = extname(flags.output ?? "").toLowerCase() === ".png" || flags.format === "png";
+  if (isPng && flags.size !== void 0 && flags.size > MAX_PNG_SIZE) {
+    throw new Error(
+      `Invalid --size "${flags.size}". PNG output is at most ${MAX_PNG_SIZE} px; use .svg or .eps for larger prints.`
+    );
+  }
+}
+var isCI = process.env.CI === "true";
+var canUseClack = process.stdin.isTTY === true && process.stdout.isTTY === true && !isCI;
+function readLineFromTTY(question) {
+  if (process.platform === "win32") {
+    return Promise.resolve(void 0);
+  }
+  return new Promise((resolve) => {
+    let stream;
     try {
-      return JSON.parse(trimmed);
+      stream = createReadStream("/dev/tty", { flags: "r" });
     } catch {
+      resolve(void 0);
+      return;
     }
-  }
-  return trimmed;
+    const rl = readline.createInterface({
+      input: stream,
+      output: process.stdout
+    });
+    const finish = (answer) => {
+      rl.close();
+      stream.destroy();
+      resolve(answer);
+    };
+    stream.once("error", () => finish(void 0));
+    rl.question(question, (answer) => finish(answer));
+  });
 }
-var IS_TTY = Boolean(process.stdin.isTTY);
 function parseFlags(args) {
   const flags = {};
   let i = 0;
   while (i < args.length) {
     const arg = args[i];
     if (!arg.startsWith("-")) {
-      if (!flags.value) {
-        flags.value = arg;
+      if (flags.value !== void 0) {
+        throw new Error(
+          `Unexpected argument "${arg}". Quote text with spaces: qrdx generate "${flags.value} ${arg}"`
+        );
       }
+      flags.value = arg;
       i++;
       continue;
     }
     const next = args[i + 1];
     switch (arg) {
+      case "-h":
+      case "--help":
+        flags.help = true;
+        i++;
+        break;
+      case "-v":
+      case "--version":
+        flags.version = true;
+        i++;
+        break;
       case "-o":
       case "--output":
+        if (!next || /^--?[a-z]/i.test(next)) {
+          throw new Error(`${arg} needs a file path, e.g. ${arg} qr.svg`);
+        }
         flags.output = next;
         i += 2;
         break;
+      case "--format":
+        flags.format = requireValue(arg, next).toLowerCase();
+        i += 2;
+        break;
       case "-l":
       case "--level":
-        flags.level = next;
+        flags.level = requireValue(arg, next).toUpperCase();
         i += 2;
         break;
       case "--body":
-        flags.body = next;
+        flags.body = requireValue(arg, next);
         i += 2;
         break;
       case "--eye":
-        flags.eye = next;
+        flags.eye = requireValue(arg, next);
         i += 2;
         break;
       case "--dot":
-        flags.dot = next;
+        flags.dot = requireValue(arg, next);
         i += 2;
         break;
       case "--fg":
-        flags.fg = next ? parseColorFlag(next) : void 0;
+        flags.fg = parseColorFlag(requireValue(arg, next));
         i += 2;
         break;
       case "--bg":
-        flags.bg = next ? parseColorFlag(next) : void 0;
+        flags.bg = parseColorFlag(requireValue(arg, next));
         i += 2;
         break;
       case "--eye-color":
-        flags.eyeColor = next ? parseColorFlag(next) : void 0;
+        flags.eyeColor = parseColorFlag(requireValue(arg, next));
         i += 2;
         break;
       case "--dot-color":
-        flags.dotColor = next ? parseColorFlag(next) : void 0;
+        flags.dotColor = parseColorFlag(requireValue(arg, next));
         i += 2;
         break;
       case "--logo":
-        flags.logo = next;
+        flags.logo = requireValue(arg, next);
         i += 2;
         break;
       case "--margin":
-        flags.margin = next ? Number.parseInt(next, 10) : qrdx.DEFAULT_MARGIN;
+        flags.margin = parseIntegerFlag(arg, next, 0);
         i += 2;
         break;
       case "--size":
-        flags.size = next ? Number.parseInt(next, 10) : 512;
+        flags.size = parseIntegerFlag(arg, next, 1);
         i += 2;
         break;
       case "--no-logo":
@@ -135,77 +345,143 @@ function parseFlags(args) {
         i++;
         break;
       case "--template":
-        flags.template = next;
+        flags.template = requireValue(arg, next);
+        i += 2;
+        break;
+      case "--frame":
+        flags.frame = requireValue(arg, next);
+        i += 2;
+        break;
+      case "--frame-text":
+        flags.frameText = requireValue(arg, next);
+        i += 2;
+        break;
+      case "--frame-color":
+        flags.frameColor = requireValue(arg, next);
+        i += 2;
+        break;
+      case "--frame-text-color":
+        flags.frameTextColor = requireValue(arg, next);
         i += 2;
         break;
       default:
-        i++;
+        throw new Error(
+          `Unknown option "${arg}". Run qrdx --help to see all options.`
+        );
     }
   }
+  if (!(flags.help || flags.version)) validateFlags(flags);
   return flags;
 }
 function isCancel2(value) {
-  return p__namespace.isCancel(value);
+  return p.isCancel(value);
 }
 function handleCancel() {
-  p__namespace.cancel("Cancelled.");
+  p.cancel("Cancelled.");
+  console.error(
+    `${DIM}Tip:${RESET} ${TEXT}qrdx generate "https://\u2026" -o qr.svg${RESET} \u2014 local dev: ${TEXT}pnpm qrdx -- generate \u2026${RESET}`
+  );
   process.exit(0);
 }
-function inferFormat(outputPath) {
-  const ext = path.extname(outputPath).toLowerCase();
+function inferFormat(outputPath, format) {
+  const ext = extname(outputPath).toLowerCase();
   if (ext === ".png") {
     return "png";
   }
-  return "svg";
+  if (ext === ".eps") {
+    return "eps";
+  }
+  return ext === ".svg" ? "svg" : format ?? "svg";
 }
-async function runGenerate(args) {
+async function runGenerate(args, meta) {
   const flags = parseFlags(args);
-  const nonInteractive = !IS_TTY;
+  if (meta && flags.help) return meta.help();
+  if (meta && flags.version) return meta.version();
+  meta?.start?.();
+  const nonInteractive = !canUseClack;
   const hasAdvancedFlags = Boolean(
-    flags.body || flags.eye || flags.dot || flags.fg || flags.bg || flags.eyeColor || flags.dotColor || flags.logo || flags.level || flags.margin !== void 0 || flags.template
+    flags.body || flags.eye || flags.dot || flags.fg || flags.bg || flags.eyeColor || flags.dotColor || flags.logo || flags.level || flags.margin !== void 0 || flags.template || frameFromFlags(flags)
   );
-  p__namespace.intro(`${TEXT}qrdx${RESET} ${DIM}\u2014 QR Code Generator${RESET}`);
+  p.intro(`${TEXT}qrdx${RESET} ${DIM}\u2014 QR Code Generator${RESET}`);
+  if (canUseClack) {
+    process.stdin.resume();
+  }
   let value = flags.value;
   if (!value) {
-    if (nonInteractive) {
-      p__namespace.log.error("No data provided. Pass a URL or text as an argument.");
-      process.exit(1);
-    }
-    const res = await p__namespace.text({
-      message: "URL or text to encode",
-      placeholder: "https://qrdx.dev",
-      validate(v) {
-        if (!v.trim()) {
-          return "Please enter a value to encode.";
+    if (canUseClack) {
+      const promptStart = performance.now();
+      const res = await p.text({
+        message: "URL or text to encode",
+        placeholder: "https://qrdx.dev",
+        validate(v) {
+          if (!v?.trim()) {
+            return "Please enter a value to encode.";
+          }
+        }
+      });
+      if (isCancel2(res)) {
+        const instant = performance.now() - promptStart < 120 && process.platform !== "win32" && process.stdout.isTTY && !isCI;
+        if (instant) {
+          const line = await readLineFromTTY(
+            `${TEXT}URL or text to encode${RESET} ${DIM}(e.g. https://qrdx.dev)${RESET}: `
+          );
+          if (line?.trim()) {
+            value = line.trim();
+          } else {
+            handleCancel();
+          }
+        } else {
+          handleCancel();
         }
+      } else {
+        value = res;
       }
-    });
-    if (isCancel2(res)) {
-      handleCancel();
+    } else if (process.stdout.isTTY && !isCI) {
+      const line = await readLineFromTTY(
+        `${TEXT}URL or text to encode${RESET} ${DIM}(e.g. https://qrdx.dev)${RESET}: `
+      );
+      if (line?.trim()) {
+        value = line.trim();
+      }
+    }
+    if (!value) {
+      console.error(
+        'No data to encode. Example: npx @qrdx/cli generate "https://example.com" -o qr.svg'
+      );
+      process.exit(1);
     }
-    value = res;
   }
   let outputPath = flags.output;
   const size = flags.size ?? 512;
-  if (!(outputPath || nonInteractive)) {
-    const pathRes = await p__namespace.text({
-      message: "Output file (.svg or .png)",
-      placeholder: "qr.svg",
-      defaultValue: "qr.svg",
-      validate(v) {
-        if (!v.trim()) {
-          return "Please enter an output path.";
+  const defaultOutput = `qr.${flags.format ?? "svg"}`;
+  if (!outputPath) {
+    if (canUseClack) {
+      const pathRes = await p.text({
+        message: "Output file (.svg, .png or .eps)",
+        placeholder: defaultOutput,
+        defaultValue: defaultOutput,
+        validate(v) {
+          if (!v?.trim()) {
+            return "Please enter an output path.";
+          }
         }
+      });
+      if (isCancel2(pathRes)) {
+        handleCancel();
       }
-    });
-    if (isCancel2(pathRes)) {
-      handleCancel();
+      outputPath = pathRes || defaultOutput;
+    } else if (process.stdout.isTTY && !isCI) {
+      const pathAns = await readLineFromTTY(
+        `Output file ${DIM}(.svg, .png or .eps, Enter = ${defaultOutput})${RESET}: `
+      );
+      outputPath = pathAns?.trim() || defaultOutput;
+    } else {
+      outputPath = defaultOutput;
     }
-    outputPath = pathRes || "qr.svg";
   }
   let wantAdvanced = hasAdvancedFlags;
   if (!(hasAdvancedFlags || nonInteractive)) {
-    const res = await p__namespace.confirm({
+    const res = await p.confirm({
       message: "Advanced customizations?",
       initialValue: false
     });
@@ -223,11 +499,12 @@ async function runGenerate(args) {
   let eyeColor = flags.eyeColor;
   let dotColor = flags.dotColor;
   let logo = flags.logo;
-  let margin = flags.margin ?? qrdx.DEFAULT_MARGIN;
+  let margin = flags.margin ?? DEFAULT_MARGIN;
   let template = flags.template;
+  let frame = frameFromFlags(flags);
   if (wantAdvanced && !nonInteractive) {
     if (!flags.level) {
-      const res = await p__namespace.select({
+      const res = await p.select({
         message: "Error correction level",
         options: [
           {
@@ -247,9 +524,9 @@ async function runGenerate(args) {
       level = res;
     }
     if (!flags.body) {
-      const res = await p__namespace.select({
+      const res = await p.select({
         message: "Body dot pattern",
-        options: qrdx.BODY_PATTERN.map((b) => ({ value: b, label: b })),
+        options: BODY_PATTERN.map((b) => ({ value: b, label: b })),
         initialValue: "square"
       });
       if (isCancel2(res)) {
@@ -258,9 +535,9 @@ async function runGenerate(args) {
       body = res;
     }
     if (!flags.eye) {
-      const res = await p__namespace.select({
+      const res = await p.select({
         message: "Corner eye pattern",
-        options: qrdx.CORNER_EYE_PATTERNS.map((e) => ({ value: e, label: e })),
+        options: CORNER_EYE_PATTERNS.map((e) => ({ value: e, label: e })),
         initialValue: "square"
       });
       if (isCancel2(res)) {
@@ -269,9 +546,9 @@ async function runGenerate(args) {
       eye = res;
     }
     if (!flags.dot) {
-      const res = await p__namespace.select({
+      const res = await p.select({
         message: "Corner dot pattern",
-        options: qrdx.CORNER_EYE_DOT_PATTERNS.map((d) => ({ value: d, label: d })),
+        options: CORNER_EYE_DOT_PATTERNS.map((d) => ({ value: d, label: d })),
         initialValue: "square"
       });
       if (isCancel2(res)) {
@@ -280,13 +557,13 @@ async function runGenerate(args) {
       dot = res;
     }
     if (!flags.fg) {
-      const res = await p__namespace.text({
+      const res = await p.text({
         message: `Foreground color ${DIM}(hex or JSON gradient)${RESET}`,
         placeholder: "#000000",
         defaultValue: "#000000",
         validate(v) {
           if (!v) {
-            return void 0;
+            return;
           }
           if (v.trim().startsWith("{")) {
             try {
@@ -294,7 +571,7 @@ async function runGenerate(args) {
             } catch {
               return "Enter a valid hex color or JSON gradient object";
             }
-            return void 0;
+            return;
           }
           if (!/^#[0-9a-fA-F]{3,8}$/.test(v)) {
             return "Enter a valid hex color (e.g. #000000) or JSON gradient";
@@ -307,13 +584,13 @@ async function runGenerate(args) {
       fg = parseColorFlag(res || "#000000");
     }
     if (!flags.bg) {
-      const res = await p__namespace.text({
+      const res = await p.text({
         message: `Background color ${DIM}(hex or JSON gradient)${RESET}`,
         placeholder: "#ffffff",
         defaultValue: "#ffffff",
         validate(v) {
           if (!v) {
-            return void 0;
+            return;
           }
           if (v.trim().startsWith("{")) {
             try {
@@ -321,7 +598,7 @@ async function runGenerate(args) {
             } catch {
               return "Enter a valid hex color or JSON gradient object";
             }
-            return void 0;
+            return;
           }
           if (!/^#[0-9a-fA-F]{3,8}$/.test(v)) {
             return "Enter a valid hex color (e.g. #ffffff) or JSON gradient";
@@ -334,12 +611,12 @@ async function runGenerate(args) {
       bg = parseColorFlag(res || "#ffffff");
     }
     if (eyeColor === void 0) {
-      const res = await p__namespace.text({
+      const res = await p.text({
         message: `Corner eye color ${DIM}(leave blank to match foreground)${RESET}`,
         placeholder: "leave blank",
         validate(v) {
           if (!v) {
-            return void 0;
+            return;
           }
           if (v.trim().startsWith("{")) {
             try {
@@ -347,7 +624,7 @@ async function runGenerate(args) {
             } catch {
               return "Enter a valid hex color or JSON gradient object";
             }
-            return void 0;
+            return;
           }
           if (!/^#[0-9a-fA-F]{3,8}$/.test(v)) {
             return "Enter a valid hex color or leave blank";
@@ -361,12 +638,12 @@ async function runGenerate(args) {
       eyeColor = eyeVal ? parseColorFlag(eyeVal) : void 0;
     }
     if (dotColor === void 0) {
-      const res = await p__namespace.text({
+      const res = await p.text({
         message: `Corner dot color ${DIM}(leave blank to match foreground)${RESET}`,
         placeholder: "leave blank",
         validate(v) {
           if (!v) {
-            return void 0;
+            return;
           }
           if (v.trim().startsWith("{")) {
             try {
@@ -374,7 +651,7 @@ async function runGenerate(args) {
             } catch {
               return "Enter a valid hex color or JSON gradient object";
             }
-            return void 0;
+            return;
           }
           if (!/^#[0-9a-fA-F]{3,8}$/.test(v)) {
             return "Enter a valid hex color or leave blank";
@@ -388,8 +665,8 @@ async function runGenerate(args) {
       dotColor = dotVal ? parseColorFlag(dotVal) : void 0;
     }
     if (!flags.template) {
-      const templateIds = qrdx.getTemplateIds();
-      const res = await p__namespace.select({
+      const templateIds = getTemplateIds();
+      const res = await p.select({
         message: `Template ${DIM}(decorative wrapper around the QR code)${RESET}`,
         options: [
           { value: "", label: "none" },
@@ -402,8 +679,37 @@ async function runGenerate(args) {
       }
       template = res || void 0;
     }
+    if (flags.frame === void 0 && !frame) {
+      const res = await p.select({
+        message: `Frame ${DIM}(call-to-action label around the code)${RESET}`,
+        options: FRAME_STYLES.map((style) => ({ value: style, label: style })),
+        initialValue: "none"
+      });
+      if (isCancel2(res)) {
+        handleCancel();
+      }
+      if (res !== "none") {
+        const text2 = await p.text({
+          message: `Frame text ${DIM}(up to ${FRAME_TEXT_MAX_LENGTH} characters)${RESET}`,
+          placeholder: DEFAULT_FRAME_TEXT,
+          defaultValue: DEFAULT_FRAME_TEXT,
+          validate(v) {
+            if (v && v.length > FRAME_TEXT_MAX_LENGTH) {
+              return `Use ${FRAME_TEXT_MAX_LENGTH} characters or fewer`;
+            }
+          }
+        });
+        if (isCancel2(text2)) {
+          handleCancel();
+        }
+        frame = {
+          style: res,
+          text: text2 || DEFAULT_FRAME_TEXT
+        };
+      }
+    }
     if (logo === void 0 && !flags.noLogo) {
-      const addLogo = await p__namespace.confirm({
+      const addLogo = await p.confirm({
         message: "Add a logo to the center?",
         initialValue: false
       });
@@ -411,16 +717,14 @@ async function runGenerate(args) {
         handleCancel();
       }
       if (addLogo) {
-        const res = await p__namespace.text({
+        const res = await p.text({
           message: "Logo URL",
           placeholder: "https://qrdx.dev/logo.png",
           validate(v) {
-            if (!v.trim()) {
+            if (!v?.trim()) {
               return "Please enter a URL for the logo.";
             }
-            try {
-              new URL(v);
-            } catch {
+            if (!URL.canParse(v)) {
               return "Please enter a valid URL.";
             }
           }
@@ -432,10 +736,10 @@ async function runGenerate(args) {
       }
     }
     if (flags.margin === void 0) {
-      const res = await p__namespace.text({
+      const res = await p.text({
         message: "Quiet zone margin (modules)",
-        placeholder: String(qrdx.DEFAULT_MARGIN),
-        defaultValue: String(qrdx.DEFAULT_MARGIN),
+        placeholder: String(DEFAULT_MARGIN),
+        defaultValue: String(DEFAULT_MARGIN),
         validate(v) {
           if (v && Number.isNaN(Number.parseInt(v, 10))) {
             return "Enter a number";
@@ -448,10 +752,10 @@ async function runGenerate(args) {
       if (isCancel2(res)) {
         handleCancel();
       }
-      margin = Number.parseInt(res || String(qrdx.DEFAULT_MARGIN), 10);
+      margin = Number.parseInt(res || String(DEFAULT_MARGIN), 10);
     }
   }
-  const spinner2 = p__namespace.spinner();
+  const spinner2 = p.spinner();
   spinner2.start("Generating QR code...");
   try {
     const qrProps = {
@@ -467,6 +771,7 @@ async function runGenerate(args) {
       margin,
       size,
       ...template ? { templateId: template } : {},
+      ...frame ? { frame } : {},
       ...logo ? {
         imageSettings: {
           src: logo,
@@ -477,21 +782,22 @@ async function runGenerate(args) {
       } : {}
     };
     if (outputPath) {
-      const format = inferFormat(outputPath);
+      const format = inferFormat(outputPath, flags.format);
       await saveOutput({ ...qrProps, outputPath, format });
+      const dimensions = getFrameDimensions(size, frame);
       spinner2.stop(
-        `${GREEN}\u2714${RESET}  Saved to ${TEXT}${outputPath}${RESET} ${DIM}(${size}\xD7${size})${RESET}`
+        `${GREEN}\u2714${RESET}  Saved to ${TEXT}${outputPath}${RESET} ${DIM}(${Math.round(dimensions.width)}\xD7${Math.round(dimensions.height)})${RESET}`
       );
     } else {
       spinner2.stop("QR code ready");
     }
   } catch (err) {
-    spinner2.stop("Failed to generate QR code");
+    spinner2.error("Failed to generate QR code");
     const msg = err instanceof Error ? err.message : String(err);
-    p__namespace.log.error(msg);
+    p.log.error(msg);
     process.exit(1);
   }
-  p__namespace.outro(`${DIM}Done!${RESET}`);
+  p.outro(`${DIM}Done!${RESET}`);
 }
 
 // src/index.ts
@@ -517,8 +823,8 @@ var LOGO_LINES = [
 ];
 function getVersion() {
   try {
-    const pkgPath = path.join(__dirname, "..", "package.json");
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = join(import.meta.dirname, "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
     return "0.0.1";
@@ -563,32 +869,44 @@ ${BOLD}Commands:${RESET2}
 
 ${BOLD}Generate Options:${RESET2}
   <data>              URL or text to encode (positional)
-  -o, --output        Output file path (.svg or .png)
+  -o, --output        Output file path (.svg, .png or .eps)
+  --format            Output format when the file name has no extension:
+                        ${DIM2}svg, png, eps${RESET2}  ${DIM2}(EPS is vector; --size = width in points)${RESET2}
   -l, --level         Error correction: L, M, Q, H  ${DIM2}(default: Q)${RESET2}
-  --body              Body dot pattern:
-                        ${DIM2}square, circle, circle-large, diamond,${RESET2}
-                        ${DIM2}circle-mixed, pacman, rounded, small-square, vertical-line${RESET2}
-  --eye               Corner eye pattern:
-                        ${DIM2}square, rounded, gear, circle, diya,${RESET2}
-                        ${DIM2}extra-rounded, message, pointy, curly${RESET2}
-  --dot               Corner dot pattern:
-                        ${DIM2}square, rounded, circle, diamond, message,${RESET2}
-                        ${DIM2}message-reverse, diya, diya-reverse,${RESET2}
-                        ${DIM2}rounded-triangle, star, banner${RESET2}
+  --body              Body dot pattern, e.g.:
+                        ${DIM2}square, rounded, circle, circle-large, liquid,${RESET2}
+                        ${DIM2}classy, classy-rounded, leaf, hexagon, star, heart${RESET2}
+  --eye               Corner eye pattern, e.g.:
+                        ${DIM2}square, rounded, extra-rounded, gear, leaf, drop,${RESET2}
+                        ${DIM2}squircle, octagon, shield, petal${RESET2}
+  --dot               Corner dot pattern, e.g.:
+                        ${DIM2}square, rounded, circle, leaf, drop, squircle,${RESET2}
+                        ${DIM2}octagon, flower, heart, plus, dots${RESET2}
+                        ${DIM2}All options: https://qrdx.dev/docs/styles${RESET2}
   --fg                Foreground color \u2014 hex or JSON gradient  ${DIM2}(default: #000000)${RESET2}
   --bg                Background color \u2014 hex or JSON gradient  ${DIM2}(default: #ffffff)${RESET2}
   --eye-color         Corner eye color \u2014 hex or JSON gradient  ${DIM2}(default: matches --fg)${RESET2}
   --dot-color         Corner dot color \u2014 hex or JSON gradient  ${DIM2}(default: matches --fg)${RESET2}
-  --logo              Logo URL for center image
+  --logo              Logo URL for center image (use with --level H)
+  --no-logo           Skip the logo prompt in interactive mode
   --margin            Quiet zone margin in modules  ${DIM2}(default: 0)${RESET2}
   --size              Output pixel size for SVG/PNG  ${DIM2}(default: 512)${RESET2}
   --template          Decorative template wrapper:
                         ${DIM2}Arrow, StandardBox, SquareBorder, StrikedBox, Halloween${RESET2}
+  --frame             Call-to-action frame (adds space around the code), e.g.:
+                        ${DIM2}none, banner-bottom, banner-top, rounded-border,${RESET2}
+                        ${DIM2}speech-bubble, polaroid, phone, ticket, sticker${RESET2}
+                        ${DIM2}All frames: https://qrdx.dev/docs/styles${RESET2}
+  --frame-text        Frame label, up to 24 characters  ${DIM2}(default: Scan me; "" hides it)${RESET2}
+  --frame-color       Frame color \u2014 hex  ${DIM2}(default: #000000)${RESET2}
+  --frame-text-color  Frame label color \u2014 hex  ${DIM2}(default: white on banners)${RESET2}
+                        ${DIM2}Frame text/colors without --frame use banner-bottom${RESET2}
 
 ${BOLD}Gradient Colors:${RESET2}
   Pass a JSON object to --fg / --bg / --eye-color / --dot-color for gradients:
   ${DIM2}Linear:  '{"type":"linear","stops":[{"color":"#f00","offset":0},{"color":"#00f","offset":100}],"angle":45}'${RESET2}
   ${DIM2}Radial:  '{"type":"radial","stops":[{"color":"#f00","offset":0},{"color":"#00f","offset":100}]}'${RESET2}
+  ${DIM2}Angular: '{"type":"angular","stops":[{"color":"#f00","offset":0},{"color":"#00f","offset":100}],"angle":0}'${RESET2}
 
 ${BOLD}Global Options:${RESET2}
   --help, -h          Show this help message
@@ -598,11 +916,13 @@ ${BOLD}Examples:${RESET2}
   ${DIM2}$${RESET2} qrdx generate
   ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev"
   ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" -o qr.svg
-  ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" -o qr.png --body circle --eye gear --dot star
+  ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" -o qr.png --body circle --eye gear --dot flower
+  ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" -o qr.eps --size 144
   ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" --fg "#ff0000" --bg "#ffffff" --size 1024
   ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" --logo "https://qrdx.dev/logo.png" --level H -o branded.svg
   ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" --template Arrow -o arrow.svg
   ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" --template Halloween --body circle --eye gear -o halloween.svg
+  ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" --frame banner-bottom --frame-text "Scan for the menu" -o menu.png
   ${DIM2}$${RESET2} qrdx generate "https://qrdx.dev" --fg '{"type":"linear","stops":[{"color":"#6366f1","offset":0},{"color":"#ec4899","offset":100}],"angle":135}' -o gradient.svg
 
   Visit ${TEXT2}https://qrdx.dev${RESET2} for more.
@@ -616,13 +936,19 @@ async function main() {
   }
   const command = args[0];
   const restArgs = args.slice(1);
+  const generateMeta = {
+    help: showHelp,
+    version: () => console.log(VERSION),
+    start: () => {
+      showLogo();
+      console.log();
+    }
+  };
   switch (command) {
     case "generate":
     case "gen":
     case "g":
-      showLogo();
-      console.log();
-      await runGenerate(restArgs);
+      await runGenerate(restArgs, generateMeta);
       break;
     case "--help":
     case "-h":
@@ -635,12 +961,11 @@ async function main() {
       break;
     default:
       if (command.startsWith("-")) {
-        console.log(`Unknown command: ${command}`);
-        console.log(`Run ${BOLD}qrdx --help${RESET2} for usage.`);
+        console.error(`Unknown command: ${command}`);
+        console.error(`Run ${BOLD}qrdx --help${RESET2} for usage.`);
+        process.exitCode = 1;
       } else {
-        showLogo();
-        console.log();
-        await runGenerate(args);
+        await runGenerate(args, generateMeta);
       }
   }
 }

package/package.json

@@ -1,7 +1,29 @@
 {
   "name": "@qrdx/cli",
-  "version": "0.0.3",
-  "description": "QR code generator CLI for developers",
+  "version": "0.0.5",
+  "description": "QR code generator CLI for developers: styled SVG, PNG and vector EPS QR codes from the command line",
+  "keywords": [
+    "qr-code",
+    "qrcode",
+    "qr-code-generator",
+    "cli",
+    "svg",
+    "png",
+    "eps",
+    "qr-code-cli"
+  ],
+  "homepage": "https://qrdx.dev/docs",
+  "bugs": {
+    "url": "https://github.com/bucharitesh/qrdx/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bucharitesh/qrdx.git",
+    "directory": "packages/cli"
+  },
+  "license": "MIT",
+  "author": "Ritesh Bucha",
+  "type": "module",
   "bin": {
     "qrdx": "./dist/index.js"
   },
@@ -10,31 +32,32 @@
     "README.md"
   ],
   "dependencies": {
-    "@clack/prompts": "^0.10.0",
+    "@clack/prompts": "^1.8.1",
     "picocolors": "^1.1.1",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "qrdx": "0.0.46"
+    "react": "19.3.1",
+    "react-dom": "19.3.1",
+    "qrdx": "0.0.47"
   },
   "optionalDependencies": {
-    "sharp": "^0.34.2"
+    "sharp": "^0.35.5"
   },
   "devDependencies": {
-    "@types/node": "^25.1.0",
-    "@types/react": "19.2.7",
-    "@types/react-dom": "19.2.3",
-    "tsup": "^8.5.1",
-    "typescript": "5.9.3",
-    "vitest": "^4.0.18",
+    "@types/node": "^26.6.6",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
+    "tsup": "^9.0.0",
+    "typescript": "6.0.3",
+    "vitest": "^5.0.5",
     "@repo/typescript-config": "0.0.0"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
+    "qrdx": "node ./dist/index.js",
     "build": "tsup",
     "dev": "tsup --watch",
     "test": "vitest run",