devknife 1.0.0

package/dist/cli.js

@@ -0,0 +1,1421 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/core/parser.ts
+function parse(rawArgv) {
+  const argv = rawArgv !== void 0 && rawArgv !== null ? rawArgv : process.argv.slice(2);
+  const args = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      flags["help"] = true;
+    } else if (arg === "--version" || arg === "-v") {
+      flags["version"] = true;
+    } else if (arg === "--interactive" || arg === "-i") {
+      flags["interactive"] = true;
+    } else if (arg === "--stdin" || arg === "-s") {
+      flags["stdin"] = true;
+    } else if (arg.startsWith("--no-")) {
+      const key = arg.slice(5);
+      flags[key] = false;
+    } else if (arg.startsWith("--")) {
+      const eqIndex = arg.indexOf("=");
+      if (eqIndex !== -1) {
+        const key = arg.slice(2, eqIndex);
+        const value = arg.slice(eqIndex + 1);
+        flags[key] = value;
+      } else {
+        const key = arg.slice(2);
+        const next = argv[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags[key] = next;
+          i++;
+        } else {
+          flags[key] = true;
+        }
+      }
+    } else {
+      args.push(arg);
+    }
+  }
+  const command = args[0] ?? "";
+  const subcommand = args[1] ?? "";
+  return {
+    command,
+    subcommand,
+    args: args.slice(2),
+    flags,
+    raw: argv
+  };
+}
+
+// src/core/logger.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  redBright: "\x1B[91m",
+  greenBright: "\x1B[92m",
+  yellowBright: "\x1B[93m",
+  blueBright: "\x1B[94m",
+  magentaBright: "\x1B[95m",
+  cyanBright: "\x1B[96m",
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgBlue: "\x1B[44m"
+};
+function createLogger(write = process.stdout.write.bind(process.stdout)) {
+  function colorize(text, color) {
+    return `${ANSI[color]}${text}${ANSI.reset}`;
+  }
+  return {
+    info(msg) {
+      write(`${colorize("\u2139", "blue")} ${msg}
+`);
+    },
+    success(msg) {
+      write(`${colorize("\u2714", "green")} ${msg}
+`);
+    },
+    warn(msg) {
+      write(`${colorize("\u26A0", "yellow")} ${msg}
+`);
+    },
+    error(msg) {
+      write(`${colorize("\u2716", "red")} ${msg}
+`);
+    },
+    raw(msg) {
+      write(`${msg}
+`);
+    },
+    title(msg) {
+      write(`
+${colorize(colorize(msg, "bold"), "cyan")}
+`);
+    },
+    table(rows) {
+      if (rows.length === 0) return;
+      const colWidths = [];
+      const maxCols = rows[0].length;
+      for (let col = 0; col < maxCols; col++) {
+        let max = 0;
+        for (const row of rows) {
+          const cell = col < row.length ? row[col] : "";
+          const cellLen = cell.length;
+          if (cellLen > max) max = cellLen;
+        }
+        colWidths.push(max);
+      }
+      for (const row of rows) {
+        const padded = [...row];
+        while (padded.length < maxCols) padded.push("");
+        const line = padded.map((cell, idx) => cell.padEnd(colWidths[idx])).join("  ");
+        write(`  ${line}
+`);
+      }
+    },
+    newline() {
+      write("\n");
+    },
+    color(text, color) {
+      return colorize(text, color);
+    },
+    bold(text) {
+      return colorize(text, "bold");
+    },
+    dim(text) {
+      return colorize(text, "dim");
+    }
+  };
+}
+
+// src/core/errors.ts
+var DevKnifeError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "DevKnifeError";
+  }
+  code;
+};
+var ToolNotFoundError = class extends DevKnifeError {
+  constructor(toolName) {
+    super(`Tool not found: ${toolName}. Run 'devknife --help' to see available tools.`, "TOOL_NOT_FOUND");
+    this.name = "ToolNotFoundError";
+  }
+};
+var SubcommandNotFoundError = class extends DevKnifeError {
+  constructor(tool, subcommand) {
+    super(
+      `Unknown subcommand '${subcommand}' for tool '${tool}'. Run 'devknife ${tool} --help' for usage.`,
+      "SUBCOMMAND_NOT_FOUND"
+    );
+    this.name = "SubcommandNotFoundError";
+  }
+};
+function handleError(error, write = process.stderr.write.bind(process.stderr)) {
+  if (error instanceof DevKnifeError) {
+    write(`\x1B[31m\u2716 Error: ${error.message}\x1B[0m
+`);
+    process.exitCode = 1;
+  } else if (error instanceof Error) {
+    write(`\x1B[31m\u2716 Unexpected Error: ${error.message}\x1B[0m
+`);
+    process.exitCode = 1;
+  } else {
+    write(`\x1B[31m\u2716 Unknown Error\x1B[0m
+`);
+    process.exitCode = 1;
+  }
+}
+
+// src/core/interactive.ts
+import * as readline from "readline";
+async function startInteractive(config) {
+  const { logger, menuTitle, options, onExit, onSelect } = config;
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const promptInputFn = (msg) => new Promise((resolve) => {
+    rl.question(msg, (answer) => {
+      resolve(answer);
+    });
+  });
+  function showMenu() {
+    logger.newline();
+    logger.title(menuTitle);
+    logger.newline();
+    for (let i = 0; i < options.length; i++) {
+      const option = options[i];
+      const num = logger.color(`${i + 1}.`, "cyan");
+      const label = logger.bold(option.label);
+      const desc = logger.dim(`\u2014 ${option.description}`);
+      logger.raw(`  ${num} ${label} ${desc}`);
+    }
+    logger.raw(`  ${logger.color("0.", "cyan")} ${logger.bold("Exit")} ${logger.dim("\u2014 Quit devknife")}`);
+    logger.newline();
+  }
+  async function run() {
+    showMenu();
+    const answer = await promptInputFn(logger.color("Select a tool (0-" + options.length + "): ", "cyan"));
+    const num = parseInt(answer, 10);
+    if (answer.toLowerCase() === "q" || answer === "0" || isNaN(num) || num < 0 || num > options.length) {
+      logger.info("Goodbye!");
+      rl.close();
+      onExit();
+      return;
+    }
+    const selected = options[num - 1];
+    if (selected) {
+      await onSelect(selected.value, promptInputFn);
+      await run();
+    } else {
+      logger.error("Invalid selection. Please try again.");
+      await run();
+    }
+  }
+  await run();
+}
+
+// src/tools/crypto/hash.ts
+import { createHash } from "crypto";
+var SUPPORTED_ALGORITHMS = ["md5", "sha1", "sha256", "sha512"];
+function hash(input, algorithm = "sha256") {
+  return createHash(algorithm).update(input).digest("hex");
+}
+function isSupportedAlgorithm(algo) {
+  return SUPPORTED_ALGORITHMS.includes(algo);
+}
+function getSupportedAlgorithms() {
+  return SUPPORTED_ALGORITHMS;
+}
+
+// src/tools/crypto/password.ts
+import { randomBytes, webcrypto } from "crypto";
+var UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var LOWERCASE = "abcdefghijklmnopqrstuvwxyz";
+var NUMBERS = "0123456789";
+var SYMBOLS = "!@#$%^&*()_+-=[]{}|;:,.<>?";
+var AMBIGUOUS = "Il1O0";
+var DEFAULT_OPTIONS = {
+  length: 16,
+  uppercase: true,
+  lowercase: true,
+  numbers: true,
+  symbols: false,
+  excludeAmbiguous: false
+};
+function filterAmbiguous(chars, exclude) {
+  if (!exclude) return chars;
+  return chars.split("").filter((c) => !AMBIGUOUS.includes(c)).join("");
+}
+function secureRandomIndex(max) {
+  const array = new Uint32Array(1);
+  webcrypto.getRandomValues(array);
+  return array[0] % max;
+}
+function generatePassword(options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  let charset = "";
+  if (opts.uppercase) charset += filterAmbiguous(UPPERCASE, opts.excludeAmbiguous);
+  if (opts.lowercase) charset += filterAmbiguous(LOWERCASE, opts.excludeAmbiguous);
+  if (opts.numbers) charset += filterAmbiguous(NUMBERS, opts.excludeAmbiguous);
+  if (opts.symbols) charset += SYMBOLS;
+  if (charset.length === 0) {
+    charset = LOWERCASE;
+  }
+  let password = "";
+  if (opts.uppercase) {
+    const pool = filterAmbiguous(UPPERCASE, opts.excludeAmbiguous);
+    password += pool[secureRandomIndex(pool.length)];
+  }
+  if (opts.lowercase) {
+    const pool = filterAmbiguous(LOWERCASE, opts.excludeAmbiguous);
+    password += pool[secureRandomIndex(pool.length)];
+  }
+  if (opts.numbers) {
+    const pool = filterAmbiguous(NUMBERS, opts.excludeAmbiguous);
+    password += pool[secureRandomIndex(pool.length)];
+  }
+  if (opts.symbols) {
+    const pool = SYMBOLS;
+    password += pool[secureRandomIndex(pool.length)];
+  }
+  const remaining = opts.length - password.length;
+  for (let i = 0; i < remaining; i++) {
+    password += charset[secureRandomIndex(charset.length)];
+  }
+  const arr = password.split("");
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = secureRandomIndex(i + 1);
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr.join("");
+}
+function calculateEntropy(password) {
+  if (password.length === 0) return 0;
+  const uniqueChars = new Set(password.split("")).size;
+  return Math.floor(password.length * Math.log2(uniqueChars));
+}
+function estimateStrength(password) {
+  const entropy = calculateEntropy(password);
+  if (entropy < 28) return "weak";
+  if (entropy < 36) return "fair";
+  if (entropy < 60) return "strong";
+  return "very-strong";
+}
+
+// src/tools/generators/uuid.ts
+import { randomBytes as randomBytes2 } from "crypto";
+function generateUUID() {
+  const bytes = randomBytes2(16);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20, 32)
+  ].join("-");
+}
+function generateUUIDs(count) {
+  if (count < 1) throw new Error("Count must be at least 1");
+  return Array.from({ length: count }, () => generateUUID());
+}
+
+// src/tools/generators/nanoid.ts
+import { webcrypto as webcrypto2 } from "crypto";
+var DEFAULT_ALPHABET = "-_0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var DEFAULT_SIZE = 21;
+function secureRandom(max) {
+  const array = new Uint32Array(1);
+  webcrypto2.getRandomValues(array);
+  return array[0] % max;
+}
+function generateNanoID(options = {}) {
+  const size = options.size ?? DEFAULT_SIZE;
+  const alphabet = options.alphabet ?? DEFAULT_ALPHABET;
+  if (alphabet.length === 0) {
+    throw new Error("Alphabet must not be empty");
+  }
+  let id = "";
+  for (let i = 0; i < size; i++) {
+    id += alphabet[secureRandom(alphabet.length)];
+  }
+  return id;
+}
+
+// src/tools/generators/lorem.ts
+var LOREM_WORDS = [
+  "lorem",
+  "ipsum",
+  "dolor",
+  "sit",
+  "amet",
+  "consectetur",
+  "adipiscing",
+  "elit",
+  "sed",
+  "do",
+  "eiusmod",
+  "tempor",
+  "incididunt",
+  "ut",
+  "labore",
+  "et",
+  "dolore",
+  "magna",
+  "aliqua",
+  "enim",
+  "ad",
+  "minim",
+  "veniam",
+  "quis",
+  "nostrud",
+  "exercitation",
+  "ullamco",
+  "laboris",
+  "nisi",
+  "aliquip",
+  "ex",
+  "ea",
+  "commodo",
+  "consequat",
+  "duis",
+  "aute",
+  "irure",
+  "in",
+  "reprehenderit",
+  "voluptate",
+  "velit",
+  "esse",
+  "cillum",
+  "fugiat",
+  "nulla",
+  "pariatur",
+  "excepteur",
+  "sint",
+  "occaecat",
+  "cupidatat",
+  "non",
+  "proident",
+  "sunt",
+  "culpa",
+  "qui",
+  "officia",
+  "deserunt",
+  "mollit",
+  "anim",
+  "id",
+  "est",
+  "laborum",
+  "perspiciatis",
+  "unde",
+  "omnis",
+  "iste",
+  "natus",
+  "error",
+  "voluptatem",
+  "accusantium",
+  "doloremque",
+  "laudantium",
+  "totam",
+  "rem",
+  "aperiam",
+  "eaque",
+  "ipsa",
+  "quae",
+  "ab",
+  "illo",
+  "inventore",
+  "veritatis",
+  "quasi",
+  "architecto",
+  "beatae",
+  "vitae",
+  "dicta",
+  "explicabo",
+  "nemo",
+  "ipsam",
+  "voluptas",
+  "aspernatur",
+  "aut",
+  "odit",
+  "fugit",
+  "consequuntur",
+  "magni",
+  "dolores",
+  "eos",
+  "ratione",
+  "sequi",
+  "nesciunt"
+];
+function randomIndex(max) {
+  return Math.floor(Math.random() * max);
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function word(count = 1) {
+  const words = [];
+  for (let i = 0; i < count; i++) {
+    words.push(LOREM_WORDS[randomIndex(LOREM_WORDS.length)]);
+  }
+  return words.join(" ");
+}
+function sentence(wordCount) {
+  const count = wordCount ?? 8 + Math.floor(Math.random() * 8);
+  const words = word(count);
+  return capitalize(words) + ".";
+}
+function paragraph(sentenceCount) {
+  const count = sentenceCount ?? 4 + Math.floor(Math.random() * 4);
+  const sentences = [];
+  for (let i = 0; i < count; i++) {
+    sentences.push(sentence());
+  }
+  return sentences.join(" ");
+}
+function paragraphs(count = 1, separator = "\n\n") {
+  const result = [];
+  for (let i = 0; i < count; i++) {
+    result.push(paragraph());
+  }
+  return result.join(separator);
+}
+function title(wordCount) {
+  const count = wordCount ?? 3 + Math.floor(Math.random() * 4);
+  const words = word(count);
+  return words.split(" ").map((w) => capitalize(w)).join(" ");
+}
+
+// src/tools/encoders/base64.ts
+function encode(input) {
+  return Buffer.from(input, "utf-8").toString("base64");
+}
+function decode(input) {
+  return Buffer.from(input, "base64").toString("utf-8");
+}
+
+// src/tools/encoders/url.ts
+function encode2(input) {
+  return encodeURIComponent(input);
+}
+function decode2(input) {
+  return decodeURIComponent(input);
+}
+
+// src/tools/encoders/html.ts
+var ENTITY_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+  "/": "&#x2F;",
+  "`": "&#x60;",
+  "=": "&#x3D;"
+};
+var DECODE_MAP = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&#x27;": "'",
+  "&#x2F;": "/",
+  "&#x60;": "`",
+  "&#x3D;": "=",
+  "&apos;": "'"
+};
+var ENTITY_REGEX = /[&<>"'`=/]/g;
+var DECODE_REGEX = /&(?:amp|lt|gt|quot|#39|#x27|#x2F|#x60|#x3D|apos);/g;
+function encode3(input) {
+  return input.replace(ENTITY_REGEX, (char) => ENTITY_MAP[char]);
+}
+function decode3(input) {
+  return input.replace(DECODE_REGEX, (entity) => DECODE_MAP[entity]);
+}
+
+// src/tools/encoders/jwt.ts
+function base64UrlDecode(str) {
+  let base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+  while (base64.length % 4 !== 0) {
+    base64 += "=";
+  }
+  return Buffer.from(base64, "base64").toString("utf-8");
+}
+function decode4(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    throw new Error("Invalid JWT: token must have 3 parts separated by dots");
+  }
+  const [headerB64, payloadB64, signature] = parts;
+  let header;
+  let payload;
+  try {
+    header = JSON.parse(base64UrlDecode(headerB64));
+  } catch {
+    throw new Error("Invalid JWT: header is not valid JSON");
+  }
+  try {
+    payload = JSON.parse(base64UrlDecode(payloadB64));
+  } catch {
+    throw new Error("Invalid JWT: payload is not valid JSON");
+  }
+  return {
+    header,
+    payload,
+    signature
+  };
+}
+
+// src/tools/formatters/json.ts
+function format(input, indent = 2) {
+  const parsed = JSON.parse(input);
+  return JSON.stringify(parsed, null, indent);
+}
+function minify(input) {
+  const parsed = JSON.parse(input);
+  return JSON.stringify(parsed);
+}
+function validate(input) {
+  try {
+    const data = JSON.parse(input);
+    return { valid: true, data };
+  } catch (err) {
+    const message = err.message;
+    return { valid: false, error: message };
+  }
+}
+function sortByKeys(input, indent = 2) {
+  const parsed = JSON.parse(input);
+  const sorted = {};
+  for (const key of Object.keys(parsed).sort()) {
+    sorted[key] = parsed[key];
+  }
+  return JSON.stringify(sorted, null, indent);
+}
+
+// src/tools/formatters/text.ts
+function camelCase(input) {
+  return input.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^[A-Z]/, (c) => c.toLowerCase());
+}
+function snakeCase(input) {
+  return input.replace(/([A-Z])/g, "_$1").replace(/[-\s]+/g, "_").replace(/^_/, "").toLowerCase();
+}
+function kebabCase(input) {
+  return input.replace(/([A-Z])/g, "-$1").replace(/[_\s]+/g, "-").replace(/^-/, "").toLowerCase();
+}
+function pascalCase(input) {
+  const camel = camelCase(input);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function constantCase(input) {
+  return snakeCase(input).toUpperCase();
+}
+function dotCase(input) {
+  return input.replace(/([A-Z])/g, ".$1").replace(/[-_\s]+/g, ".").replace(/^\.|\.+$/g, "").toLowerCase();
+}
+function titleCase(input) {
+  return input.split(/[-_\s]+/).map((word2) => word2.charAt(0).toUpperCase() + word2.slice(1).toLowerCase()).join(" ");
+}
+function sentenceCase(input) {
+  const result = input.replace(/[-_\s]+/g, " ").trim();
+  return result.charAt(0).toUpperCase() + result.slice(1).toLowerCase();
+}
+function upperCase(input) {
+  return input.toUpperCase();
+}
+function lowerCase(input) {
+  return input.toLowerCase();
+}
+function reverseCase(input) {
+  return input.split("").map((c) => c === c.toUpperCase() ? c.toLowerCase() : c.toUpperCase()).join("");
+}
+function slugify(input) {
+  return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[-_\s]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+// src/tools/converters/color.ts
+function hexToRgb(hex) {
+  const clean = hex.replace("#", "");
+  if (clean.length !== 3 && clean.length !== 6) {
+    throw new Error("Invalid HEX color: must be 3 or 6 characters");
+  }
+  const full = clean.length === 3 ? clean.split("").map((c) => c + c).join("") : clean;
+  const r = parseInt(full.slice(0, 2), 16);
+  const g = parseInt(full.slice(2, 4), 16);
+  const b = parseInt(full.slice(4, 6), 16);
+  if (isNaN(r) || isNaN(g) || isNaN(b)) {
+    throw new Error("Invalid HEX color: contains non-hex characters");
+  }
+  return { r, g, b };
+}
+function rgbToHex(r, g, b) {
+  const clamp = (n) => Math.max(0, Math.min(255, Math.round(n)));
+  const toHex = (n) => clamp(n).toString(16).padStart(2, "0");
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function rgbToHsl(r, g, b) {
+  const rn = r / 255;
+  const gn = g / 255;
+  const bn = b / 255;
+  const max = Math.max(rn, gn, bn);
+  const min = Math.min(rn, gn, bn);
+  const l = (max + min) / 2;
+  let h = 0;
+  let s = 0;
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case rn:
+        h = ((gn - bn) / d + (gn < bn ? 6 : 0)) / 6;
+        break;
+      case gn:
+        h = ((bn - rn) / d + 2) / 6;
+        break;
+      case bn:
+        h = ((rn - gn) / d + 4) / 6;
+        break;
+    }
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function hslToRgb(h, s, l) {
+  const sn = s / 100;
+  const ln = l / 100;
+  if (sn === 0) {
+    const val = Math.round(ln * 255);
+    return { r: val, g: val, b: val };
+  }
+  const hue2rgb = (p2, q2, t) => {
+    let tn = t;
+    if (tn < 0) tn += 1;
+    if (tn > 1) tn -= 1;
+    if (tn < 1 / 6) return p2 + (q2 - p2) * 6 * tn;
+    if (tn < 1 / 2) return q2;
+    if (tn < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - tn) * 6;
+    return p2;
+  };
+  const q = ln < 0.5 ? ln * (1 + sn) : ln + sn - ln * sn;
+  const p = 2 * ln - q;
+  const hNorm = h / 360;
+  return {
+    r: Math.round(hue2rgb(p, q, hNorm + 1 / 3) * 255),
+    g: Math.round(hue2rgb(p, q, hNorm) * 255),
+    b: Math.round(hue2rgb(p, q, hNorm - 1 / 3) * 255)
+  };
+}
+function hexToHsl(hex) {
+  const { r, g, b } = hexToRgb(hex);
+  return rgbToHsl(r, g, b);
+}
+function hslToHex(h, s, l) {
+  const { r, g, b } = hslToRgb(h, s, l);
+  return rgbToHex(r, g, b);
+}
+function isLightColor(hex) {
+  const { r, g, b } = hexToRgb(hex);
+  const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+  return luminance > 0.5;
+}
+
+// src/tools/converters/time.ts
+function epochToIso(epoch) {
+  return new Date(epoch * 1e3).toISOString();
+}
+function isoToEpoch(iso) {
+  const ms = new Date(iso).getTime();
+  if (isNaN(ms)) {
+    throw new Error("Invalid ISO date string");
+  }
+  return Math.floor(ms / 1e3);
+}
+function nowEpoch() {
+  return Math.floor(Date.now() / 1e3);
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function timeAgo(epoch) {
+  const now = Math.floor(Date.now() / 1e3);
+  const diff = now - epoch;
+  if (diff < 0) return "in the future";
+  const intervals = [
+    ["year", 31536e3],
+    ["month", 2592e3],
+    ["week", 604800],
+    ["day", 86400],
+    ["hour", 3600],
+    ["minute", 60],
+    ["second", 1]
+  ];
+  for (const [label, seconds] of intervals) {
+    const count = Math.floor(diff / seconds);
+    if (count >= 1) {
+      return `${count} ${label}${count > 1 ? "s" : ""} ago`;
+    }
+  }
+  return "just now";
+}
+function formatDate(iso, format2) {
+  const date = new Date(iso);
+  if (isNaN(date.getTime())) throw new Error("Invalid date string");
+  return format2.replace("YYYY", date.getFullYear().toString()).replace("MM", String(date.getMonth() + 1).padStart(2, "0")).replace("DD", String(date.getDate()).padStart(2, "0")).replace("HH", String(date.getHours()).padStart(2, "0")).replace("mm", String(date.getMinutes()).padStart(2, "0")).replace("ss", String(date.getSeconds()).padStart(2, "0"));
+}
+function getWeekNumber(iso) {
+  const date = new Date(iso);
+  if (isNaN(date.getTime())) throw new Error("Invalid date string");
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  return Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+}
+
+// src/tools/converters/number.ts
+function decimalToBinary(decimal) {
+  if (!Number.isInteger(decimal)) throw new Error("Input must be an integer");
+  return decimal.toString(2);
+}
+function binaryToDecimal(binary) {
+  if (!/^[01]+$/.test(binary)) throw new Error("Invalid binary string");
+  return parseInt(binary, 2);
+}
+function decimalToHex(decimal) {
+  if (!Number.isInteger(decimal)) throw new Error("Input must be an integer");
+  return decimal.toString(16);
+}
+function hexToDecimal(hex) {
+  if (!/^[0-9a-fA-F]+$/.test(hex)) throw new Error("Invalid hexadecimal string");
+  return parseInt(hex, 16);
+}
+function decimalToOctal(decimal) {
+  if (!Number.isInteger(decimal)) throw new Error("Input must be an integer");
+  return parseInt(decimal.toString(8), 10);
+}
+function octalToDecimal(octal) {
+  if (!/^[0-7]+$/.test(octal)) throw new Error("Invalid octal string");
+  return parseInt(octal, 8);
+}
+function hexToBinary(hex) {
+  const decimal = hexToDecimal(hex);
+  return decimalToBinary(decimal);
+}
+function binaryToHex(binary) {
+  const decimal = binaryToDecimal(binary);
+  return decimalToHex(decimal);
+}
+function formatBytes(bytes, decimals = 2) {
+  if (bytes === 0) return "0 Bytes";
+  if (bytes < 0) throw new Error("Bytes cannot be negative");
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const i = Math.min(Math.floor(Math.log(bytes) / Math.log(k)), sizes.length - 1);
+  const sizeStr = sizes[i];
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${sizeStr}`;
+}
+
+// src/tools/network/ip.ts
+import * as os from "os";
+var IPv4_REGEX = /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
+function isValidIPv4(ip) {
+  return IPv4_REGEX.test(ip);
+}
+var IPv6_REGEX = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
+function isValidIPv6(ip) {
+  if (ip.includes("::")) {
+    const parts = ip.split("::");
+    if (parts.length !== 2) return false;
+    const left = parts[0].split(":").filter(Boolean);
+    const right = parts[1].split(":").filter(Boolean);
+    return left.length + right.length <= 7 && left.length + right.length >= 1;
+  }
+  return IPv6_REGEX.test(ip);
+}
+function getLocalIPs() {
+  const interfaces = os.networkInterfaces();
+  const ips = [];
+  for (const name of Object.keys(interfaces)) {
+    const iface = interfaces[name];
+    if (iface === void 0) continue;
+    for (const addr of iface) {
+      if (addr.family === "IPv4" && !addr.internal) {
+        ips.push(addr.address);
+      }
+    }
+  }
+  return ips;
+}
+function isPrivateIP(ip) {
+  if (!isValidIPv4(ip)) return false;
+  const parts = ip.split(".").map(Number);
+  return parts[0] === 10 || parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31 || parts[0] === 192 && parts[1] === 168 || parts[0] === 127;
+}
+function isReservedIP(ip) {
+  if (!isValidIPv4(ip)) return false;
+  const parts = ip.split(".").map(Number);
+  if (parts[0] === 0) return true;
+  if (parts[0] === 127) return true;
+  if (parts[0] === 169 && parts[1] === 254) return true;
+  if (parts[0] >= 224) return true;
+  return false;
+}
+function getHostname() {
+  return os.hostname();
+}
+
+// src/tools/network/mac.ts
+import { randomBytes as randomBytes3 } from "crypto";
+var MAC_REGEX = /^([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}$/;
+function isValidMAC(mac) {
+  return MAC_REGEX.test(mac);
+}
+function generateMAC(separator = ":") {
+  const bytes = Array.from(randomBytes3(6), (b) => b.toString(16).padStart(2, "0").toUpperCase());
+  bytes[0] = (parseInt(bytes[0], 16) & 254 | 2).toString(16).padStart(2, "0").toUpperCase();
+  return bytes.join(separator);
+}
+function normalizeMAC(mac, separator = ":") {
+  const clean = mac.replace(/[-:]/g, "").toUpperCase();
+  if (clean.length !== 12) throw new Error("Invalid MAC address length");
+  return clean.match(/.{2}/g).join(separator);
+}
+
+// src/cli.ts
+var VERSION = "1.0.0";
+var log = createLogger();
+var HELP_TEXT = `
+${log.color("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557", "cyan")}
+${log.color("\u2551", "cyan")}          ${log.bold(log.color("devknife", "green"))} \u2014 Developer Swiss Army Knife          ${log.color("\u2551", "cyan")}
+${log.color("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D", "cyan")}
+
+${log.bold("Usage:")}
+  ${log.color("devknife", "green")} <${log.color("tool", "cyan")}> <${log.color("subcommand", "yellow")}> [${log.color("args", "gray")}] [${log.color("--flag", "magenta")}]
+
+${log.bold("Tools:")}
+
+${log.color("  Crypto:", "cyan")}
+    ${log.color("hash", "green")}      ${log.dim("\u2014 Generate hash (md5, sha1, sha256, sha512)")}
+    ${log.color("password", "green")}  ${log.dim("\u2014 Generate secure password")}
+
+${log.color("  Generators:", "cyan")}
+    ${log.color("uuid", "green")}      ${log.dim("\u2014 Generate UUID v4")}
+    ${log.color("nanoid", "green")}    ${log.dim("\u2014 Generate NanoID string")}
+    ${log.color("lorem", "green")}     ${log.dim("\u2014 Generate Lorem Ipsum text")}
+
+${log.color("  Encoders:", "cyan")}
+    ${log.color("base64", "green")}    ${log.dim("\u2014 Base64 encode/decode")}
+    ${log.color("url", "green")}       ${log.dim("\u2014 URL encode/decode")}
+    ${log.color("html", "green")}      ${log.dim("\u2014 HTML entity encode/decode")}
+    ${log.color("jwt", "green")}       ${log.dim("\u2014 Decode JWT token")}
+
+${log.color("  Formatters:", "cyan")}
+    ${log.color("json", "green")}      ${log.dim("\u2014 Format/minify JSON")}
+    ${log.color("text", "green")}      ${log.dim("\u2014 Convert text case (camel, snake, kebab...)")}
+
+${log.color("  Converters:", "cyan")}
+    ${log.color("color", "green")}     ${log.dim("\u2014 Convert colors (hex, rgb, hsl)")}
+    ${log.color("time", "green")}      ${log.dim("\u2014 Convert timestamps")}
+    ${log.color("number", "green")}    ${log.dim("\u2014 Convert number bases (bin, hex, oct)")}
+
+${log.color("  Network:", "cyan")}
+    ${log.color("ip", "green")}        ${log.dim("\u2014 Validate/show IP addresses")}
+    ${log.color("mac", "green")}       ${log.dim("\u2014 Generate/validate MAC addresses")}
+
+${log.bold("Flags:")}
+    ${log.color("-h, --help", "yellow")}     ${log.dim("Show this help message")}
+    ${log.color("-v, --version", "yellow")}  ${log.dim("Show version")}
+    ${log.color("-i, --interactive", "yellow")} ${log.dim("Start interactive mode")}
+    ${log.color("-s, --stdin", "yellow")}     ${log.dim("Read input from stdin")}
+
+${log.bold("Examples:")}
+    ${log.color("$ devknife uuid", "gray")}
+    ${log.color('$ devknife hash sha256 "Hello World"', "gray")}
+    ${log.color('$ devknife base64 encode "hello"', "gray")}
+    ${log.color("$ devknife jwt decode eyJhbGci...", "gray")}
+    ${log.color(`$ echo '{"a":1}' | devknife json format`, "gray")}
+    ${log.color('$ devknife color hex-to-rgb "#ff0000"', "gray")}
+`;
+function getStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) {
+      resolve("");
+      return;
+    }
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      resolve(data.trim());
+    });
+  });
+}
+var tools = {
+  hash: {
+    description: "Generate hash (md5, sha1, sha256, sha512)",
+    usage: "hash <algorithm> <text>",
+    examples: ['hash sha256 "Hello World"', 'hash md5 "test"'],
+    run: (args) => {
+      const algo = args[0] ?? "";
+      const input = args[1] ?? "";
+      if (!algo || !input) {
+        return `Usage: devknife hash <algorithm> <text>
+Algorithms: ${getSupportedAlgorithms().join(", ")}`;
+      }
+      if (!isSupportedAlgorithm(algo)) {
+        throw new Error(`Unsupported algorithm: ${algo}. Use: ${getSupportedAlgorithms().join(", ")}`);
+      }
+      return hash(input, algo);
+    }
+  },
+  password: {
+    description: "Generate secure password",
+    usage: "password [--length N] [--symbols] [--no-ambiguous]",
+    examples: ["password", "password --length 32 --symbols"],
+    run: (args, _flags) => {
+      const lengthIdx = args.indexOf("--length");
+      const length = lengthIdx !== -1 ? parseInt(args[lengthIdx + 1] ?? "16", 10) : 16;
+      const hasSymbols = args.includes("--symbols");
+      const noAmbiguous = args.includes("--no-ambiguous");
+      const pw = generatePassword({ length, numbers: true, symbols: hasSymbols, excludeAmbiguous: noAmbiguous });
+      const entropy = calculateEntropy(pw);
+      const strength = estimateStrength(pw);
+      return `Password: ${pw}
+Length: ${pw.length}
+Entropy: ${entropy} bits
+Strength: ${strength}`;
+    }
+  },
+  uuid: {
+    description: "Generate UUID v4",
+    usage: "uuid [--count N]",
+    examples: ["uuid", "uuid --count 5"],
+    run: (args) => {
+      const countIdx = args.indexOf("--count");
+      const count = countIdx !== -1 ? parseInt(args[countIdx + 1] ?? "1", 10) : 1;
+      if (count === 1) return generateUUID();
+      return generateUUIDs(count).join("\n");
+    }
+  },
+  nanoid: {
+    description: "Generate NanoID string",
+    usage: "nanoid [--size N]",
+    examples: ["nanoid", "nanoid --size 10"],
+    run: (args) => {
+      const sizeIdx = args.indexOf("--size");
+      const size = sizeIdx !== -1 ? parseInt(args[sizeIdx + 1] ?? "21", 10) : 21;
+      return generateNanoID({ size });
+    }
+  },
+  lorem: {
+    description: "Generate Lorem Ipsum text",
+    usage: "lorem <paragraphs|sentences|words> [count]",
+    examples: ["lorem paragraphs 2", "lorem sentences 3", "lorem words 10"],
+    run: (args) => {
+      const type = args[0] ?? "paragraph";
+      const count = parseInt(args[1] ?? "1", 10);
+      switch (type) {
+        case "paragraph":
+        case "paragraphs":
+          return paragraphs(count);
+        case "sentence":
+        case "sentences": {
+          const sentences = [];
+          for (let i = 0; i < count; i++) sentences.push(sentence());
+          return sentences.join(" ");
+        }
+        case "word":
+        case "words":
+          return word(count);
+        case "title":
+          return title();
+        default:
+          return paragraphs(count);
+      }
+    }
+  },
+  base64: {
+    description: "Base64 encode/decode",
+    usage: "base64 <encode|decode> <text>",
+    examples: ['base64 encode "hello"', 'base64 decode "aGVsbG8="'],
+    run: (args, stdinData) => {
+      const subcommand = args[0] ?? "";
+      const input = args[1] ?? stdinData ?? "";
+      if (!subcommand || !input && subcommand) {
+        return "Usage: devknife base64 <encode|decode> <text>";
+      }
+      if (subcommand === "encode") return encode(input);
+      if (subcommand === "decode") return decode(input);
+      throw new SubcommandNotFoundError("base64", subcommand);
+    }
+  },
+  url: {
+    description: "URL encode/decode",
+    usage: "url <encode|decode> <text>",
+    examples: ['url encode "hello world"', 'url decode "hello%20world"'],
+    run: (args) => {
+      const subcommand = args[0] ?? "";
+      const input = args[1] ?? "";
+      if (!subcommand || !input) return "Usage: devknife url <encode|decode> <text>";
+      if (subcommand === "encode") return encode2(input);
+      if (subcommand === "decode") return decode2(input);
+      throw new SubcommandNotFoundError("url", subcommand);
+    }
+  },
+  html: {
+    description: "HTML entity encode/decode",
+    usage: "html <encode|decode> <text>",
+    examples: ['html encode "<div>"', 'html decode "&lt;div&gt;"'],
+    run: (args) => {
+      const subcommand = args[0] ?? "";
+      const input = args[1] ?? "";
+      if (!subcommand || !input) return "Usage: devknife html <encode|decode> <text>";
+      if (subcommand === "encode") return encode3(input);
+      if (subcommand === "decode") return decode3(input);
+      throw new SubcommandNotFoundError("html", subcommand);
+    }
+  },
+  jwt: {
+    description: "Decode JWT token",
+    usage: "jwt decode <token>",
+    examples: ["jwt decode eyJhbGciOiJIUzI1NiJ9..."],
+    run: (args) => {
+      const subcommand = args[0] ?? "";
+      const token = args[1] ?? "";
+      if (!subcommand || !token) return "Usage: devknife jwt decode <token>";
+      if (subcommand === "decode") {
+        try {
+          const result = decode4(token);
+          return `Header:
+${JSON.stringify(result.header, null, 2)}
+
+Payload:
+${JSON.stringify(result.payload, null, 2)}`;
+        } catch (err) {
+          return `Error: ${err instanceof Error ? err.message : "Invalid token"}`;
+        }
+      }
+      throw new SubcommandNotFoundError("jwt", subcommand);
+    }
+  },
+  json: {
+    description: "Format/minify JSON",
+    usage: "json <format|minify|validate> [json]",
+    examples: [`json format '{"a":1}'`, `json minify '{"a": 1}'`],
+    run: (args, stdinData) => {
+      const subcommand = args[0] ?? "";
+      const input = args[1] ?? stdinData ?? "";
+      if (!subcommand || !input && subcommand) {
+        return "Usage: devknife json <format|minify|validate|sort> [json]";
+      }
+      try {
+        if (subcommand === "format" || subcommand === "prettify") return format(input);
+        if (subcommand === "minify" || subcommand === "compact") return minify(input);
+        if (subcommand === "validate") {
+          const result = validate(input);
+          if (result.valid) return "\u2713 Valid JSON";
+          return `\u2717 Invalid JSON: ${result.error}`;
+        }
+        if (subcommand === "sort") return sortByKeys(input);
+        throw new SubcommandNotFoundError("json", subcommand);
+      } catch (err) {
+        return `Error: ${err instanceof Error ? err.message : "Invalid JSON"}`;
+      }
+    }
+  },
+  text: {
+    description: "Convert text case",
+    usage: "text <case> <text>",
+    examples: ['text camel "hello world"', 'text snake "helloWorld"', 'text kebab "hello World"'],
+    run: (args) => {
+      const caseType = args[0] ?? "";
+      const input = args[1] ?? "";
+      if (!caseType || !input) return "Usage: devknife text <camel|snake|kebab|pascal|constant|title|upper|lower|sentence|reverse> <text>";
+      const cases = {
+        camel: camelCase,
+        snake: snakeCase,
+        kebab: kebabCase,
+        pascal: pascalCase,
+        constant: constantCase,
+        title: titleCase,
+        upper: upperCase,
+        lower: lowerCase,
+        sentence: sentenceCase,
+        reverse: reverseCase,
+        dot: dotCase,
+        slug: slugify
+      };
+      const fn = cases[caseType];
+      if (!fn) throw new SubcommandNotFoundError("text", caseType);
+      return fn(input);
+    }
+  },
+  color: {
+    description: "Convert colors (hex, rgb, hsl)",
+    usage: "color <conversion> <value>",
+    examples: ['color hex-to-rgb "#ff0000"', "color rgb-to-hex 255 0 0"],
+    run: (args) => {
+      const conversion = args[0] ?? "";
+      if (!conversion) return "Usage: devknife color <hex-to-rgb|rgb-to-hex|rgb-to-hsl|hsl-to-hex|is-light> <value>";
+      try {
+        switch (conversion) {
+          case "hex-to-rgb": {
+            const result = hexToRgb(args[1] ?? "");
+            return `RGB: r=${result.r}, g=${result.g}, b=${result.b}`;
+          }
+          case "rgb-to-hex":
+            return rgbToHex(
+              parseInt(args[1] ?? "0", 10),
+              parseInt(args[2] ?? "0", 10),
+              parseInt(args[3] ?? "0", 10)
+            );
+          case "rgb-to-hsl": {
+            const result = rgbToHsl(
+              parseInt(args[1] ?? "0", 10),
+              parseInt(args[2] ?? "0", 10),
+              parseInt(args[3] ?? "0", 10)
+            );
+            return `HSL: h=${result.h}\xB0, s=${result.s}%, l=${result.l}%`;
+          }
+          case "hex-to-hsl": {
+            const result = hexToHsl(args[1] ?? "");
+            return `HSL: h=${result.h}\xB0, s=${result.s}%, l=${result.l}%`;
+          }
+          case "hsl-to-hex":
+            return hslToHex(
+              parseInt(args[1] ?? "0", 10),
+              parseInt(args[2] ?? "0", 10),
+              parseInt(args[3] ?? "0", 10)
+            );
+          case "hsl-to-rgb": {
+            const result = hslToRgb(
+              parseInt(args[1] ?? "0", 10),
+              parseInt(args[2] ?? "0", 10),
+              parseInt(args[3] ?? "0", 10)
+            );
+            return `RGB: r=${result.r}, g=${result.g}, b=${result.b}`;
+          }
+          case "is-light": {
+            const light = isLightColor(args[1] ?? "");
+            return light ? "Light color" : "Dark color";
+          }
+          default:
+            throw new SubcommandNotFoundError("color", conversion);
+        }
+      } catch (err) {
+        return `Error: ${err instanceof Error ? err.message : "Invalid input"}`;
+      }
+    }
+  },
+  time: {
+    description: "Convert timestamps",
+    usage: "time <conversion> <value>",
+    examples: ["time epoch-to-iso 1672531200", 'time iso-to-epoch "2023-01-01T00:00:00Z"', "time now"],
+    run: (args) => {
+      const conversion = args[0] ?? "";
+      if (!conversion) return "Usage: devknife time <epoch-to-iso|iso-to-epoch|now|time-ago|format> <value>";
+      try {
+        switch (conversion) {
+          case "epoch-to-iso":
+            return epochToIso(parseInt(args[1] ?? "0", 10));
+          case "iso-to-epoch":
+            return isoToEpoch(args[1] ?? "").toString();
+          case "now":
+            return `${nowIso()} (epoch: ${nowEpoch()})`;
+          case "time-ago":
+            return timeAgo(parseInt(args[1] ?? "0", 10));
+          case "format": {
+            const fmt = args[2] ?? "YYYY-MM-DD HH:mm:ss";
+            return formatDate(args[1] ?? "", fmt);
+          }
+          case "week":
+            return `Week ${getWeekNumber(args[1] ?? (/* @__PURE__ */ new Date()).toISOString())}`;
+          default:
+            throw new SubcommandNotFoundError("time", conversion);
+        }
+      } catch (err) {
+        return `Error: ${err instanceof Error ? err.message : "Invalid input"}`;
+      }
+    }
+  },
+  number: {
+    description: "Convert number bases",
+    usage: "number <conversion> <value>",
+    examples: ["number dec-to-bin 42", "number bin-to-dec 101010", "number dec-to-hex 255"],
+    run: (args) => {
+      const conversion = args[0] ?? "";
+      if (!conversion) return "Usage: devknife number <dec-to-bin|bin-to-dec|dec-to-hex|hex-to-dec|dec-to-oct|oct-to-dec|format-bytes> <value>";
+      try {
+        switch (conversion) {
+          case "dec-to-bin":
+            return decimalToBinary(parseInt(args[1] ?? "0", 10));
+          case "bin-to-dec":
+            return binaryToDecimal(args[1] ?? "0").toString();
+          case "dec-to-hex":
+            return decimalToHex(parseInt(args[1] ?? "0", 10));
+          case "hex-to-dec":
+            return hexToDecimal(args[1] ?? "0").toString();
+          case "dec-to-oct":
+            return decimalToOctal(parseInt(args[1] ?? "0", 10)).toString();
+          case "oct-to-dec":
+            return octalToDecimal(args[1] ?? "0").toString();
+          case "hex-to-bin":
+            return hexToBinary(args[1] ?? "0");
+          case "bin-to-hex":
+            return binaryToHex(args[1] ?? "0");
+          case "format-bytes":
+            return formatBytes(parseInt(args[1] ?? "0", 10));
+          default:
+            throw new SubcommandNotFoundError("number", conversion);
+        }
+      } catch (err) {
+        return `Error: ${err instanceof Error ? err.message : "Invalid input"}`;
+      }
+    }
+  },
+  ip: {
+    description: "Validate/show IP addresses",
+    usage: "ip <validate|local|private|reserved|hostname>",
+    examples: ["ip validate 192.168.1.1", "ip local", "ip hostname"],
+    run: (args) => {
+      const subcommand = args[0] ?? "";
+      if (!subcommand) return "Usage: devknife ip <validate|local|private|reserved|hostname> [address]";
+      switch (subcommand) {
+        case "validate":
+        case "is-valid": {
+          const ip = args[1] ?? "";
+          if (!ip) return "Please provide an IP address";
+          if (isValidIPv4(ip)) return `${ip} is a valid IPv4 address`;
+          if (isValidIPv6(ip)) return `${ip} is a valid IPv6 address`;
+          return `${ip} is not a valid IP address`;
+        }
+        case "local": {
+          const ips = getLocalIPs();
+          return ips.length > 0 ? ips.join("\n") : "No local IPs found";
+        }
+        case "private": {
+          const ip = args[1] ?? "";
+          if (!ip) return "Please provide an IP address";
+          return isPrivateIP(ip) ? `${ip} is a private IP` : `${ip} is a public IP`;
+        }
+        case "reserved": {
+          const ip = args[1] ?? "";
+          if (!ip) return "Please provide an IP address";
+          return isReservedIP(ip) ? `${ip} is reserved` : `${ip} is not reserved`;
+        }
+        case "hostname":
+          return getHostname();
+        default:
+          throw new SubcommandNotFoundError("ip", subcommand);
+      }
+    }
+  },
+  mac: {
+    description: "Generate/validate MAC address",
+    usage: "mac <generate|validate|normalize> [address]",
+    examples: ["mac generate", 'mac validate "00:1A:2B:3C:4D:5E"'],
+    run: (args) => {
+      const subcommand = args[0] ?? "";
+      if (!subcommand) return "Usage: devknife mac <generate|validate|normalize> [address]";
+      switch (subcommand) {
+        case "generate": {
+          const sep = args[1] ?? ":";
+          return generateMAC(sep);
+        }
+        case "validate": {
+          const mac = args[1] ?? "";
+          if (!mac) return "Please provide a MAC address";
+          return isValidMAC(mac) ? `${mac} is a valid MAC address` : `${mac} is not a valid MAC address`;
+        }
+        case "normalize": {
+          const mac = args[1] ?? "";
+          const sep = args[2] ?? ":";
+          if (!mac) return "Please provide a MAC address";
+          return normalizeMAC(mac, sep);
+        }
+        default:
+          throw new SubcommandNotFoundError("mac", subcommand);
+      }
+    }
+  }
+};
+async function main() {
+  const parsed = parse();
+  if (parsed.flags["help"] || parsed.flags["h"]) {
+    log.raw(HELP_TEXT);
+    return;
+  }
+  if (parsed.flags["version"] || parsed.flags["v"]) {
+    log.raw(`devknife v${VERSION}`);
+    return;
+  }
+  if (parsed.flags["interactive"] || parsed.flags["i"] || !parsed.command) {
+    const options = Object.entries(tools).map(([name, tool2]) => ({
+      label: name,
+      value: name,
+      description: tool2.description
+    }));
+    await startInteractive({
+      logger: log,
+      menuTitle: "\u{1F52A} devknife \u2014 Interactive Mode",
+      options,
+      onExit: () => {
+      },
+      onSelect: async (value, promptInput) => {
+        const tool2 = tools[value];
+        if (!tool2) {
+          log.error(`Tool not found: ${value}`);
+          return;
+        }
+        log.newline();
+        log.info(`Tool: ${value}`);
+        log.dim(`Usage: ${tool2.usage}`);
+        log.dim(`Examples: ${tool2.examples.join(", ")}`);
+        log.newline();
+        if (promptInput) {
+          const input = await promptInput(log.color("Enter input (or press Enter to skip): ", "cyan"));
+          if (input.trim()) {
+            const result2 = tool2.run([input.trim()], "");
+            if (result2) log.raw(result2);
+          }
+        }
+      }
+    });
+    return;
+  }
+  const tool = tools[parsed.command];
+  if (!tool) {
+    throw new ToolNotFoundError(parsed.command);
+  }
+  const stdinData = await getStdin();
+  const args = parsed.subcommand ? [parsed.subcommand, ...parsed.args] : [...parsed.args];
+  const result = tool.run(args, stdinData);
+  if (result) {
+    log.raw(result);
+  }
+}
+main().catch((error) => {
+  handleError(error);
+});