@qodalis/cli-encode 2.0.0-beta.7

package/public-api.mjs

@@ -0,0 +1,961 @@
+import { DefaultLibraryAuthor, CliForegroundColor } from '@qodalis/cli-core';
+
+// src/lib/processors/cli-base64-command-processor.ts
+var CliBase64CommandProcessor = class {
+  constructor() {
+    this.command = "base64";
+    this.aliases = ["b64"];
+    this.description = "Encode or decode Base64 strings";
+    this.author = DefaultLibraryAuthor;
+    this.processors = [];
+    this.metadata = {
+      icon: "\u{1F523}",
+      module: "misc"
+    };
+    this.processors = [
+      {
+        command: "encode",
+        aliases: ["enc", "e"],
+        description: "Encode text to Base64",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const encoded = btoa(
+            new TextEncoder().encode(text).reduce(
+              (data, byte) => data + String.fromCharCode(byte),
+              ""
+            )
+          );
+          context.writer.writeln(encoded);
+          context.process.output(encoded);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Encode text to Base64 format");
+          writer.writeln();
+          writer.writeln(`\u{1F4CB} ${context.translator.t("cli.common.usage", "Usage:")}`);
+          writer.writeln(
+            `  ${writer.wrapInColor("base64 encode <text>", CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln(`\u{1F4DD} ${context.translator.t("cli.common.examples", "Examples:")}`);
+          writer.writeln(
+            `  base64 encode Hello World        ${writer.wrapInColor("# \u2192 SGVsbG8gV29ybGQ=", CliForegroundColor.Green)}`
+          );
+        }
+      },
+      {
+        command: "decode",
+        aliases: ["dec", "d"],
+        description: "Decode a Base64 string",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const encoded = command.value || command.data || "";
+          try {
+            const bytes = Uint8Array.from(
+              atob(encoded),
+              (c) => c.charCodeAt(0)
+            );
+            const decoded = new TextDecoder().decode(bytes);
+            context.writer.writeln(decoded);
+            context.process.output(decoded);
+          } catch {
+            context.writer.writeError("Invalid Base64 string");
+            context.process.exit(-1);
+          }
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Decode a Base64 string back to text");
+          writer.writeln();
+          writer.writeln(`\u{1F4CB} ${context.translator.t("cli.common.usage", "Usage:")}`);
+          writer.writeln(
+            `  ${writer.wrapInColor("base64 decode <base64>", CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln(`\u{1F4DD} ${context.translator.t("cli.common.examples", "Examples:")}`);
+          writer.writeln(
+            `  base64 decode SGVsbG8gV29ybGQ=   ${writer.wrapInColor("# \u2192 Hello World", CliForegroundColor.Green)}`
+          );
+        }
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    context.executor.showHelp(command, context);
+  }
+  writeDescription(context) {
+    const { writer, translator: t } = context;
+    writer.writeln(t.t("cli.base64.long_description", "Encode and decode Base64 strings"));
+    writer.writeln(t.t("cli.base64.utf8_note", "Supports UTF-8 text encoding"));
+    writer.writeln();
+    writer.writeln(`\u{1F4CB} ${t.t("cli.common.usage", "Usage:")}`);
+    writer.writeln(
+      `  ${writer.wrapInColor("base64 encode <text>", CliForegroundColor.Cyan)}       ${t.t("cli.base64.encode_desc", "Encode text to Base64")}`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("base64 decode <base64>", CliForegroundColor.Cyan)}     ${t.t("cli.base64.decode_desc", "Decode Base64 to text")}`
+    );
+  }
+};
+var CliHexCommandProcessor = class {
+  constructor() {
+    this.command = "hex";
+    this.description = "Hex encode/decode and number base conversions";
+    this.author = DefaultLibraryAuthor;
+    this.processors = [];
+    this.metadata = {
+      icon: "0\uFE0F\u20E3",
+      module: "misc"
+    };
+    this.processors = [
+      {
+        command: "encode",
+        aliases: ["enc"],
+        description: "Encode text to hexadecimal",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const hex = Array.from(new TextEncoder().encode(text)).map((b) => b.toString(16).padStart(2, "0")).join("");
+          context.writer.writeln(hex);
+          context.process.output(hex);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Encode text to hexadecimal representation");
+          writer.writeln();
+          writer.writeln(`\u{1F4CB} ${context.translator.t("cli.common.usage", "Usage:")}`);
+          writer.writeln(
+            `  ${writer.wrapInColor("hex encode <text>", CliForegroundColor.Cyan)}`
+          );
+        }
+      },
+      {
+        command: "decode",
+        aliases: ["dec"],
+        description: "Decode hexadecimal to text",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const hexStr = command.value || command.data || "";
+          try {
+            const bytes = new Uint8Array(
+              (hexStr.match(/.{1,2}/g) || []).map(
+                (byte) => parseInt(byte, 16)
+              )
+            );
+            const text = new TextDecoder().decode(bytes);
+            context.writer.writeln(text);
+            context.process.output(text);
+          } catch {
+            context.writer.writeError("Invalid hex string");
+            context.process.exit(-1);
+          }
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Decode hexadecimal back to text");
+          writer.writeln();
+          writer.writeln(`\u{1F4CB} ${context.translator.t("cli.common.usage", "Usage:")}`);
+          writer.writeln(
+            `  ${writer.wrapInColor("hex decode <hex>", CliForegroundColor.Cyan)}`
+          );
+        }
+      },
+      {
+        command: "convert",
+        aliases: ["conv"],
+        description: "Convert a number between bases",
+        acceptsRawInput: true,
+        valueRequired: true,
+        parameters: [
+          {
+            name: "from",
+            description: "Source base (default: 10)",
+            type: "number",
+            required: false
+          },
+          {
+            name: "to",
+            description: "Target base (default: 16)",
+            type: "number",
+            required: false
+          }
+        ],
+        processCommand: async (command, context) => {
+          const { writer } = context;
+          const input = command.value || "";
+          const fromBase = parseInt(command.args["from"]) || 10;
+          const toBase = parseInt(command.args["to"]) || 16;
+          if (fromBase < 2 || fromBase > 36 || toBase < 2 || toBase > 36) {
+            writer.writeError("Base must be between 2 and 36");
+            context.process.exit(-1);
+            return;
+          }
+          try {
+            const num = parseInt(input, fromBase);
+            if (isNaN(num)) {
+              writer.writeError(
+                `Invalid number for base ${fromBase}`
+              );
+              context.process.exit(-1);
+              return;
+            }
+            const result = num.toString(toBase);
+            writer.writeln(
+              `  ${writer.wrapInColor(`Base ${fromBase}:`, CliForegroundColor.Cyan)}  ${input}`
+            );
+            writer.writeln(
+              `  ${writer.wrapInColor(`Base ${toBase}:`, CliForegroundColor.Cyan)}  ${result}`
+            );
+            if (fromBase !== 10 && toBase !== 10) {
+              writer.writeln(
+                `  ${writer.wrapInColor("Base 10:", CliForegroundColor.Cyan)}  ${num}`
+              );
+            }
+            context.process.output(result);
+          } catch {
+            writer.writeError("Conversion failed");
+            context.process.exit(-1);
+          }
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln(
+            "Convert a number between different bases (2-36)"
+          );
+          writer.writeln();
+          writer.writeln(`\u{1F4CB} ${context.translator.t("cli.common.usage", "Usage:")}`);
+          writer.writeln(
+            `  ${writer.wrapInColor("hex convert <number> [--from=N] [--to=N]", CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln(`\u{1F4DD} ${context.translator.t("cli.common.examples", "Examples:")}`);
+          writer.writeln(
+            `  hex convert 255                  ${writer.wrapInColor("# Decimal \u2192 Hex (ff)", CliForegroundColor.Green)}`
+          );
+          writer.writeln(
+            `  hex convert ff --from=16 --to=2  ${writer.wrapInColor("# Hex \u2192 Binary (11111111)", CliForegroundColor.Green)}`
+          );
+          writer.writeln(
+            `  hex convert 1010 --from=2        ${writer.wrapInColor("# Binary \u2192 Hex (a)", CliForegroundColor.Green)}`
+          );
+        }
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    context.executor.showHelp(command, context);
+  }
+  writeDescription(context) {
+    const { writer, translator: t } = context;
+    writer.writeln(
+      t.t("cli.hex.long_description", "Hex encode/decode text and convert numbers between bases")
+    );
+    writer.writeln();
+    writer.writeln(`\u{1F4CB} ${t.t("cli.common.usage", "Usage:")}`);
+    writer.writeln(
+      `  ${writer.wrapInColor("hex encode <text>", CliForegroundColor.Cyan)}                     ${t.t("cli.hex.text_to_hex", "Text to hex")}`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("hex decode <hex>", CliForegroundColor.Cyan)}                      ${t.t("cli.hex.hex_to_text", "Hex to text")}`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("hex convert <num> [--from --to]", CliForegroundColor.Cyan)}       ${t.t("cli.hex.base_conversion", "Base conversion")}`
+    );
+  }
+};
+var CliUrlCommandProcessor = class {
+  constructor() {
+    this.command = "url";
+    this.description = "Encode or decode URLs";
+    this.author = DefaultLibraryAuthor;
+    this.processors = [];
+    this.metadata = {
+      icon: "\u{1F517}",
+      module: "misc"
+    };
+    this.processors = [
+      {
+        command: "encode",
+        aliases: ["enc"],
+        description: "URL-encode a string",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const encoded = encodeURIComponent(text);
+          context.writer.writeln(encoded);
+          context.process.output(encoded);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("URL-encode a string");
+          writer.writeln();
+          writer.writeln(`\u{1F4CB} ${context.translator.t("cli.common.usage", "Usage:")}`);
+          writer.writeln(
+            `  ${writer.wrapInColor("url encode <text>", CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln(`\u{1F4DD} ${context.translator.t("cli.common.examples", "Examples:")}`);
+          writer.writeln(
+            `  url encode hello world           ${writer.wrapInColor("# \u2192 hello%20world", CliForegroundColor.Green)}`
+          );
+        }
+      },
+      {
+        command: "decode",
+        aliases: ["dec"],
+        description: "URL-decode a string",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          try {
+            const decoded = decodeURIComponent(text);
+            context.writer.writeln(decoded);
+            context.process.output(decoded);
+          } catch {
+            context.writer.writeError("Invalid URL-encoded string");
+            context.process.exit(-1);
+          }
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("URL-decode a string");
+          writer.writeln();
+          writer.writeln(`\u{1F4CB} ${context.translator.t("cli.common.usage", "Usage:")}`);
+          writer.writeln(
+            `  ${writer.wrapInColor("url decode <text>", CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln(`\u{1F4DD} ${context.translator.t("cli.common.examples", "Examples:")}`);
+          writer.writeln(
+            `  url decode hello%20world         ${writer.wrapInColor("# \u2192 hello world", CliForegroundColor.Green)}`
+          );
+        }
+      },
+      {
+        command: "parse",
+        description: "Parse a URL into its components",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const input = command.value || command.data || "";
+          try {
+            const url = new URL(input);
+            const parts = {
+              protocol: url.protocol,
+              hostname: url.hostname,
+              port: url.port || "(default)",
+              pathname: url.pathname,
+              search: url.search || "(none)",
+              hash: url.hash || "(none)",
+              origin: url.origin
+            };
+            const { writer } = context;
+            Object.entries(parts).forEach(([key, value]) => {
+              writer.writeln(
+                `  ${writer.wrapInColor(key.padEnd(12), CliForegroundColor.Cyan)} ${value}`
+              );
+            });
+            context.process.output(parts);
+          } catch {
+            context.writer.writeError("Invalid URL");
+            context.process.exit(-1);
+          }
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Parse a URL and display its components");
+          writer.writeln();
+          writer.writeln(`\u{1F4CB} ${context.translator.t("cli.common.usage", "Usage:")}`);
+          writer.writeln(
+            `  ${writer.wrapInColor("url parse <url>", CliForegroundColor.Cyan)}`
+          );
+        }
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    context.executor.showHelp(command, context);
+  }
+  writeDescription(context) {
+    const { writer, translator: t } = context;
+    writer.writeln(t.t("cli.url.long_description", "Encode, decode, and parse URLs"));
+    writer.writeln();
+    writer.writeln(`\u{1F4CB} ${t.t("cli.common.usage", "Usage:")}`);
+    writer.writeln(
+      `  ${writer.wrapInColor("url encode <text>", CliForegroundColor.Cyan)}        ${t.t("cli.url.encode_desc", "URL-encode a string")}`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("url decode <text>", CliForegroundColor.Cyan)}        ${t.t("cli.url.decode_desc", "URL-decode a string")}`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("url parse <url>", CliForegroundColor.Cyan)}          ${t.t("cli.url.parse_desc", "Parse URL components")}`
+    );
+  }
+};
+var CliHashCommandProcessor = class {
+  constructor() {
+    this.command = "hash";
+    this.description = "Generate hash digests of text";
+    this.author = DefaultLibraryAuthor;
+    this.processors = [];
+    this.metadata = {
+      icon: "#\uFE0F\u20E3",
+      module: "misc"
+    };
+    const algorithms = [
+      { command: "sha256", algo: "SHA-256", aliases: ["sha-256"] },
+      { command: "sha1", algo: "SHA-1", aliases: ["sha-1"] },
+      { command: "sha384", algo: "SHA-384", aliases: ["sha-384"] },
+      { command: "sha512", algo: "SHA-512", aliases: ["sha-512"] }
+    ];
+    this.processors = algorithms.map(({ command, algo, aliases }) => ({
+      command,
+      aliases,
+      description: `Generate ${algo} hash`,
+      acceptsRawInput: true,
+      valueRequired: true,
+      processCommand: async (cmd, context) => {
+        const text = cmd.value || cmd.data || "";
+        try {
+          const encoded = new TextEncoder().encode(text);
+          const hashBuffer = await crypto.subtle.digest(
+            algo,
+            encoded
+          );
+          const hashArray = Array.from(new Uint8Array(hashBuffer));
+          const hex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+          context.writer.writeln(hex);
+          context.process.output(hex);
+        } catch {
+          context.writer.writeError(`Failed to compute ${algo} hash`);
+          context.process.exit(-1);
+        }
+      },
+      writeDescription: (context) => {
+        const { writer } = context;
+        writer.writeln(
+          `Generate a ${algo} hash digest of the input text`
+        );
+        writer.writeln();
+        writer.writeln(`\u{1F4CB} ${context.translator.t("cli.common.usage", "Usage:")}`);
+        writer.writeln(
+          `  ${writer.wrapInColor(`hash ${command} <text>`, CliForegroundColor.Cyan)}`
+        );
+      }
+    }));
+  }
+  async processCommand(command, context) {
+    context.executor.showHelp(command, context);
+  }
+  writeDescription(context) {
+    const { writer, translator: t } = context;
+    writer.writeln(
+      t.t("cli.hash.long_description", "Generate cryptographic hash digests using the Web Crypto API")
+    );
+    writer.writeln();
+    writer.writeln(`\u{1F4CB} ${t.t("cli.common.usage", "Usage:")}`);
+    writer.writeln(
+      `  ${writer.wrapInColor("hash sha256 <text>", CliForegroundColor.Cyan)}        SHA-256 hash`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("hash sha1 <text>", CliForegroundColor.Cyan)}          SHA-1 hash`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("hash sha384 <text>", CliForegroundColor.Cyan)}        SHA-384 hash`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("hash sha512 <text>", CliForegroundColor.Cyan)}        SHA-512 hash`
+    );
+    writer.writeln();
+    writer.writeln(`\u{1F4DD} ${t.t("cli.common.examples", "Examples:")}`);
+    writer.writeln(
+      `  hash sha256 hello                ${writer.wrapInColor("# \u2192 2cf24dba5fb0a30e...", CliForegroundColor.Green)}`
+    );
+  }
+};
+var CliJwtCommandProcessor = class {
+  constructor() {
+    this.command = "jwt";
+    this.description = "Decode and inspect JWT tokens";
+    this.author = DefaultLibraryAuthor;
+    this.processors = [];
+    this.metadata = {
+      icon: "\u{1F511}",
+      module: "misc"
+    };
+    this.processors = [
+      {
+        command: "decode",
+        aliases: ["d"],
+        description: "Decode a JWT token",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const token = command.value || command.data || "";
+          const { writer } = context;
+          const parts = token.split(".");
+          if (parts.length !== 3) {
+            writer.writeError(
+              "Invalid JWT token (expected 3 parts separated by dots)"
+            );
+            context.process.exit(-1);
+            return;
+          }
+          try {
+            const header = JSON.parse(
+              this.base64UrlDecode(parts[0])
+            );
+            const payload = JSON.parse(
+              this.base64UrlDecode(parts[1])
+            );
+            writer.writeln(
+              writer.wrapInColor(
+                "Header:",
+                CliForegroundColor.Yellow
+              )
+            );
+            writer.writeln(JSON.stringify(header, null, 2));
+            writer.writeln();
+            writer.writeln(
+              writer.wrapInColor(
+                "Payload:",
+                CliForegroundColor.Yellow
+              )
+            );
+            writer.writeln(JSON.stringify(payload, null, 2));
+            writer.writeln();
+            if (payload.exp) {
+              const expDate = new Date(payload.exp * 1e3);
+              const isExpired = expDate.getTime() < Date.now();
+              writer.writeln(
+                `${writer.wrapInColor("Expires:", CliForegroundColor.Yellow)} ${expDate.toLocaleString()} ${isExpired ? writer.wrapInColor(
+                  "(EXPIRED)",
+                  CliForegroundColor.Red
+                ) : writer.wrapInColor(
+                  "(valid)",
+                  CliForegroundColor.Green
+                )}`
+              );
+            }
+            if (payload.iat) {
+              const iatDate = new Date(payload.iat * 1e3);
+              writer.writeln(
+                `${writer.wrapInColor("Issued:", CliForegroundColor.Yellow)}  ${iatDate.toLocaleString()}`
+              );
+            }
+            writer.writeln();
+            writer.writeln(
+              writer.wrapInColor(
+                "Signature:",
+                CliForegroundColor.Yellow
+              ) + ` ${parts[2].substring(0, 20)}...`
+            );
+            context.process.output({ header, payload });
+          } catch {
+            writer.writeError("Failed to decode JWT token");
+            context.process.exit(-1);
+          }
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln(
+            "Decode a JWT token and display its header and payload"
+          );
+          writer.writeln(
+            "Shows expiration status and issue date if present"
+          );
+          writer.writeln();
+          writer.writeln(`\u{1F4CB} ${context.translator.t("cli.common.usage", "Usage:")}`);
+          writer.writeln(
+            `  ${writer.wrapInColor("jwt decode <token>", CliForegroundColor.Cyan)}`
+          );
+        }
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    context.executor.showHelp(command, context);
+  }
+  writeDescription(context) {
+    const { writer, translator: t } = context;
+    writer.writeln(t.t("cli.jwt.long_description", "Decode and inspect JSON Web Tokens (JWT)"));
+    writer.writeln();
+    writer.writeln(`\u{1F4CB} ${t.t("cli.common.usage", "Usage:")}`);
+    writer.writeln(
+      `  ${writer.wrapInColor("jwt decode <token>", CliForegroundColor.Cyan)}       ${t.t("cli.jwt.decode_display", "Decode and display JWT contents")}`
+    );
+    writer.writeln();
+    writer.writeln(
+      `\u{1F4DD} ${t.t("cli.jwt.shows", "Shows: header, payload, expiration status, issue date")}`
+    );
+  }
+  base64UrlDecode(str) {
+    str = str.replace(/-/g, "+").replace(/_/g, "/");
+    while (str.length % 4) {
+      str += "=";
+    }
+    return decodeURIComponent(
+      atob(str).split("").map(
+        (c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)
+      ).join("")
+    );
+  }
+};
+var CliBinaryCommandProcessor = class {
+  constructor() {
+    this.command = "binary";
+    this.aliases = ["bin"];
+    this.description = "Encode or decode binary strings";
+    this.author = DefaultLibraryAuthor;
+    this.processors = [];
+    this.metadata = {
+      icon: "\u{1F4BB}",
+      module: "@qodalis/cli-encode"
+    };
+    this.processors = [
+      {
+        command: "encode",
+        aliases: ["enc", "e"],
+        description: "Encode text to binary",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const binary = Array.from(new TextEncoder().encode(text)).map((b) => b.toString(2).padStart(8, "0")).join(" ");
+          context.writer.writeln(binary);
+          context.process.output(binary);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Encode text to binary representation");
+          writer.writeln();
+          writer.writeln(`\u{1F4CB} ${context.translator.t("cli.common.usage", "Usage:")}`);
+          writer.writeln(
+            `  ${writer.wrapInColor("binary encode <text>", CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln(`\u{1F4DD} ${context.translator.t("cli.common.examples", "Examples:")}`);
+          writer.writeln(
+            `  binary encode Hi   ${writer.wrapInColor("# \u2192 01001000 01101001", CliForegroundColor.Green)}`
+          );
+        }
+      },
+      {
+        command: "decode",
+        aliases: ["dec", "d"],
+        description: "Decode binary to text",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const input = command.value || command.data || "";
+          try {
+            const cleaned = input.replace(/[^01]/g, "");
+            if (cleaned.length === 0 || cleaned.length % 8 !== 0) {
+              throw new Error("Invalid binary");
+            }
+            const bytes = new Uint8Array(
+              (cleaned.match(/.{8}/g) || []).map(
+                (b) => parseInt(b, 2)
+              )
+            );
+            const text = new TextDecoder().decode(bytes);
+            context.writer.writeln(text);
+            context.process.output(text);
+          } catch {
+            context.writer.writeError(
+              "Invalid binary string (expected groups of 8 bits)"
+            );
+            context.process.exit(-1);
+          }
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Decode binary string back to text");
+          writer.writeln();
+          writer.writeln(`\u{1F4CB} ${context.translator.t("cli.common.usage", "Usage:")}`);
+          writer.writeln(
+            `  ${writer.wrapInColor("binary decode <binary>", CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln(`\u{1F4DD} ${context.translator.t("cli.common.examples", "Examples:")}`);
+          writer.writeln(
+            `  binary decode 01001000 01101001   ${writer.wrapInColor("# \u2192 Hi", CliForegroundColor.Green)}`
+          );
+        }
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    context.executor.showHelp(command, context);
+  }
+  writeDescription(context) {
+    const { writer, translator: t } = context;
+    writer.writeln(t.t("cli.binary.long_description", "Encode and decode binary strings"));
+    writer.writeln(t.t("cli.binary.utf8_note", "Supports UTF-8 text encoding"));
+    writer.writeln();
+    writer.writeln(`\u{1F4CB} ${t.t("cli.common.usage", "Usage:")}`);
+    writer.writeln(
+      `  ${writer.wrapInColor("binary encode <text>", CliForegroundColor.Cyan)}       ${t.t("cli.binary.encode_desc", "Text to binary")}`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("binary decode <binary>", CliForegroundColor.Cyan)}     ${t.t("cli.binary.decode_desc", "Binary to text")}`
+    );
+  }
+};
+var CliRotCommandProcessor = class {
+  constructor() {
+    this.command = "rot";
+    this.description = "Apply ROT cipher (letter rotation)";
+    this.author = DefaultLibraryAuthor;
+    this.metadata = {
+      icon: "\u{1F504}",
+      module: "@qodalis/cli-encode"
+    };
+    this.parameters = [
+      {
+        name: "shift",
+        description: "Rotation amount (default: 13)",
+        type: "number",
+        required: false
+      }
+    ];
+    this.acceptsRawInput = true;
+    this.valueRequired = true;
+  }
+  async processCommand(command, context) {
+    const text = command.value || command.data || "";
+    const shift = parseInt(command.args["shift"]) || 13;
+    const normalizedShift = (shift % 26 + 26) % 26;
+    const result = text.replace(/[a-zA-Z]/g, (char) => {
+      const base = char >= "a" ? 97 : 65;
+      return String.fromCharCode(
+        (char.charCodeAt(0) - base + normalizedShift) % 26 + base
+      );
+    });
+    context.writer.writeln(result);
+    context.process.output(result);
+  }
+  writeDescription(context) {
+    const { writer, translator: t } = context;
+    writer.writeln(
+      t.t("cli.rot.long_description", "Apply ROT (rotation) cipher to text")
+    );
+    writer.writeln(
+      t.t("cli.rot.note", "Default is ROT13 (self-inverse: applying twice returns original)")
+    );
+    writer.writeln();
+    writer.writeln(`\u{1F4CB} ${t.t("cli.common.usage", "Usage:")}`);
+    writer.writeln(
+      `  ${writer.wrapInColor("rot <text>", CliForegroundColor.Cyan)}                 ${t.t("cli.rot.default_desc", "Apply ROT13")}`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("rot <text> --shift=N", CliForegroundColor.Cyan)}       ${t.t("cli.rot.shift_desc", "Apply ROT-N")}`
+    );
+    writer.writeln();
+    writer.writeln(`\u{1F4DD} ${t.t("cli.common.examples", "Examples:")}`);
+    writer.writeln(
+      `  rot Hello World              ${writer.wrapInColor("# \u2192 Uryyb Jbeyq", CliForegroundColor.Green)}`
+    );
+    writer.writeln(
+      `  rot Uryyb Jbeyq              ${writer.wrapInColor("# \u2192 Hello World (ROT13 is self-inverse)", CliForegroundColor.Green)}`
+    );
+    writer.writeln(
+      `  rot abc --shift=1            ${writer.wrapInColor("# \u2192 bcd", CliForegroundColor.Green)}`
+    );
+  }
+};
+var CHAR_TO_MORSE = {
+  A: ".-",
+  B: "-...",
+  C: "-.-.",
+  D: "-..",
+  E: ".",
+  F: "..-.",
+  G: "--.",
+  H: "....",
+  I: "..",
+  J: ".---",
+  K: "-.-",
+  L: ".-..",
+  M: "--",
+  N: "-.",
+  O: "---",
+  P: ".--.",
+  Q: "--.-",
+  R: ".-.",
+  S: "...",
+  T: "-",
+  U: "..-",
+  V: "...-",
+  W: ".--",
+  X: "-..-",
+  Y: "-.--",
+  Z: "--..",
+  "0": "-----",
+  "1": ".----",
+  "2": "..---",
+  "3": "...--",
+  "4": "....-",
+  "5": ".....",
+  "6": "-....",
+  "7": "--...",
+  "8": "---..",
+  "9": "----.",
+  ".": ".-.-.-",
+  ",": "--..--",
+  "?": "..--..",
+  "'": ".----.",
+  "!": "-.-.--",
+  "/": "-..-.",
+  "(": "-.--.",
+  ")": "-.--.-",
+  "&": ".-...",
+  ":": "---...",
+  ";": "-.-.-.",
+  "=": "-...-",
+  "+": ".-.-.",
+  "-": "-....-",
+  "_": "..--.-",
+  '"': ".-..-.",
+  "$": "...-..-",
+  "@": ".--.-.",
+  " ": "/"
+};
+var MORSE_TO_CHAR = {};
+for (const [char, morse] of Object.entries(CHAR_TO_MORSE)) {
+  if (char !== " ") {
+    MORSE_TO_CHAR[morse] = char;
+  }
+}
+var CliMorseCommandProcessor = class {
+  constructor() {
+    this.command = "morse";
+    this.description = "Encode or decode Morse code";
+    this.author = DefaultLibraryAuthor;
+    this.processors = [];
+    this.metadata = {
+      icon: "\u{1F4E1}",
+      module: "@qodalis/cli-encode"
+    };
+    this.processors = [
+      {
+        command: "encode",
+        aliases: ["enc", "e"],
+        description: "Encode text to Morse code",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const text = command.value || command.data || "";
+          const morse = text.toUpperCase().split("").map((c) => CHAR_TO_MORSE[c] ?? c).join(" ");
+          context.writer.writeln(morse);
+          context.process.output(morse);
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Encode text to Morse code");
+          writer.writeln();
+          writer.writeln(`\u{1F4CB} ${context.translator.t("cli.common.usage", "Usage:")}`);
+          writer.writeln(
+            `  ${writer.wrapInColor("morse encode <text>", CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln(`\u{1F4DD} ${context.translator.t("cli.common.examples", "Examples:")}`);
+          writer.writeln(
+            `  morse encode SOS             ${writer.wrapInColor("# \u2192 ... --- ...", CliForegroundColor.Green)}`
+          );
+          writer.writeln(
+            `  morse encode Hello World     ${writer.wrapInColor("# \u2192 .... . .-.. .-.. --- / .-- --- .-. .-.. -..", CliForegroundColor.Green)}`
+          );
+        }
+      },
+      {
+        command: "decode",
+        aliases: ["dec", "d"],
+        description: "Decode Morse code to text",
+        acceptsRawInput: true,
+        valueRequired: true,
+        processCommand: async (command, context) => {
+          const input = command.value || command.data || "";
+          try {
+            const text = input.split(" ").map((code) => {
+              if (code === "/") return " ";
+              const char = MORSE_TO_CHAR[code];
+              if (!char) throw new Error(`Unknown morse: ${code}`);
+              return char;
+            }).join("");
+            context.writer.writeln(text);
+            context.process.output(text);
+          } catch {
+            context.writer.writeError(
+              "Invalid Morse code (use spaces between letters, / between words)"
+            );
+            context.process.exit(-1);
+          }
+        },
+        writeDescription: (context) => {
+          const { writer } = context;
+          writer.writeln("Decode Morse code back to text");
+          writer.writeln();
+          writer.writeln(`\u{1F4CB} ${context.translator.t("cli.common.usage", "Usage:")}`);
+          writer.writeln(
+            `  ${writer.wrapInColor("morse decode <morse>", CliForegroundColor.Cyan)}`
+          );
+          writer.writeln();
+          writer.writeln(`\u{1F4DD} ${context.translator.t("cli.common.examples", "Examples:")}`);
+          writer.writeln(
+            `  morse decode ... --- ...     ${writer.wrapInColor("# \u2192 SOS", CliForegroundColor.Green)}`
+          );
+        }
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    context.executor.showHelp(command, context);
+  }
+  writeDescription(context) {
+    const { writer, translator: t } = context;
+    writer.writeln(t.t("cli.morse.long_description", "Encode and decode Morse code"));
+    writer.writeln(
+      t.t("cli.morse.note", "Supports letters, numbers, and common punctuation")
+    );
+    writer.writeln();
+    writer.writeln(`\u{1F4CB} ${t.t("cli.common.usage", "Usage:")}`);
+    writer.writeln(
+      `  ${writer.wrapInColor("morse encode <text>", CliForegroundColor.Cyan)}        ${t.t("cli.morse.encode_desc", "Text to Morse")}`
+    );
+    writer.writeln(
+      `  ${writer.wrapInColor("morse decode <morse>", CliForegroundColor.Cyan)}       ${t.t("cli.morse.decode_desc", "Morse to text")}`
+    );
+  }
+};
+
+// src/lib/version.ts
+var LIBRARY_VERSION = "2.0.0-beta.7";
+var API_VERSION = 2;
+
+// src/public-api.ts
+var encodeModule = {
+  apiVersion: API_VERSION,
+  name: "@qodalis/cli-encode",
+  processors: [
+    new CliBase64CommandProcessor(),
+    new CliHexCommandProcessor(),
+    new CliUrlCommandProcessor(),
+    new CliHashCommandProcessor(),
+    new CliJwtCommandProcessor(),
+    new CliBinaryCommandProcessor(),
+    new CliRotCommandProcessor(),
+    new CliMorseCommandProcessor()
+  ]
+};
+
+export { API_VERSION, CliBase64CommandProcessor, CliBinaryCommandProcessor, CliHashCommandProcessor, CliHexCommandProcessor, CliJwtCommandProcessor, CliMorseCommandProcessor, CliRotCommandProcessor, CliUrlCommandProcessor, LIBRARY_VERSION, encodeModule };
+//# sourceMappingURL=public-api.mjs.map
+//# sourceMappingURL=public-api.mjs.map