@jvittechs/jai1-cli 0.1.59 → 0.1.61

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command as Command26 } from "commander";
+import { Command as Command40 } from "commander";
 
 // src/errors/index.ts
 var Jai1Error = class extends Error {
@@ -33,7 +33,7 @@ var NetworkError = class extends Jai1Error {
 // package.json
 var package_default = {
   name: "@jvittechs/jai1-cli",
-  version: "0.1.59",
+  version: "0.1.61",
   description: "Unified CLI for Jai1 Framework Management and Redmine Context Sync",
   type: "module",
   bin: {
@@ -80,13 +80,17 @@ var package_default = {
   dependencies: {
     "@inquirer/prompts": "^8.0.2",
     "adm-zip": "^0.5.16",
+    bcryptjs: "^2.4.3",
     "cli-progress": "^3.12.0",
     clipboardy: "^4.0.0",
     commander: "^12.1.0",
+    cronstrue: "^2.50.0",
     "gray-matter": "^4.0.3",
     ink: "^5.0.1",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
+    marked: "^12.0.0",
+    "marked-terminal": "^7.0.0",
     "p-limit": "^5.0.0",
     "p-queue": "^7.4.1",
     "p-retry": "^6.2.0",
@@ -191,8 +195,13 @@ var colors = {
 };
 var lastCheckTime = 0;
 var cachedLatestVersion = null;
+var shouldCheckUpdates = true;
 var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
+function disableUpdateCheck() {
+  shouldCheckUpdates = false;
+}
 async function checkForClientUpdate() {
+  if (!shouldCheckUpdates) return;
   try {
     const now = Date.now();
     if (now - lastCheckTime < CHECK_INTERVAL_MS && cachedLatestVersion) {
@@ -4785,8 +4794,850 @@ function createTranslateCommand() {
   return cmd;
 }
 
-// src/commands/upgrade.ts
+// src/commands/utils/index.ts
+import { Command as Command27 } from "commander";
+
+// src/commands/utils/password.ts
 import { Command as Command14 } from "commander";
+
+// src/services/utils.service.ts
+import crypto from "crypto";
+import bcrypt from "bcryptjs";
+import { readFile } from "fs/promises";
+var UtilsService = class {
+  /**
+   * Generate secure random password
+   */
+  generatePassword(options) {
+    const {
+      length,
+      lowercase,
+      uppercase,
+      digits,
+      symbols,
+      symbolChars = "!@#$%^&*()_+-=[]{}|;:,.<>?"
+    } = options;
+    let charset = "";
+    if (lowercase) charset += "abcdefghijklmnopqrstuvwxyz";
+    if (uppercase) charset += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    if (digits) charset += "0123456789";
+    if (symbols) charset += symbolChars;
+    if (charset.length === 0) {
+      throw new Error("At least one character type must be enabled");
+    }
+    const randomBytes = crypto.randomBytes(length);
+    let password = "";
+    for (let i = 0; i < length; i++) {
+      const randomIndex = randomBytes[i] % charset.length;
+      password += charset[randomIndex];
+    }
+    return password;
+  }
+  /**
+   * Generate UUID v4
+   */
+  generateUuid(options) {
+    let uuid = crypto.randomUUID();
+    if (options?.uppercase) {
+      uuid = uuid.toUpperCase();
+    }
+    if (options?.noHyphens) {
+      uuid = uuid.replace(/-/g, "");
+    }
+    return uuid;
+  }
+  /**
+   * Hash text or file using specified algorithm
+   */
+  async hash(input, algorithm) {
+    if (algorithm === "bcrypt") {
+      throw new Error("Use hashBcrypt for bcrypt algorithm");
+    }
+    const hash = crypto.createHash(algorithm);
+    hash.update(input);
+    return hash.digest("hex");
+  }
+  /**
+   * Hash file contents
+   */
+  async hashFile(filePath, algorithm) {
+    const content = await readFile(filePath);
+    return this.hash(content, algorithm);
+  }
+  /**
+   * Hash using bcrypt
+   */
+  async hashBcrypt(input, rounds = 10) {
+    return bcrypt.hash(input, rounds);
+  }
+  /**
+   * Base64 encode
+   */
+  base64Encode(input, urlSafe = false) {
+    const buffer = typeof input === "string" ? Buffer.from(input, "utf-8") : input;
+    let encoded = buffer.toString("base64");
+    if (urlSafe) {
+      encoded = encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    }
+    return encoded;
+  }
+  /**
+   * Base64 decode
+   */
+  base64Decode(input) {
+    let normalized = input.replace(/-/g, "+").replace(/_/g, "/");
+    while (normalized.length % 4) {
+      normalized += "=";
+    }
+    return Buffer.from(normalized, "base64");
+  }
+  /**
+   * Make HTTP request with detailed output
+   */
+  async httpRequest(url, options) {
+    const startTime = performance.now();
+    const fetchOptions = {
+      method: options.method,
+      headers: options.headers,
+      body: options.body,
+      signal: options.timeout ? AbortSignal.timeout(options.timeout) : void 0,
+      redirect: options.followRedirects === false ? "manual" : "follow"
+    };
+    const response = await fetch(url, fetchOptions);
+    const body = await response.text();
+    const endTime = performance.now();
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+      body,
+      timing: Math.round(endTime - startTime),
+      size: Buffer.byteLength(body, "utf-8")
+    };
+  }
+  /**
+   * Decode JWT (no verification)
+   */
+  jwtDecode(token) {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+      throw new Error("Invalid JWT format");
+    }
+    const [headerB64, payloadB64, signature] = parts;
+    const header = JSON.parse(this.base64Decode(headerB64).toString("utf-8"));
+    const payload = JSON.parse(this.base64Decode(payloadB64).toString("utf-8"));
+    return { header, payload, signature };
+  }
+  /**
+   * Encode JWT (HS256 only)
+   */
+  jwtEncode(payload, secret, header) {
+    const defaultHeader = { alg: "HS256", typ: "JWT" };
+    const finalHeader = { ...defaultHeader, ...header };
+    const headerB64 = this.base64Encode(JSON.stringify(finalHeader), true);
+    const payloadB64 = this.base64Encode(JSON.stringify(payload), true);
+    const signatureInput = `${headerB64}.${payloadB64}`;
+    const signature = crypto.createHmac("sha256", secret).update(signatureInput).digest("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    return `${headerB64}.${payloadB64}.${signature}`;
+  }
+  /**
+   * Convert unix timestamp to date
+   */
+  unixToDate(timestamp, milliseconds = false) {
+    return new Date(milliseconds ? timestamp : timestamp * 1e3);
+  }
+  /**
+   * Convert date to unix timestamp
+   */
+  dateToUnix(date, milliseconds = false) {
+    const timestamp = date.getTime();
+    return milliseconds ? timestamp : Math.floor(timestamp / 1e3);
+  }
+  /**
+   * Convert time between timezones
+   */
+  convertTimezone(time, fromTimezone, toTimezone) {
+    const date = typeof time === "string" ? new Date(time) : time;
+    const formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone: toTimezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false
+    });
+    const parts = formatter.formatToParts(date);
+    const dateParts = parts.reduce((acc, part) => {
+      if (part.type !== "literal") {
+        acc[part.type] = part.value;
+      }
+      return acc;
+    }, {});
+    const time24 = `${dateParts.year}-${dateParts.month}-${dateParts.day} ${dateParts.hour}:${dateParts.minute}:${dateParts.second}`;
+    return {
+      time: time24,
+      iso: date.toISOString()
+    };
+  }
+  /**
+   * Get list of available timezones
+   */
+  getTimezones() {
+    return [
+      "UTC",
+      "America/New_York",
+      "America/Chicago",
+      "America/Denver",
+      "America/Los_Angeles",
+      "America/Sao_Paulo",
+      "Europe/London",
+      "Europe/Paris",
+      "Europe/Berlin",
+      "Europe/Moscow",
+      "Asia/Dubai",
+      "Asia/Kolkata",
+      "Asia/Bangkok",
+      "Asia/Shanghai",
+      "Asia/Tokyo",
+      "Asia/Seoul",
+      "Asia/Ho_Chi_Minh",
+      "Australia/Sydney",
+      "Pacific/Auckland"
+    ];
+  }
+  /**
+   * URL encode
+   */
+  urlEncode(input, full = false) {
+    return full ? encodeURI(input) : encodeURIComponent(input);
+  }
+  /**
+   * URL decode
+   */
+  urlDecode(input, full = false) {
+    return full ? decodeURI(input) : decodeURIComponent(input);
+  }
+  /**
+   * Format bytes to human-readable size
+   */
+  formatBytes(bytes) {
+    if (bytes === 0) return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+  }
+};
+
+// src/commands/utils/password.ts
+async function handlePasswordGeneration(options) {
+  const service = new UtilsService();
+  try {
+    const passwords = [];
+    for (let i = 0; i < options.count; i++) {
+      const password = service.generatePassword({
+        length: options.length,
+        lowercase: options.lowercase,
+        uppercase: options.uppercase,
+        digits: options.digits,
+        symbols: options.symbols,
+        symbolChars: options.symbolChars
+      });
+      passwords.push(password);
+    }
+    console.log("\u{1F510} Generated Password(s):");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+    passwords.forEach((password, index) => {
+      if (options.count > 1) {
+        console.log(`   ${index + 1}. ${password}`);
+      } else {
+        console.log(`   ${password}`);
+      }
+    });
+    console.log();
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function createPasswordCommand() {
+  const cmd = new Command14("password").description("Generate secure random password").option("-l, --length <number>", "Password length", "16").option("--no-lowercase", "Exclude lowercase letters").option("--no-uppercase", "Exclude uppercase letters").option("--no-digits", "Exclude digits").option("--no-symbols", "Exclude symbols").option("--symbol-chars <chars>", "Custom symbol characters").option("-c, --count <number>", "Number of passwords to generate", "1").action(async (options) => {
+    await handlePasswordGeneration({
+      ...options,
+      length: parseInt(options.length, 10),
+      count: parseInt(options.count, 10)
+    });
+  });
+  return cmd;
+}
+
+// src/commands/utils/uuid.ts
+import { Command as Command15 } from "commander";
+async function handleUuidGeneration(options) {
+  const service = new UtilsService();
+  try {
+    const uuids = [];
+    for (let i = 0; i < options.count; i++) {
+      const uuid = service.generateUuid({
+        uppercase: options.uppercase,
+        noHyphens: options.noHyphens
+      });
+      uuids.push(uuid);
+    }
+    console.log("\u{1F194} Generated UUID(s):");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+    uuids.forEach((uuid, index) => {
+      if (options.count > 1) {
+        console.log(`   ${index + 1}. ${uuid}`);
+      } else {
+        console.log(`   ${uuid}`);
+      }
+    });
+    console.log();
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function createUuidCommand() {
+  const cmd = new Command15("uuid").description("Generate UUID v4 identifier").option("-c, --count <number>", "Number of UUIDs to generate", "1").option("--uppercase", "Output in uppercase").option("--no-hyphens", "Remove hyphens from output").action(async (options) => {
+    await handleUuidGeneration({
+      ...options,
+      count: parseInt(options.count, 10)
+    });
+  });
+  return cmd;
+}
+
+// src/commands/utils/hash.ts
+import { Command as Command16 } from "commander";
+async function handleHashGeneration(input, options) {
+  const service = new UtilsService();
+  try {
+    let hash;
+    if (options.file) {
+      if (options.algorithm === "bcrypt") {
+        console.error("\u274C bcrypt cannot be used with files (it requires string input)");
+        process.exit(1);
+      }
+      hash = await service.hashFile(options.file, options.algorithm);
+    } else {
+      if (!input) {
+        console.error("\u274C Please provide input text or use --file option");
+        process.exit(1);
+      }
+      if (options.algorithm === "bcrypt") {
+        hash = await service.hashBcrypt(input, options.rounds);
+      } else {
+        hash = await service.hash(input, options.algorithm);
+      }
+    }
+    console.log("\u{1F512} Hash Result:");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log(`   Algorithm: ${options.algorithm.toUpperCase()}`);
+    if (options.file) {
+      console.log(`   File: ${options.file}`);
+    }
+    if (options.algorithm === "bcrypt") {
+      console.log(`   Rounds: ${options.rounds}`);
+    }
+    console.log();
+    console.log(`   ${hash}`);
+    console.log();
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function createHashCommand() {
+  const cmd = new Command16("hash").description("Generate hash (MD5, SHA, bcrypt)").argument("[input]", "Text to hash").option(
+    "-a, --algorithm <algorithm>",
+    "Hash algorithm (md5, sha1, sha256, sha512, bcrypt)",
+    "sha256"
+  ).option("-f, --file <path>", "Hash file contents instead of text").option("-r, --rounds <number>", "Bcrypt rounds (only for bcrypt)", "10").action(async (input, options) => {
+    await handleHashGeneration(input, {
+      ...options,
+      rounds: parseInt(options.rounds, 10)
+    });
+  });
+  return cmd;
+}
+
+// src/commands/utils/base64-encode.ts
+import { Command as Command17 } from "commander";
+import { readFile as readFile2 } from "fs/promises";
+async function handleBase64Encode(input, options) {
+  const service = new UtilsService();
+  try {
+    let encoded;
+    if (options.file) {
+      const content = await readFile2(options.file);
+      encoded = service.base64Encode(content, options.urlSafe);
+    } else {
+      if (!input) {
+        console.error("\u274C Please provide input text or use --file option");
+        process.exit(1);
+      }
+      encoded = service.base64Encode(input, options.urlSafe);
+    }
+    console.log("\u{1F4DD} Base64 Encoded:");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    if (options.file) {
+      console.log(`   File: ${options.file}`);
+    }
+    if (options.urlSafe) {
+      console.log(`   Format: URL-safe`);
+    }
+    console.log();
+    console.log(`   ${encoded}`);
+    console.log();
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function createBase64EncodeCommand() {
+  const cmd = new Command17("base64-encode").description("Encode text or file to Base64").argument("[input]", "Text to encode").option("-f, --file <path>", "Encode file contents").option("--url-safe", "Use URL-safe Base64 encoding").action(async (input, options) => {
+    await handleBase64Encode(input, options);
+  });
+  return cmd;
+}
+
+// src/commands/utils/base64-decode.ts
+import { Command as Command18 } from "commander";
+import { readFile as readFile3, writeFile } from "fs/promises";
+async function handleBase64Decode(input, options) {
+  const service = new UtilsService();
+  try {
+    let encodedInput;
+    if (options.file) {
+      encodedInput = await readFile3(options.file, "utf-8");
+    } else {
+      if (!input) {
+        console.error("\u274C Please provide Base64 input or use --file option");
+        process.exit(1);
+      }
+      encodedInput = input;
+    }
+    const decoded = service.base64Decode(encodedInput.trim());
+    if (options.output) {
+      await writeFile(options.output, decoded);
+      console.log("\u2705 Decoded and saved to:", options.output);
+    } else {
+      console.log("\u{1F4DD} Base64 Decoded:");
+      console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      console.log();
+      console.log(`   ${decoded.toString("utf-8")}`);
+      console.log();
+    }
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function createBase64DecodeCommand() {
+  const cmd = new Command18("base64-decode").description("Decode Base64 string").argument("[input]", "Base64 string to decode").option("-f, --file <path>", "Decode from file").option("-o, --output <path>", "Write decoded output to file").action(async (input, options) => {
+    await handleBase64Decode(input, options);
+  });
+  return cmd;
+}
+
+// src/commands/utils/http.ts
+import { Command as Command19 } from "commander";
+import { readFile as readFile4 } from "fs/promises";
+async function handleHttpRequest(url, options) {
+  const service = new UtilsService();
+  try {
+    const headers = {};
+    if (options.header) {
+      options.header.forEach((header) => {
+        const [key, ...valueParts] = header.split(":");
+        if (key && valueParts.length > 0) {
+          headers[key.trim()] = valueParts.join(":").trim();
+        }
+      });
+    }
+    let body;
+    if (options.file) {
+      body = await readFile4(options.file, "utf-8");
+    } else if (options.data) {
+      body = options.data;
+    }
+    const response = await service.httpRequest(url, {
+      method: options.method.toUpperCase(),
+      headers,
+      body,
+      timeout: options.timeout,
+      followRedirects: !options.noFollow
+    });
+    if (!options.onlyBody) {
+      console.log(`HTTP/${response.status >= 200 && response.status < 300 ? "1.1" : "1.0"} ${response.status} ${response.statusText}`);
+      console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      console.log(`\u{1F4CA} Status: ${response.status} ${response.statusText}`);
+      console.log(`\u23F1\uFE0F  Time: ${response.timing}ms`);
+      console.log(`\u{1F4E6} Size: ${service.formatBytes(response.size)}`);
+      console.log();
+    }
+    if (!options.onlyBody && !options.onlyHeaders) {
+      console.log("\u{1F4CB} Headers:");
+      Object.entries(response.headers).forEach(([key, value]) => {
+        console.log(`   ${key}: ${value}`);
+      });
+      console.log();
+    }
+    if (options.onlyHeaders) {
+      Object.entries(response.headers).forEach(([key, value]) => {
+        console.log(`${key}: ${value}`);
+      });
+      return;
+    }
+    if (!options.onlyHeaders) {
+      if (!options.onlyBody) {
+        console.log("\u{1F4C4} Body:");
+      }
+      try {
+        const json = JSON.parse(response.body);
+        console.log(JSON.stringify(json, null, 2));
+      } catch {
+        console.log(response.body);
+      }
+      console.log();
+    }
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function createHttpCommand() {
+  const cmd = new Command19("http").description("Make HTTP request with formatted output").argument("<url>", "Target URL").option("-X, --method <method>", "HTTP method", "GET").option("-H, --header <header...>", "Request headers (repeatable)").option("-d, --data <data>", "Request body (JSON string)").option("--file <path>", "Read body from file").option("--timeout <ms>", "Request timeout in milliseconds", "30000").option("--no-follow", "Do not follow redirects").option("--only-headers", "Show only response headers").option("--only-body", "Show only response body").action(async (url, options) => {
+    await handleHttpRequest(url, {
+      ...options,
+      timeout: parseInt(options.timeout, 10)
+    });
+  });
+  return cmd;
+}
+
+// src/commands/utils/jwt.ts
+import { Command as Command20 } from "commander";
+async function handleJwtDecode(token) {
+  const service = new UtilsService();
+  try {
+    const { header, payload, signature } = service.jwtDecode(token);
+    console.log("\u{1F513} JWT Decoded:");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+    console.log("\u{1F4CB} Header:");
+    console.log(JSON.stringify(header, null, 2));
+    console.log();
+    console.log("\u{1F4C4} Payload:");
+    console.log(JSON.stringify(payload, null, 2));
+    console.log();
+    console.log("\u{1F50F} Signature:");
+    console.log(`   ${signature}`);
+    console.log();
+    console.log("\u26A0\uFE0F  Note: Token signature is not verified");
+    console.log();
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+async function handleJwtEncode(options) {
+  const service = new UtilsService();
+  try {
+    const payload = JSON.parse(options.payload);
+    const header = options.header ? JSON.parse(options.header) : void 0;
+    const token = service.jwtEncode(payload, options.secret, header);
+    console.log("\u{1F510} JWT Encoded:");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+    console.log(`   ${token}`);
+    console.log();
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function createJwtCommand() {
+  const jwtCommand = new Command20("jwt").description("Decode and encode JWT tokens");
+  jwtCommand.command("decode").description("Decode JWT token").argument("<token>", "JWT token to decode").action(async (token) => {
+    await handleJwtDecode(token);
+  });
+  jwtCommand.command("encode").description("Encode JWT token (HS256)").requiredOption("-p, --payload <json>", "Payload as JSON string").requiredOption("-s, --secret <secret>", "Secret key for signing").option("-h, --header <json>", "Custom header as JSON string").action(async (options) => {
+    await handleJwtEncode(options);
+  });
+  return jwtCommand;
+}
+
+// src/commands/utils/unix-time.ts
+import { Command as Command21 } from "commander";
+async function handleUnixTime(input, options) {
+  const service = new UtilsService();
+  try {
+    if (!input) {
+      const now = /* @__PURE__ */ new Date();
+      const timestamp = service.dateToUnix(now, options.ms);
+      console.log("\u{1F552} Current Unix Timestamp:");
+      console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      console.log(`   ${timestamp}${options.ms ? " (milliseconds)" : ""}`);
+      console.log();
+      console.log(`   ISO: ${now.toISOString()}`);
+      console.log(`   Local: ${now.toLocaleString()}`);
+      console.log();
+    } else if (/^\d+$/.test(input)) {
+      const timestamp = parseInt(input, 10);
+      const date = service.unixToDate(timestamp, options.ms);
+      console.log("\u{1F552} Unix Timestamp to Date:");
+      console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      console.log(`   Input: ${timestamp}${options.ms ? " (ms)" : ""}`);
+      console.log();
+      if (options.format === "iso" || options.format === "utc") {
+        console.log(`   ${date.toISOString()}`);
+      } else {
+        console.log(`   ${date.toLocaleString()}`);
+      }
+      console.log();
+    } else {
+      const date = new Date(input);
+      if (isNaN(date.getTime())) {
+        console.error("\u274C Invalid date format");
+        process.exit(1);
+      }
+      const timestamp = service.dateToUnix(date, options.ms);
+      console.log("\u{1F552} Date to Unix Timestamp:");
+      console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      console.log(`   Input: ${input}`);
+      console.log(`   Parsed: ${date.toISOString()}`);
+      console.log();
+      console.log(`   ${timestamp}${options.ms ? " (ms)" : ""}`);
+      console.log();
+    }
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function createUnixTimeCommand() {
+  const cmd = new Command21("unix-time").description("Convert unix timestamps to/from dates").argument("[input]", "Unix timestamp or date string").option("-f, --format <format>", "Output format (iso, local, utc)", "iso").option("--ms", "Use milliseconds instead of seconds").action(async (input, options) => {
+    await handleUnixTime(input, options);
+  });
+  return cmd;
+}
+
+// src/commands/utils/timezone.ts
+import { Command as Command22 } from "commander";
+async function handleTimezoneConversion(time, options) {
+  const service = new UtilsService();
+  try {
+    if (options.list) {
+      console.log("\u{1F30D} Available Timezones:");
+      console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+      const timezones = service.getTimezones();
+      timezones.forEach((tz) => {
+        console.log(`   ${tz}`);
+      });
+      console.log();
+      return;
+    }
+    if (!time) {
+      console.error("\u274C Please provide time to convert or use --list to see available timezones");
+      process.exit(1);
+    }
+    if (!options.from || !options.to) {
+      console.error("\u274C Please provide both --from and --to timezones");
+      process.exit(1);
+    }
+    const result = service.convertTimezone(time, options.from, options.to);
+    console.log("\u{1F30D} Timezone Conversion:");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log(`   From: ${options.from}`);
+    console.log(`   To: ${options.to}`);
+    console.log();
+    console.log(`   ${result.time}`);
+    console.log(`   ISO: ${result.iso}`);
+    console.log();
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function createTimezoneCommand() {
+  const cmd = new Command22("timezone").description("Convert time between timezones").argument("[time]", 'Time to convert (e.g., "2024-01-15 10:00")').option("--from <timezone>", "Source timezone").option("--to <timezone>", "Target timezone").option("--list", "Show available timezones").action(async (time, options) => {
+    await handleTimezoneConversion(time, options);
+  });
+  return cmd;
+}
+
+// src/commands/utils/url-encode.ts
+import { Command as Command23 } from "commander";
+async function handleUrlEncode(input, options) {
+  const service = new UtilsService();
+  try {
+    const encoded = service.urlEncode(input, options.full);
+    console.log("\u{1F517} URL Encoded:");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    if (options.full) {
+      console.log("   Mode: Full URL (encodeURI)");
+    } else {
+      console.log("   Mode: Component (encodeURIComponent)");
+    }
+    console.log();
+    console.log(`   ${encoded}`);
+    console.log();
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function createUrlEncodeCommand() {
+  const cmd = new Command23("url-encode").description("Encode URL component or full URL").argument("<input>", "Text to encode").option("--full", "Encode full URL (use encodeURI instead of encodeURIComponent)").action(async (input, options) => {
+    await handleUrlEncode(input, options);
+  });
+  return cmd;
+}
+
+// src/commands/utils/url-decode.ts
+import { Command as Command24 } from "commander";
+async function handleUrlDecode(input, options) {
+  const service = new UtilsService();
+  try {
+    const decoded = service.urlDecode(input, options.full);
+    console.log("\u{1F517} URL Decoded:");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    if (options.full) {
+      console.log("   Mode: Full URL (decodeURI)");
+    } else {
+      console.log("   Mode: Component (decodeURIComponent)");
+    }
+    console.log();
+    console.log(`   ${decoded}`);
+    console.log();
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function createUrlDecodeCommand() {
+  const cmd = new Command24("url-decode").description("Decode URL-encoded string").argument("<input>", "Text to decode").option("--full", "Decode full URL (use decodeURI instead of decodeURIComponent)").action(async (input, options) => {
+    await handleUrlDecode(input, options);
+  });
+  return cmd;
+}
+
+// src/commands/utils/cron.ts
+import { Command as Command25 } from "commander";
+import cronstrue from "cronstrue";
+async function handleCronParse(expression) {
+  try {
+    const description = cronstrue.toString(expression);
+    console.log("\u23F0 Cron Expression Parser:");
+    console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log(`   Expression: ${expression}`);
+    console.log(`   Meaning: ${description}`);
+    console.log();
+    console.log("\u{1F4C5} Next 5 Executions:");
+    const parts = expression.trim().split(/\s+/);
+    if (parts.length < 5 || parts.length > 6) {
+      console.log("   \u26A0\uFE0F  Invalid cron expression format");
+      return;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const executions = [];
+    for (let i = 0; i < 5; i++) {
+      const nextTime = new Date(now);
+      nextTime.setDate(nextTime.getDate() + i);
+      const [minute, hour] = parts.slice(parts.length === 6 ? 1 : 0, parts.length === 6 ? 3 : 2);
+      if (minute !== "*" && !minute.includes("/") && !minute.includes("-")) {
+        nextTime.setMinutes(parseInt(minute, 10));
+      }
+      if (hour !== "*" && !hour.includes("/") && !hour.includes("-")) {
+        nextTime.setHours(parseInt(hour, 10));
+      }
+      executions.push(
+        `   ${i + 1}. ${nextTime.toISOString().replace("T", " ").substring(0, 19)}`
+      );
+    }
+    executions.forEach((exec) => console.log(exec));
+    console.log();
+    console.log("\u{1F4A1} Tip: This is an approximate calculation.");
+    console.log("   For exact times, consider your system timezone.");
+    console.log();
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function createCronCommand() {
+  const cmd = new Command25("cron").description("Parse and explain cron expression").argument("<expression>", 'Cron expression (e.g., "0 5 * * *")').action(async (expression) => {
+    await handleCronParse(expression);
+  });
+  return cmd;
+}
+
+// src/commands/utils/markdown-preview.ts
+import { Command as Command26 } from "commander";
+import { readFile as readFile5 } from "fs/promises";
+import { marked } from "marked";
+import TerminalRenderer from "marked-terminal";
+async function handleMarkdownPreview(file, options) {
+  try {
+    const content = await readFile5(file, "utf-8");
+    if (options.raw) {
+      console.log("\u{1F4C4} Markdown File (Raw):");
+      console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+      console.log(content);
+      console.log();
+    } else {
+      marked.setOptions({
+        // @ts-ignore - marked-terminal types may not match perfectly
+        renderer: new TerminalRenderer()
+      });
+      const rendered = marked(content);
+      console.log("\u{1F4C4} Markdown Preview:");
+      console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+      console.log(rendered);
+    }
+  } catch (error) {
+    console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+function createMarkdownPreviewCommand() {
+  const cmd = new Command26("markdown-preview").description("Preview markdown file in terminal").argument("<file>", "Markdown file path").option("--raw", "Show raw markdown instead of rendered").action(async (file, options) => {
+    await handleMarkdownPreview(file, options);
+  });
+  return cmd;
+}
+
+// src/commands/utils/index.ts
+function createUtilsCommand() {
+  const utilsCommand = new Command27("utils").description("Developer utilities for common tasks");
+  utilsCommand.addCommand(createPasswordCommand());
+  utilsCommand.addCommand(createUuidCommand());
+  utilsCommand.addCommand(createHashCommand());
+  utilsCommand.addCommand(createBase64EncodeCommand());
+  utilsCommand.addCommand(createBase64DecodeCommand());
+  utilsCommand.addCommand(createHttpCommand());
+  utilsCommand.addCommand(createJwtCommand());
+  utilsCommand.addCommand(createUnixTimeCommand());
+  utilsCommand.addCommand(createTimezoneCommand());
+  utilsCommand.addCommand(createUrlEncodeCommand());
+  utilsCommand.addCommand(createUrlDecodeCommand());
+  utilsCommand.addCommand(createCronCommand());
+  utilsCommand.addCommand(createMarkdownPreviewCommand());
+  utilsCommand.action(() => {
+    utilsCommand.help();
+  });
+  return utilsCommand;
+}
+
+// src/commands/upgrade.ts
+import { Command as Command28 } from "commander";
 import { confirm as confirm4 } from "@inquirer/prompts";
 import { execSync } from "child_process";
 var colors2 = {
@@ -4798,7 +5649,7 @@ var colors2 = {
   bold: "\x1B[1m"
 };
 function createUpgradeCommand() {
-  return new Command14("upgrade").description("Upgrade jai1-client to the latest version").option("--check", "Only check for updates without installing").option("--force", "Force upgrade without confirmation").action(async (options) => {
+  return new Command28("upgrade").description("Upgrade jai1-client to the latest version").option("--check", "Only check for updates without installing").option("--force", "Force upgrade without confirmation").action(async (options) => {
     await handleUpgrade(options);
   });
 }
@@ -4871,6 +5722,7 @@ ${colors2.green}\u2705 Successfully upgraded to version ${latestVersion}!${color
         to_version: latestVersion,
         package_manager: packageManager2
       });
+      disableUpdateCheck();
     } catch (error) {
       console.error(`
 ${colors2.red}\u274C Upgrade failed!${colors2.reset}`);
@@ -4945,11 +5797,11 @@ function getInstallCommand(packageManager2) {
 }
 
 // src/commands/clean.ts
-import { Command as Command15 } from "commander";
+import { Command as Command29 } from "commander";
 import { confirm as confirm5, select as select2 } from "@inquirer/prompts";
 import { join as join4 } from "path";
 function createCleanCommand() {
-  return new Command15("clean").description("Clean up backups, cache, and temporary files").option("-y, --yes", "Skip confirmation").option("--backups", "Clean only backup files").option("--all", "Clean all (backups + cache)").action(async (options) => {
+  return new Command29("clean").description("Clean up backups, cache, and temporary files").option("-y, --yes", "Skip confirmation").option("--backups", "Clean only backup files").option("--all", "Clean all (backups + cache)").action(async (options) => {
     await handleClean(options);
   });
 }
@@ -5062,10 +5914,10 @@ async function cleanTarget(target, skipConfirm) {
 }
 
 // src/commands/redmine/check.ts
-import { Command as Command16 } from "commander";
+import { Command as Command30 } from "commander";
 
 // src/services/redmine-config.service.ts
-import { readFile } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import { resolve } from "path";
 
 // src/types/redmine.types.ts
@@ -5124,7 +5976,7 @@ var RedmineConfigService = class {
    */
   async load() {
     try {
-      const content = await readFile(this.configPath, "utf-8");
+      const content = await readFile6(this.configPath, "utf-8");
       const rawConfig = parse(content);
       return RedmineConfigSchema.parse(rawConfig);
     } catch (error) {
@@ -5369,7 +6221,7 @@ async function checkConnectivity(config) {
 
 // src/commands/redmine/check.ts
 function createRedmineCheckCommand() {
-  const cmd = new Command16("check").description("Check Redmine connectivity").option("-c, --config <path>", "Config file path", "redmine.config.yaml").option("--json", "Output as JSON").action(async (options) => {
+  const cmd = new Command30("check").description("Check Redmine connectivity").option("-c, --config <path>", "Config file path", "redmine.config.yaml").option("--json", "Output as JSON").action(async (options) => {
     await handleRedmineCheck(options);
   });
   return cmd;
@@ -5397,7 +6249,7 @@ async function handleRedmineCheck(options) {
 }
 
 // src/commands/redmine/sync-issue.ts
-import { Command as Command17 } from "commander";
+import { Command as Command31 } from "commander";
 
 // src/sync-issue.ts
 import { resolve as resolve2, relative } from "path";
@@ -5539,7 +6391,7 @@ function generateFilename(issueId, title, config, existingSlugs = /* @__PURE__ *
 }
 
 // src/file.util.ts
-import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
+import { readFile as readFile7, writeFile as writeFile2, mkdir } from "fs/promises";
 import { dirname } from "path";
 import matter3 from "gray-matter";
 async function ensureDir(filePath) {
@@ -5548,7 +6400,7 @@ async function ensureDir(filePath) {
 }
 async function readMarkdownFile(filePath) {
   try {
-    const content = await readFile2(filePath, "utf-8");
+    const content = await readFile7(filePath, "utf-8");
     return parseMarkdownContent(content);
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -5626,7 +6478,7 @@ ${config.anchors.end}`;
 async function writeMarkdownFile(filePath, data, config) {
   await ensureDir(filePath);
   const content = buildMarkdownContent(data, config);
-  await writeFile(filePath, content, "utf-8");
+  await writeFile2(filePath, content, "utf-8");
 }
 function extractIssueIdFromFrontmatter(frontmatter) {
   const id = frontmatter.id;
@@ -5773,7 +6625,7 @@ function extractIssueIdFromUrl(url) {
 
 // src/commands/redmine/sync-issue.ts
 function createSyncIssueCommand() {
-  const cmd = new Command17("issue").description("Sync a single issue").option("-i, --id <number>", "Issue ID").option("-u, --url <url>", "Issue URL").option("--dry-run", "Preview without making changes").option("-c, --config <path>", "Config file path").option("-o, --output-dir <path>", "Output directory").option("--json", "Output as JSON").action(async (options) => {
+  const cmd = new Command31("issue").description("Sync a single issue").option("-i, --id <number>", "Issue ID").option("-u, --url <url>", "Issue URL").option("--dry-run", "Preview without making changes").option("-c, --config <path>", "Config file path").option("-o, --output-dir <path>", "Output directory").option("--json", "Output as JSON").action(async (options) => {
     await handleSyncIssue(options);
   });
   return cmd;
@@ -5817,7 +6669,7 @@ async function handleSyncIssue(options) {
 }
 
 // src/commands/redmine/sync-project.ts
-import { Command as Command18 } from "commander";
+import { Command as Command32 } from "commander";
 
 // src/sync-project.ts
 async function syncProject(config, options = {}) {
@@ -5887,7 +6739,7 @@ async function syncProject(config, options = {}) {
 
 // src/commands/redmine/sync-project.ts
 function createSyncProjectCommand() {
-  const cmd = new Command18("project").description("Sync all issues in a project").option("-s, --status <status>", "Filter by status (default: *)", "*").option("--updated-since <date>", "Only sync issues updated since YYYY-MM-DD").option("--concurrency <number>", "Number of concurrent requests").option("--page-size <number>", "Page size for API requests").option("--dry-run", "Preview without making changes").option("-c, --config <path>", "Config file path").option("-o, --output-dir <path>", "Output directory").option("--json", "Output as JSON").action(async (options) => {
+  const cmd = new Command32("project").description("Sync all issues in a project").option("-s, --status <status>", "Filter by status (default: *)", "*").option("--updated-since <date>", "Only sync issues updated since YYYY-MM-DD").option("--concurrency <number>", "Number of concurrent requests").option("--page-size <number>", "Page size for API requests").option("--dry-run", "Preview without making changes").option("-c, --config <path>", "Config file path").option("-o, --output-dir <path>", "Output directory").option("--json", "Output as JSON").action(async (options) => {
     await handleSyncProject(options);
   });
   return cmd;
@@ -5942,12 +6794,12 @@ async function handleSyncProject(options) {
 }
 
 // src/commands/framework/info.ts
-import { Command as Command19 } from "commander";
+import { Command as Command33 } from "commander";
 import { promises as fs8 } from "fs";
 import { join as join5 } from "path";
 import { homedir as homedir5 } from "os";
 function createInfoCommand() {
-  const cmd = new Command19("info").description("Show jai1-client configuration and status").option("--json", "Output as JSON").option("--verbose", "Show detailed information").action(async (options) => {
+  const cmd = new Command33("info").description("Show jai1-client configuration and status").option("--json", "Output as JSON").option("--verbose", "Show detailed information").action(async (options) => {
     await handleInfo(options);
   });
   return cmd;
@@ -6003,7 +6855,7 @@ async function getProjectStatus2() {
 }
 
 // src/commands/self-update.ts
-import { Command as Command20 } from "commander";
+import { Command as Command34 } from "commander";
 import { confirm as confirm6 } from "@inquirer/prompts";
 import { execSync as execSync2 } from "child_process";
 var colors3 = {
@@ -6015,7 +6867,7 @@ var colors3 = {
   bold: "\x1B[1m"
 };
 function createSelfUpdateCommand() {
-  return new Command20("self-update").description("Update jai1-client to the latest version").option("--check", "Only check for updates without installing").option("--force", "Force update without confirmation").action(async (options) => {
+  return new Command34("self-update").description("Update jai1-client to the latest version").option("--check", "Only check for updates without installing").option("--force", "Force update without confirmation").action(async (options) => {
     await handleSelfUpdate(options);
   });
 }
@@ -6088,6 +6940,7 @@ ${colors3.green}\u2705 Successfully updated to version ${latestVersion}!${colors
         to_version: latestVersion,
         package_manager: packageManager2
       });
+      disableUpdateCheck();
     } catch (error) {
       console.error(`
 ${colors3.red}\u274C Update failed!${colors3.reset}`);
@@ -6154,10 +7007,10 @@ function getInstallCommand2(packageManager2) {
 }
 
 // src/commands/clear-backups.ts
-import { Command as Command21 } from "commander";
+import { Command as Command35 } from "commander";
 import { confirm as confirm7 } from "@inquirer/prompts";
 function createClearBackupsCommand() {
-  return new Command21("clear-backups").description("Clear backup files").option("-y, --yes", "Skip confirmation").action(async (options) => {
+  return new Command35("clear-backups").description("Clear backup files").option("-y, --yes", "Skip confirmation").action(async (options) => {
     const service = new ComponentsService();
     const backups = await service.listBackups(process.cwd());
     if (backups.length === 0) {
@@ -6182,7 +7035,7 @@ function createClearBackupsCommand() {
 }
 
 // src/commands/vscode/index.ts
-import { Command as Command22 } from "commander";
+import { Command as Command36 } from "commander";
 import { checkbox as checkbox3, confirm as confirm8, select as select3 } from "@inquirer/prompts";
 import fs9 from "fs/promises";
 import path5 from "path";
@@ -6322,7 +7175,7 @@ var PERFORMANCE_GROUPS2 = {
   }
 };
 function createVSCodeCommand() {
-  const vscodeCommand = new Command22("vscode").description("Qu\u1EA3n l\xFD c\xE0i \u0111\u1EB7t VSCode cho d\u1EF1 \xE1n hi\u1EC7n t\u1EA1i");
+  const vscodeCommand = new Command36("vscode").description("Qu\u1EA3n l\xFD c\xE0i \u0111\u1EB7t VSCode cho d\u1EF1 \xE1n hi\u1EC7n t\u1EA1i");
   vscodeCommand.action(async () => {
     await interactiveMode2();
   });
@@ -6493,9 +7346,9 @@ async function resetSettings2(groupKeys) {
 // src/commands/guide.ts
 import React27 from "react";
 import { render as render5 } from "ink";
-import { Command as Command23 } from "commander";
+import { Command as Command37 } from "commander";
 function createGuideCommand() {
-  const cmd = new Command23("guide").description("Interactive guide center for Agentic Coding").option("--topic <topic>", "Open specific topic (intro, rules, workflows, prompts, skills)").action(async (options) => {
+  const cmd = new Command37("guide").description("Interactive guide center for Agentic Coding").option("--topic <topic>", "Open specific topic (intro, rules, workflows, prompts, skills)").action(async (options) => {
     const { waitUntilExit } = render5(
       React27.createElement(GuideApp, {
         initialTopic: options.topic,
@@ -6512,9 +7365,9 @@ function createGuideCommand() {
 // src/commands/context.ts
 import React28 from "react";
 import { render as render6 } from "ink";
-import { Command as Command24 } from "commander";
+import { Command as Command38 } from "commander";
 function createContextCommand() {
-  const cmd = new Command24("context").description("Kh\xE1m ph\xE1 v\xE0 qu\u1EA3n l\xFD context d\u1EF1 \xE1n cho c\xE1c IDE").option("--ide <ide>", "M\u1EDF tr\u1EF1c ti\u1EBFp IDE c\u1EE5 th\u1EC3 (cursor, windsurf, antigravity, jai1)").option("--type <type>", "Hi\u1EC3n th\u1ECB lo\u1EA1i context c\u1EE5 th\u1EC3 (rules, workflows, skills, agents, prompts)").option("--stats", "Hi\u1EC3n th\u1ECB th\u1ED1ng k\xEA context (non-interactive)").action(async (options) => {
+  const cmd = new Command38("context").description("Kh\xE1m ph\xE1 v\xE0 qu\u1EA3n l\xFD context d\u1EF1 \xE1n cho c\xE1c IDE").option("--ide <ide>", "M\u1EDF tr\u1EF1c ti\u1EBFp IDE c\u1EE5 th\u1EC3 (cursor, windsurf, antigravity, jai1)").option("--type <type>", "Hi\u1EC3n th\u1ECB lo\u1EA1i context c\u1EE5 th\u1EC3 (rules, workflows, skills, agents, prompts)").option("--stats", "Hi\u1EC3n th\u1ECB th\u1ED1ng k\xEA context (non-interactive)").action(async (options) => {
     let initialIDE;
     if (options.ide) {
       const validIDEs = ["cursor", "windsurf", "antigravity", "jai1"];
@@ -6591,10 +7444,10 @@ async function printStats2() {
 }
 
 // src/commands/migrate-ide.ts
-import { Command as Command25 } from "commander";
+import { Command as Command39 } from "commander";
 import { checkbox as checkbox4, confirm as confirm9 } from "@inquirer/prompts";
 function createMigrateIdeCommand() {
-  const cmd = new Command25("migrate-ide").description("Migrate .jai1 rules v\xE0 workflows sang IDEs (Cursor, Windsurf, Claude Code, etc.)").option("--ide <ides...>", "Target IDEs (cursor, windsurf, antigravity, claudecode, opencode)").option("--type <types...>", "Content types (rules, workflows, commands)").option("--dry-run", "Preview changes without writing files").action(async (options) => {
+  const cmd = new Command39("migrate-ide").description("Migrate .jai1 rules v\xE0 workflows sang IDEs (Cursor, Windsurf, Claude Code, etc.)").option("--ide <ides...>", "Target IDEs (cursor, windsurf, antigravity, claudecode, opencode)").option("--type <types...>", "Content types (rules, workflows, commands)").option("--dry-run", "Preview changes without writing files").action(async (options) => {
     await runMigrateIde(options);
   });
   return cmd;
@@ -6700,7 +7553,7 @@ async function runMigrateIde(options) {
 }
 
 // src/cli.ts
-var program = new Command26();
+var program = new Command40();
 if (process.argv.includes("-v") || process.argv.includes("--version")) {
   console.log(package_default.version);
   if (!process.argv.includes("--skip-update-check")) {
@@ -6720,11 +7573,12 @@ program.addCommand(createLearnCommand());
 program.addCommand(createChatCommand());
 program.addCommand(createApiKeysCommand());
 program.addCommand(createTranslateCommand());
+program.addCommand(createUtilsCommand());
 program.addCommand(createUpgradeCommand());
 program.addCommand(createCleanCommand());
-var redmineCommand = new Command26("redmine").description("Redmine context sync commands");
+var redmineCommand = new Command40("redmine").description("Redmine context sync commands");
 redmineCommand.addCommand(createRedmineCheckCommand());
-var syncCommand = new Command26("sync").description("Sync Redmine issues to markdown files");
+var syncCommand = new Command40("sync").description("Sync Redmine issues to markdown files");
 syncCommand.addCommand(createSyncIssueCommand());
 syncCommand.addCommand(createSyncProjectCommand());
 redmineCommand.addCommand(syncCommand);
@@ -6762,6 +7616,9 @@ program.on("command:*", (operands) => {
   console.error("     api-keys      Show OpenAI-compatible API credentials");
   console.error("     translate     Translate text, files, or folders using AI");
   console.error("");
+  console.error("  \u{1F6E0}\uFE0F  Developer Utilities");
+  console.error("     utils         Developer tools (password, uuid, hash, jwt, etc.)");
+  console.error("");
   console.error("  \u{1F527} Maintenance");
   console.error("     upgrade       Upgrade jai1-client to latest version");
   console.error("     clean         Clean up backups and cache");