balda-js 0.0.2 → 0.0.4

package/lib/cli.js

@@ -1,929 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-
-// src/runtime/runtime.ts
-var RunTime = class {
-  type;
-  constructor() {
-    this.type = this.getRunTime();
-  }
-  getRunTime() {
-    if (typeof Bun !== "undefined") {
-      return "bun";
-    } else if (typeof Deno !== "undefined") {
-      return "deno";
-    } else if (typeof process !== "undefined") {
-      return "node";
-    }
-    throw new Error("No environment detected");
-  }
-};
-var runtime = new RunTime();
-
-// src/runtime/native_args.ts
-var NativeArgs = class {
-  /**
-   * Gets CLI arguments, dynamically determining where they start
-   * Handles different execution contexts (direct execution, tsx, ts-node, etc.)
-   */
-  getCliArgs() {
-    switch (runtime.type) {
-      case "bun":
-        return this.getBunArgs();
-      case "node":
-        return this.getNodeArgs();
-      case "deno":
-        return Deno.args;
-      default:
-        throw new Error("Unsupported runtime");
-    }
-  }
-  /**
-   * Gets Bun arguments, handling different execution contexts
-   */
-  getBunArgs() {
-    const args2 = Bun.argv;
-    const scriptIndex = this.findScriptIndex(args2);
-    return args2.slice(scriptIndex + 1);
-  }
-  /**
-   * Gets Node.js arguments, handling different execution contexts
-   */
-  getNodeArgs() {
-    const args2 = process.argv;
-    const scriptIndex = this.findScriptIndex(args2);
-    return args2.slice(scriptIndex + 1);
-  }
-  /**
-   * Finds the index of the actual script being executed
-   * Handles cases like: node script.js, tsx script.ts, ts-node script.ts, yarn, yarn run, npx, etc.
-   */
-  findScriptIndex(args2) {
-    const scriptPatterns = [
-      /\.(js|ts|mjs|cjs)$/,
-      /^(tsx|ts-node|node|bun|yarn|npx|pnpm|npm)$/
-    ];
-    for (let i = 0; i < args2.length; i++) {
-      const arg2 = args2[i];
-      if (arg2.startsWith("-")) {
-        continue;
-      }
-      if (arg2 === "yarn" && i + 1 < args2.length && args2[i + 1] === "run") {
-        return i + 1;
-      }
-      const isScript = scriptPatterns.some((pattern) => pattern.test(arg2));
-      if (isScript) {
-        return i;
-      }
-    }
-    for (let i = args2.length - 1; i >= 0; i--) {
-      const arg2 = args2[i];
-      if (!arg2.startsWith("-")) {
-        return i;
-      }
-    }
-    return 1;
-  }
-};
-var nativeArgs = new NativeArgs();
-
-// src/utils.ts
-var levenshteinDistance = (str1, str2) => {
-  const matrix = Array(str2.length + 1).fill(null).map(() => Array(str1.length + 1).fill(null));
-  for (let i = 0; i <= str1.length; i++) {
-    matrix[0][i] = i;
-  }
-  for (let j = 0; j <= str2.length; j++) {
-    matrix[j][0] = j;
-  }
-  for (let j = 1; j <= str2.length; j++) {
-    for (let i = 1; i <= str1.length; i++) {
-      const indicator = str1[i - 1] === str2[j - 1] ? 0 : 1;
-      matrix[j][i] = Math.min(
-        matrix[j][i - 1] + 1,
-        matrix[j - 1][i] + 1,
-        matrix[j - 1][i - 1] + indicator
-      );
-    }
-  }
-  return matrix[str2.length][str1.length];
-};
-
-// src/commands/arg_parser.ts
-var parseFlag = (arg2) => {
-  if (!arg2 || arg2 === "-" || arg2 === "--") {
-    return null;
-  }
-  const equalIndex = arg2.indexOf("=");
-  if (equalIndex > 0) {
-    const name = arg2.substring(0, equalIndex);
-    const value = arg2.substring(equalIndex + 1);
-    return {
-      name,
-      value: parseFlagValue(value)
-    };
-  }
-  return { name: arg2, value: true };
-};
-var parseFlagValue = (value) => {
-  if (value.toLowerCase() === "true") {
-    return true;
-  }
-  if (value.toLowerCase() === "false") {
-    return false;
-  }
-  const numValue = Number(value);
-  if (!Number.isNaN(numValue) && Number.isFinite(numValue)) {
-    return numValue;
-  }
-  return value;
-};
-var parseCliArgsAndFlags = () => {
-  const cliArgs = nativeArgs.getCliArgs();
-  const parsedArgs = [];
-  const parsedFlags = {};
-  if (!cliArgs || !cliArgs.length) {
-    return { args: parsedArgs, flags: parsedFlags };
-  }
-  for (let i = 0; i < cliArgs.length; i++) {
-    const arg2 = cliArgs[i];
-    if (!arg2 || typeof arg2 !== "string") {
-      continue;
-    }
-    if (arg2.startsWith("-")) {
-      const flag2 = parseFlag(arg2);
-      if (flag2) {
-        if (flag2.value === true && i + 1 < cliArgs.length) {
-          const nextArg = cliArgs[i + 1];
-          if (nextArg && typeof nextArg === "string" && !nextArg.startsWith("-")) {
-            flag2.value = parseFlagValue(nextArg);
-            i++;
-          }
-        }
-        parsedFlags[flag2.name] = flag2.value;
-      }
-      continue;
-    }
-    parsedArgs.push(arg2);
-  }
-  return { args: parsedArgs, flags: parsedFlags };
-};
-var findSimilarCommands = (notFoundCommand, availableCommands) => {
-  if (!notFoundCommand || typeof notFoundCommand !== "string") {
-    return "";
-  }
-  if (!availableCommands || !Array.isArray(availableCommands) || availableCommands.length === 0) {
-    return "";
-  }
-  const searchTerm = notFoundCommand.toLowerCase().trim();
-  const similarCommands = availableCommands.filter((command) => {
-    const normalizedCommand = command.toLowerCase();
-    if (normalizedCommand === searchTerm) {
-      return true;
-    }
-    if (normalizedCommand.includes(searchTerm) || searchTerm.includes(normalizedCommand)) {
-      return true;
-    }
-    const distance = levenshteinDistance(normalizedCommand, searchTerm);
-    const maxDistance = Math.max(searchTerm.length, normalizedCommand.length) * 0.4;
-    return distance <= maxDistance;
-  });
-  if (similarCommands.length === 0) {
-    return "";
-  }
-  const topSuggestions = similarCommands.slice(0, 3);
-  const suggestions = topSuggestions.map((cmd) => `\x1B[36m${cmd}\x1B[0m`).join(", ");
-  return `\x1B[31m\u2717\x1B[0m Command \x1B[33m${notFoundCommand}\x1B[0m not found
-\x1B[32m\u{1F4A1}\x1B[0m Did you mean: ${suggestions}?`;
-};
-var getCalledCommandName = () => {
-  const cliArgs = nativeArgs.getCliArgs();
-  return cliArgs[0] || null;
-};
-
-// src/runtime/native_exit.ts
-var NativeExit = class {
-  exit(code) {
-    switch (runtime.type) {
-      case "bun":
-      case "node":
-        process.exit(code);
-      case "deno":
-        Deno.exit(code);
-      default:
-        throw new Error("Unsupported runtime");
-    }
-  }
-};
-var nativeExit = new NativeExit();
-
-// src/commands/command_registry.ts
-import { glob } from "glob";
-
-// src/commands/base_commands/generate_plugin.ts
-import { join } from "path";
-
-// src/metadata_store.ts
-var MetadataStore = class {
-  static metadata = /* @__PURE__ */ new WeakMap();
-  /**
-   * Set the metadata for the given target and property key
-   */
-  static set(target, propertyKey, value) {
-    if (!this.metadata.has(target)) {
-      this.metadata.set(target, /* @__PURE__ */ new Map());
-    }
-    this.metadata.get(target).set(propertyKey, value);
-  }
-  /**
-   * Get the metadata for the given target and property key
-   */
-  static get(target, propertyKey) {
-    return this.metadata.get(target)?.get(propertyKey);
-  }
-  /**
-   * Get all the metadata for the given target
-   */
-  static getAll(target) {
-    return this.metadata.get(target) || /* @__PURE__ */ new Map();
-  }
-  /**
-   * Delete the metadata for the given target and property key
-   */
-  static delete(target, propertyKey) {
-    this.metadata.get(target)?.delete(propertyKey.toString());
-  }
-  /**
-   * Clear all the metadata for the given target
-   */
-  static clear(target) {
-    this.metadata.delete(target);
-  }
-};
-
-// src/decorators/command/arg.ts
-var VALIDATION_ERROR_SYMBOL = "VALIDATION_ERROR";
-var args = parseCliArgsAndFlags().args.slice(1);
-var arg = (options) => {
-  return (target, propertyKey) => {
-    const currentCommandName = getCalledCommandName();
-    if (!currentCommandName || currentCommandName !== target.commandName) {
-      return;
-    }
-    const argName = propertyKey;
-    MetadataStore.set(target, propertyKey, {
-      type: "arg",
-      name: argName,
-      description: options.description
-    });
-    let argValue = args.length ? args.shift() : options.defaultValue;
-    if (options.required && !argValue) {
-      const errorChain = MetadataStore.get(target, VALIDATION_ERROR_SYMBOL);
-      MetadataStore.set(target, VALIDATION_ERROR_SYMBOL, [
-        ...errorChain || [],
-        {
-          type: "arg",
-          name: argName,
-          message: "Required argument not provided"
-        }
-      ]);
-      return;
-    }
-    if (options.parse && argValue) {
-      argValue = options.parse(argValue);
-    }
-    Object.defineProperty(target, propertyKey, {
-      value: argValue,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  };
-};
-
-// src/logger/logger.ts
-import pino from "pino";
-var createBaseLogger = () => {
-  const baseOptions = {
-    level: "info",
-    formatters: {
-      level: (label) => {
-        return { level: label };
-      }
-    }
-  };
-  return pino(baseOptions);
-};
-var logger = createBaseLogger();
-
-// src/commands/base_command.ts
-var Command = class {
-  /**
-   * The name of the command.
-   */
-  static commandName = this.name;
-  /**
-   * The description of the command.
-   */
-  static description = "";
-  /**
-   * The help text of the command.
-   */
-  static help = [];
-  /**
-   * The options of the command.
-   */
-  static options = {
-    keepAlive: false
-  };
-  /**
-   * Static arguments in order to be validated by decorators. Will be fetched in the command instance.
-   */
-  static args = parseCliArgsAndFlags().args.slice(1);
-  /**
-   * Static flags in order to be validated by decorators. Will be fetched in the command instance.
-   */
-  static flags = parseCliArgsAndFlags().flags;
-  static logger = logger;
-  /**
-   * Main entry point for the command.
-   */
-  static handle() {
-    throw new Error(
-      `Handle method not implemented in command class ${this.name}`
-    );
-  }
-  /**
-   * Enhanced help flag handler with rich formatting and command information
-   */
-  static handleHelpFlag(flags) {
-    const helpFlags = ["-h", "--help", "-?", "--usage"];
-    const hasHelpFlag = Object.keys(flags).some(
-      (flag2) => helpFlags.includes(flag2)
-    );
-    if (!hasHelpFlag) {
-      return;
-    }
-    const commandName = this.commandName;
-    const description = this.description || "No description available";
-    const helpText = this.help || [];
-    const options = this.options;
-    const helpOutput = this.generateHelpOutput(
-      {
-        name: commandName,
-        description,
-        helpText,
-        options,
-        args: this.args,
-        flags: this.flags
-      },
-      this
-    );
-    console.log(helpOutput);
-    nativeExit.exit(0);
-  }
-  static generateHelpOutput = (info, commandClass) => {
-    const { name, description, helpText, options, args: args2, flags } = info;
-    const colors = {
-      title: "\x1B[1;36m",
-      // Bright cyan
-      subtitle: "\x1B[1;33m",
-      // Bright yellow
-      description: "\x1B[0;37m",
-      // White
-      code: "\x1B[0;32m",
-      // Green
-      flag: "\x1B[0;35m",
-      // Magenta
-      reset: "\x1B[0m",
-      // Reset
-      error: "\x1B[0;31m",
-      // Red
-      success: "\x1B[0;32m",
-      // Green
-      info: "\x1B[0;34m"
-      // Blue
-    };
-    const lines = [
-      `${colors.title}${name}${colors.reset}`,
-      `${colors.description}${description}${colors.reset}`,
-      "",
-      `${colors.subtitle}Usage:${colors.reset}`,
-      `  ${colors.code}${name}${colors.reset} [options] [arguments]`,
-      "",
-      `${colors.subtitle}Options:${colors.reset}`,
-      `  ${colors.flag}-h, --help${colors.reset}     Show this help message`,
-      `  ${colors.flag}-?, --usage${colors.reset}    Show usage information`,
-      "",
-      `${colors.subtitle}Command Options:${colors.reset}`,
-      `  ${colors.flag}keepAlive${colors.reset}      ${options?.keepAlive ?? false ? colors.success + "Enabled" + colors.reset : colors.error + "Disabled" + colors.reset}`,
-      ""
-    ];
-    if (helpText) {
-      const helpLines = Array.isArray(helpText) ? helpText : [helpText];
-      lines.push(`${colors.subtitle}Help:${colors.reset}`);
-      helpLines.forEach((line) => {
-        lines.push(`  ${colors.description}${line}${colors.reset}`);
-      });
-      lines.push("");
-    }
-    const allMeta = MetadataStore.getAll(commandClass);
-    const argsMeta = Array.from(allMeta.values()).filter(
-      (meta) => meta.type === "arg"
-    );
-    const flagsMeta = Array.from(allMeta.values()).filter(
-      (meta) => meta.type === "flag"
-    );
-    if (argsMeta.length) {
-      lines.push(`${colors.subtitle}Available Arguments:${colors.reset}`);
-      argsMeta.forEach((meta) => {
-        const required = meta.required ? ` ${colors.error}(required)${colors.reset}` : "";
-        const description2 = meta.description ? ` ${colors.description}${meta.description}${colors.reset}` : "";
-        lines.push(
-          `  ${colors.code}${meta.name}${colors.reset}${required}${description2}`
-        );
-      });
-      lines.push("");
-    }
-    if (flagsMeta.length) {
-      lines.push(`${colors.subtitle}Available Flags:${colors.reset}`);
-      flagsMeta.forEach((meta) => {
-        if (meta.aliases && !Array.isArray(meta.aliases)) {
-          meta.aliases = [meta.aliases];
-        }
-        const aliases = meta.aliases.length ? ` ${colors.flag}(${meta.aliases.join(", ")})${colors.reset}` : "";
-        const required = meta.required ? ` ${colors.error}(required)${colors.reset}` : "";
-        const description2 = meta.description ? ` ${colors.description}${meta.description}${colors.reset}` : "";
-        lines.push(
-          `  ${colors.flag}--${meta.name}${aliases}${colors.reset}${required}${description2}`
-        );
-      });
-      lines.push("");
-    }
-    if ((args2?.length ?? 0) > 0 || flags && Object.keys(flags).length > 0) {
-      lines.push(`${colors.subtitle}Current Context:${colors.reset}`);
-      if (args2?.length) {
-        lines.push(
-          `  ${colors.info}Provided Arguments:${colors.reset} ${colors.code}${args2.join(" ")}${colors.reset}`
-        );
-      }
-      if (flags && Object.keys(flags).length > 0) {
-        lines.push(`  ${colors.info}Provided Flags:${colors.reset}`);
-        Object.keys(flags).forEach((flagKey) => {
-          const flagValue = flags[flagKey];
-          const valueDisplay = flagValue !== void 0 && flagValue !== null ? ` = ${colors.code}${flagValue}${colors.reset}` : "";
-          lines.push(
-            `  ${colors.flag}${flagKey}${colors.reset}${valueDisplay}`
-          );
-        });
-      }
-      lines.push("");
-    }
-    if (helpText && (Array.isArray(helpText) ? helpText.some((line) => line.includes("example")) : helpText.includes("example"))) {
-      lines.push(`${colors.subtitle}Examples:${colors.reset}`);
-      const examples = Array.isArray(helpText) ? helpText.filter((line) => line.includes("example")) : [helpText.split("example")[1].trim()];
-      examples.forEach((example) => {
-        lines.push(`  ${colors.code}${example}${colors.reset}`);
-      });
-      lines.push("");
-    }
-    return lines.join("\n");
-  };
-  static validateContext = (target) => {
-    const errorChain = Array.from(
-      MetadataStore.get(target, VALIDATION_ERROR_SYMBOL) || []
-    );
-    if (errorChain.length) {
-      const colors = {
-        error: "\x1B[0;31m",
-        // Red
-        title: "\x1B[1;31m",
-        // Bright red
-        reset: "\x1B[0m",
-        // Reset
-        info: "\x1B[0;34m",
-        // Blue
-        code: "\x1B[0;32m"
-        // Green
-      };
-      console.error(`${colors.title}\u274C Validation Errors:${colors.reset}`);
-      console.error("");
-      errorChain.forEach((error, index) => {
-        const errorNumber = `${colors.info}${index + 1}.${colors.reset}`;
-        const errorType = `${colors.error}${error.type.toUpperCase()}${colors.reset}`;
-        const errorName = `${colors.code}${error.name}${colors.reset}`;
-        console.error(
-          `  ${errorNumber} ${errorType} ${errorName}: ${colors.error}${error.message}${colors.reset}`
-        );
-      });
-      console.error("");
-      console.error(
-        `${colors.info}\u{1F4A1} Tip: Use --help for usage information${colors.reset}`
-      );
-      nativeExit.exit(1);
-    }
-  };
-};
-
-// src/decorators/command/flag.ts
-var flag = (options) => {
-  return (target, propertyKey) => {
-    const currentCommandName = getCalledCommandName();
-    if (!currentCommandName || currentCommandName !== target.commandName) {
-      return;
-    }
-    const primaryFlagName = options.name || propertyKey;
-    const parsedFlags = parseCliArgsAndFlags().flags;
-    const flagAliases = options.aliases || [];
-    const allFlagVariants = [primaryFlagName, ...flagAliases];
-    let resolvedFlagValue = options.defaultValue;
-    for (const flagVariant of allFlagVariants) {
-      const possibleNames = [
-        flagVariant,
-        `-${flagVariant}`,
-        `--${flagVariant}`
-      ];
-      for (const flagName of possibleNames) {
-        if (flagName in parsedFlags) {
-          resolvedFlagValue = parsedFlags[flagName];
-          break;
-        }
-      }
-      if (resolvedFlagValue !== options.defaultValue) {
-        break;
-      }
-    }
-    MetadataStore.set(target, propertyKey, {
-      type: "flag",
-      name: primaryFlagName,
-      aliases: flagAliases || [],
-      description: options.description
-    });
-    if (options.required && !resolvedFlagValue) {
-      const errorChain = MetadataStore.get(target, VALIDATION_ERROR_SYMBOL);
-      MetadataStore.set(target, VALIDATION_ERROR_SYMBOL, [
-        ...errorChain || [],
-        {
-          type: "flag",
-          name: primaryFlagName,
-          message: "Required flag not provided"
-        }
-      ]);
-      return;
-    }
-    Object.defineProperty(target, propertyKey, {
-      value: resolvedFlagValue,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  };
-};
-
-// src/runtime/native_fs.ts
-var NativeFs = class {
-  async readFile(path) {
-    switch (runtime.type) {
-      case "node":
-        const fs = await import("fs/promises");
-        const buffer = await fs.readFile(path);
-        return new Uint8Array(buffer);
-      case "bun":
-        const arrayBuffer = await Bun.file(path).arrayBuffer();
-        return new Uint8Array(arrayBuffer);
-      case "deno":
-        return new Uint8Array(await Deno.readFile(path));
-    }
-  }
-  async writeFile(path, data) {
-    switch (runtime.type) {
-      case "node":
-        const fs = await import("fs/promises");
-        await fs.writeFile(path, data);
-        break;
-      case "bun":
-        await Bun.write(path, data);
-        break;
-      case "deno":
-        await Deno.writeFile(path, data);
-        break;
-    }
-  }
-  async stat(path) {
-    switch (runtime.type) {
-      case "node":
-        const fs = await import("fs/promises");
-        const stats = await fs.stat(path);
-        return {
-          isDirectory: stats.isDirectory(),
-          isFile: stats.isFile(),
-          isSymbolicLink: stats.isSymbolicLink(),
-          size: stats.size
-        };
-      case "bun":
-        const bunStats = await Bun.file(path).stat();
-        return {
-          isDirectory: bunStats.isDirectory(),
-          isFile: bunStats.isFile(),
-          isSymbolicLink: bunStats.isSymbolicLink(),
-          size: bunStats.size
-        };
-      case "deno":
-        const denoStats = await Deno.stat(path);
-        return {
-          isDirectory: denoStats.isDirectory,
-          isFile: denoStats.isFile,
-          isSymbolicLink: false,
-          size: denoStats.size
-        };
-    }
-  }
-  async unlink(path) {
-    switch (runtime.type) {
-      case "node":
-        const fs = await import("fs/promises");
-        await fs.unlink(path);
-        break;
-      case "bun":
-        await Bun.file(path).delete();
-        break;
-      case "deno":
-        await Deno.remove(path);
-        break;
-      default:
-        throw new Error("Unsupported runtime");
-    }
-  }
-};
-var nativeFs = new NativeFs();
-
-// src/commands/base_commands/generate_plugin.ts
-var GeneratePluginCommand = class extends Command {
-  static commandName = "generate-plugin";
-  static description = "Generate a new plugin in the specified path";
-  static help = [
-    "Generate a new plugin in the specified path",
-    "Example: npx balda generate-plugin my-plugin -p src/plugins"
-  ];
-  static pluginName;
-  static pluginPath;
-  static async handle() {
-    const pluginTemplate = this.getPluginTemplate();
-    this.pluginPath = join(this.pluginPath, `${this.pluginName}.ts`);
-    await nativeFs.writeFile(
-      this.pluginPath,
-      new TextEncoder().encode(pluginTemplate)
-    );
-    this.logger.info(
-      `Plugin ${this.name} created successfully at ${this.pluginPath}`
-    );
-  }
-  static getPluginTemplate() {
-    return `import { BasePlugin, Request, Response, NextFunction, ServerRouteMiddleware } from "balda";
-
-export default class extends BasePlugin {
-  async handle(): Promise<ServerRouteMiddleware> {
-    return async (req: Request, res: Response, next: NextFunction) => {
-      console.log("${this.pluginName} plugin is running");
-      await next();
-    };
-  }
-}`;
-  }
-};
-__decorateClass([
-  arg({
-    description: "The name of the plugin to generate",
-    required: true
-  })
-], GeneratePluginCommand, "pluginName", 2);
-__decorateClass([
-  flag({
-    description: "The path to the plugin to generate, default is src/plugins",
-    type: "string",
-    aliases: "p",
-    name: "path",
-    required: false,
-    defaultValue: "src/plugins"
-  })
-], GeneratePluginCommand, "pluginPath", 2);
-
-// src/commands/base_commands/generate_command.ts
-import { join as join2 } from "path";
-var GenerateCommand = class extends Command {
-  static commandName = "generate-command";
-  static description = "Generate a new command in the specified path";
-  static help = [
-    "Generate a new cli command in the specified path",
-    "Example: npx balda generate-command my-command -p src/commands"
-  ];
-  static name;
-  static path;
-  static async handle() {
-    const commandTemplate = this.getCommandTemplate();
-    this.path = join2(this.path, `${this.name}.ts`);
-    await nativeFs.writeFile(
-      this.path,
-      new TextEncoder().encode(commandTemplate)
-    );
-    this.logger.info(
-      `Command ${this.name} created successfully at ${this.path}`
-    );
-  }
-  static getCommandTemplate() {
-    return `import { Command } from "balda";
-
-export default class extends Command {
-  static commandName = "${this.name}";
-  static description = "${this.description}";
-
-  static options = {};
-
-  static async handle(): Promise<void> {
-    // Implement your command logic here
-  }
-}`;
-  }
-};
-__decorateClass([
-  arg({
-    description: "The name of the command to generate",
-    required: true
-  })
-], GenerateCommand, "name", 2);
-__decorateClass([
-  flag({
-    description: "The path to the command to generate, default is src/commands",
-    type: "string",
-    aliases: "p",
-    name: "path",
-    required: false,
-    defaultValue: "src/commands"
-  })
-], GenerateCommand, "path", 2);
-
-// src/commands/base_commands/generate_cron.ts
-import { join as join3 } from "path";
-var GenerateCron = class extends Command {
-  static commandName = "generate-cron";
-  static description = "Generate a new cron job in the specified path";
-  static help = [
-    "Generate a new cron job in the specified path",
-    "Example: npx balda generate-cron my-cron -p src/cron"
-  ];
-  static fileName;
-  static path;
-  static async handle() {
-    const cronTemplate = this.getCronTemplate();
-    this.path = join3(this.path, `${this.fileName}.ts`);
-    await nativeFs.writeFile(this.path, new TextEncoder().encode(cronTemplate));
-    this.logger.info(
-      `Cron job ${this.fileName} created successfully at ${this.path}`
-    );
-  }
-  static getCronTemplate() {
-    return `import { cron } from "balda-js";
-
-export default class {
-  @cron("* * * * *")
-  handle() {
-    // Implement your cron job logic here
-  }
-}`;
-  }
-};
-__decorateClass([
-  arg({
-    description: "The name of the cron job file to generate",
-    required: true
-  })
-], GenerateCron, "fileName", 2);
-__decorateClass([
-  flag({
-    description: "The path to the cron job to generate, default is src/cron",
-    type: "string",
-    aliases: "p",
-    name: "path",
-    required: false,
-    defaultValue: "src/cron"
-  })
-], GenerateCron, "path", 2);
-
-// src/commands/command_registry.ts
-var CommandRegistry = class _CommandRegistry {
-  commands;
-  static commandsPattern = "commands/**/*.{ts,js}";
-  static logger = logger;
-  /**
-   * Private constructor to prevent direct instantiation
-   * @internal Not meant to be used outside by the user
-   */
-  constructor() {
-    this.commands = /* @__PURE__ */ new Map();
-  }
-  static getInstance() {
-    return new _CommandRegistry();
-  }
-  static setCommandsPattern(pattern) {
-    this.commandsPattern = pattern;
-  }
-  getCommand(name) {
-    return this.commands.get(name) ?? null;
-  }
-  getCommands() {
-    return Array.from(this.commands.values());
-  }
-  async loadCommands(commandsPattern) {
-    _CommandRegistry.logger.info(`Loading commands from ${commandsPattern}`);
-    const commandFiles = await glob(commandsPattern);
-    for (const commandFile of commandFiles) {
-      const command = await import(commandFile).then((module) => {
-        if (module.default) {
-          return module.default;
-        }
-        return module;
-      }).catch((error) => {
-        _CommandRegistry.logger.error(
-          `Error loading command ${commandFile}: ${error}`
-        );
-        return null;
-      });
-      if (command) {
-        this.commands.set(command.commandName, command);
-      }
-    }
-    const baseCommands = [
-      GeneratePluginCommand,
-      GenerateCommand,
-      GenerateCron
-    ];
-    for (const command of baseCommands) {
-      this.commands.set(command.commandName, command);
-    }
-  }
-};
-var commandRegistry = CommandRegistry.getInstance();
-
-// src/cli.ts
-var cli = async () => {
-  await commandRegistry.loadCommands(CommandRegistry.commandsPattern);
-  const commandName = nativeArgs.getCliArgs()[0];
-  if (!commandName) {
-    console.error(
-      `No command provided, available commands: ${commandRegistry.getCommands().map((command) => command.commandName).join(", ")}`
-    );
-    nativeExit.exit(1);
-    return;
-  }
-  const CommandClass = commandRegistry.getCommand(commandName);
-  if (!CommandClass) {
-    console.error(
-      findSimilarCommands(
-        commandName,
-        commandRegistry.getCommands().map((command) => command.commandName)
-      ) || `Command ${commandName} not found`
-    );
-    nativeExit.exit(1);
-    return;
-  }
-  const commandClass = CommandClass;
-  commandClass.handleHelpFlag(commandClass.flags);
-  commandClass.validateContext(commandClass);
-  await commandClass.handle();
-  const keepAlive = CommandClass.options?.keepAlive ?? false;
-  if (!keepAlive) {
-    nativeExit.exit(0);
-  }
-};
-if (typeof process !== "undefined") {
-  import("module").then(({ register }) => {
-    register("ts-node/esm", import.meta.url);
-    cli().catch((err) => {
-      CommandRegistry.logger.error(err);
-      process.exit(1);
-    });
-  }).catch(() => {
-    CommandRegistry.logger.error(
-      `Failed to register ts-node/esm, you need to install it in your project in order to use typescript in the cli
-try running: npm install -D ts-node`
-    );
-    process.exit(1);
-  });
-} else {
-  cli().catch((err) => {
-    CommandRegistry.logger.error(err);
-    nativeExit.exit(1);
-  });
-}
-export {
-  cli
-};
-//# sourceMappingURL=cli.js.map