novaapp-sdk 1.4.1 → 1.4.2

package/dist/cli/index.js

@@ -0,0 +1,871 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli/index.ts
+var cli_exports = {};
+__export(cli_exports, {
+  run: () => run
+});
+module.exports = __toCommonJS(cli_exports);
+
+// src/cli/utils.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var isTTY = Boolean(process.stdout.isTTY);
+var c = {
+  reset: (s) => isTTY ? `\x1B[0m${s}\x1B[0m` : s,
+  bold: (s) => isTTY ? `\x1B[1m${s}\x1B[0m` : s,
+  dim: (s) => isTTY ? `\x1B[2m${s}\x1B[0m` : s,
+  green: (s) => isTTY ? `\x1B[32m${s}\x1B[0m` : s,
+  yellow: (s) => isTTY ? `\x1B[33m${s}\x1B[0m` : s,
+  cyan: (s) => isTTY ? `\x1B[36m${s}\x1B[0m` : s,
+  red: (s) => isTTY ? `\x1B[31m${s}\x1B[0m` : s
+};
+var colors = c;
+function print(msg) {
+  process.stdout.write(msg + "\n");
+}
+function printInfo(msg) {
+  print(c.cyan("\u2139") + "  " + msg);
+}
+function printSuccess(msg) {
+  print(c.green("\u2714") + "  " + msg);
+}
+function printWarning(msg) {
+  print(c.yellow("\u26A0") + "  " + msg);
+}
+function printError(msg) {
+  print(c.red("\u2716") + "  " + msg);
+}
+function printHeader(title) {
+  print("\n" + c.bold(title));
+}
+function printStep(step) {
+  print(c.dim("  \u2192") + " " + step);
+}
+function printTable(rows, pad = 20) {
+  for (const [left, right] of rows) {
+    print("  " + c.cyan(left.padEnd(pad)) + right);
+  }
+}
+function fatal(msg) {
+  printError(msg);
+  process.exit(1);
+}
+var KNOWN_COMMANDS = /* @__PURE__ */ new Set(["new", "generate", "deploy", "dev", "help"]);
+function parseArgs(argv) {
+  const flags = {};
+  const positional = [];
+  let command = null;
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const [key, ...valueParts] = arg.slice(2).split("=");
+      if (valueParts.length) {
+        flags[key] = valueParts.join("=");
+      } else if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+        flags[key] = argv[++i];
+      } else {
+        flags[key] = true;
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      flags[arg[1]] = true;
+    } else {
+      if (command === null && KNOWN_COMMANDS.has(arg)) {
+        command = arg;
+      } else {
+        positional.push(arg);
+      }
+    }
+    i++;
+  }
+  return { command, positional, flags };
+}
+function mkdirp(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+function writeFile(filePath, content, force = false) {
+  const dir = path.dirname(filePath);
+  mkdirp(dir);
+  if (!force && fs.existsSync(filePath)) {
+    printWarning(`Skipped (already exists): ${filePath}`);
+    return;
+  }
+  fs.writeFileSync(filePath, content, "utf8");
+  printSuccess(`Created: ${filePath}`);
+}
+function slugify(str) {
+  return str.toLowerCase().replace(/[^a-z0-9-_]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function pascalCase(str) {
+  return str.replace(/[-_](.)/g, (_, c2) => c2.toUpperCase()).replace(/^(.)/, (_, c2) => c2.toUpperCase());
+}
+function camelCase(str) {
+  const p = pascalCase(str);
+  return p.charAt(0).toLowerCase() + p.slice(1);
+}
+
+// src/cli/commands/new.ts
+var path2 = __toESM(require("path"));
+var cp = __toESM(require("child_process"));
+async function runNew(args, flags) {
+  const name = args[0];
+  if (!name) fatal("Usage: nova new <project-name>");
+  const options = {
+    name,
+    skipInstall: flags["skip-install"] === true || flags["y"] === true
+  };
+  scaffold(options);
+  if (!options.skipInstall) {
+    printHeader("Installing dependencies\u2026");
+    printStep("npm install");
+    try {
+      cp.execSync("npm install", {
+        cwd: path2.resolve(slugify(name)),
+        stdio: "inherit"
+      });
+    } catch {
+      printWarning("npm install failed \u2014 run it manually inside the project folder.");
+    }
+  }
+  printHeader("Done!");
+  print("");
+  printInfo(`  cd ${slugify(name)}`);
+  printInfo("  cp .env.example .env   # add your BOT_TOKEN");
+  printInfo("  npm run dev");
+  print("");
+}
+function scaffold(options) {
+  const { name } = options;
+  const slug = slugify(name);
+  const root = path2.resolve(slug);
+  printHeader(`Creating Nova project "${slug}"\u2026`);
+  writeFile(
+    path2.join(root, "package.json"),
+    JSON.stringify(
+      {
+        name: slug,
+        version: "1.0.0",
+        type: "module",
+        scripts: {
+          build: "tsc",
+          start: "node dist/index.js",
+          dev: "nova dev"
+        },
+        dependencies: {
+          "novaapp-sdk": "latest"
+        },
+        devDependencies: {
+          typescript: "^5.0.0"
+        }
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  writeFile(
+    path2.join(root, "tsconfig.json"),
+    JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          module: "NodeNext",
+          moduleResolution: "NodeNext",
+          strict: true,
+          outDir: "./dist",
+          rootDir: "./src",
+          declaration: true,
+          skipLibCheck: true
+        },
+        include: ["src"]
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  writeFile(
+    path2.join(root, ".gitignore"),
+    [
+      "node_modules/",
+      "dist/",
+      ".env",
+      "*.log"
+    ].join("\n") + "\n"
+  );
+  writeFile(
+    path2.join(root, ".env.example"),
+    [
+      "# Copy this file to .env and fill in your values",
+      "BOT_TOKEN=your_token_here",
+      "SERVER_URL=https://nova.example.com"
+    ].join("\n") + "\n"
+  );
+  writeFile(
+    path2.join(root, "src", "index.ts"),
+    indexTemplate(slug)
+  );
+  writeFile(
+    path2.join(root, "src", "commands", "ping.ts"),
+    pingCommandTemplate()
+  );
+  writeFile(
+    path2.join(root, "src", "events", "ready.ts"),
+    readyEventTemplate()
+  );
+  printSuccess(`Project "${slug}" created at ./${slug}`);
+}
+function indexTemplate(botName) {
+  return `import { NovaClient } from 'novaapp-sdk'
+import { ping } from './commands/ping.js'
+import { onReady } from './events/ready.js'
+
+const client = new NovaClient({
+  token:     process.env.BOT_TOKEN  ?? '',
+  serverUrl: process.env.SERVER_URL ?? 'https://nova.example.com',
+})
+
+// Register commands
+client.commands.register(ping)
+
+// Register events
+client.on('ready', onReady)
+
+client.connect()
+`;
+}
+function pingCommandTemplate() {
+  return `import type { NovaClient, Interaction } from 'novaapp-sdk'
+
+export const ping = {
+  name:        'ping',
+  description: 'Replies with Pong!',
+
+  async execute(client: NovaClient, interaction: Interaction) {
+    await client.interactions.respond(interaction.id, {
+      content: 'Pong! \u{1F3D3}',
+    })
+  },
+}
+`;
+}
+function readyEventTemplate() {
+  return `import type { BotApplication } from 'novaapp-sdk'
+
+export function onReady(bot: BotApplication) {
+  console.log(\`\u2714  Logged in as \${bot.botUser?.username ?? 'Unknown'}\`)
+}
+`;
+}
+
+// src/cli/commands/generate.ts
+var path3 = __toESM(require("path"));
+async function runGenerate(args, flags) {
+  const [kindRaw, name] = args;
+  if (!kindRaw) {
+    fatal(
+      "Usage: nova generate <command|event|plugin|middleware> <name>\n  nova generate command ban\n  nova generate event messageDelete\n  nova generate plugin moderation\n  nova generate middleware rateLimit"
+    );
+  }
+  const kind = kindRaw.toLowerCase();
+  const KINDS = ["command", "event", "plugin", "middleware"];
+  if (!KINDS.includes(kind)) {
+    fatal(`Unknown kind "${kindRaw}". Must be one of: ${KINDS.join(", ")}`);
+  }
+  if (!name) fatal(`Usage: nova generate ${kind} <name>`);
+  const options = {
+    kind,
+    name,
+    outDir: typeof flags["out"] === "string" ? flags["out"] : void 0
+  };
+  generate(options);
+}
+function generate(options) {
+  const { kind, name } = options;
+  const defaultDirs = {
+    command: "src/commands",
+    event: "src/events",
+    plugin: "src/plugins",
+    middleware: "src/middleware"
+  };
+  const outDir = options.outDir ?? defaultDirs[kind];
+  const fileName = camelCase(name) + ".ts";
+  const filePath = path3.resolve(outDir, fileName);
+  const generators = {
+    command: () => commandTemplate(name),
+    event: () => eventTemplate(name),
+    plugin: () => pluginTemplate(name),
+    middleware: () => middlewareTemplate(name)
+  };
+  printHeader(`Generating ${kind} "${name}"\u2026`);
+  writeFile(filePath, generators[kind]());
+  print("");
+  printInfo(`Register it in your bot entry:
+`);
+  const hints = {
+    command: `  client.commands.register(${camelCase(name)})`,
+    event: `  client.on('${camelCase(name)}', handle${pascalCase(name)})`,
+    plugin: `  client.plugins.use(${camelCase(name)}Plugin)`,
+    middleware: `  client.middleware.use(${camelCase(name)}Middleware)`
+  };
+  printInfo(hints[kind]);
+  print("");
+}
+function commandTemplate(name) {
+  const identName = camelCase(name);
+  const pascal = pascalCase(name);
+  return `import type { NovaClient, Interaction } from 'novaapp-sdk'
+
+/**
+ * /${name} command
+ */
+export const ${identName} = {
+  name:        '${name}',
+  description: 'Description of the ${name} command',
+
+  async execute(client: NovaClient, interaction: Interaction) {
+    await client.interactions.respond(interaction.id, {
+      content: '${pascal} executed!',
+    })
+  },
+}
+`;
+}
+function eventTemplate(name) {
+  const pascal = pascalCase(name);
+  return `import type { NovaClient } from 'novaapp-sdk'
+
+/**
+ * Handler for the \`${name}\` event.
+ */
+export async function handle${pascal}(
+  ..._args: unknown[]
+): Promise<void> {
+  // TODO: implement ${name} handler
+}
+
+/**
+ * Register this handler with a client.
+ */
+export function register${pascal}(client: NovaClient): void {
+  client.on('${name}' as never, handle${pascal})
+}
+`;
+}
+function pluginTemplate(name) {
+  const pascal = pascalCase(name);
+  const ident = camelCase(name);
+  return `import type { NovaPlugin, NovaClient } from 'novaapp-sdk'
+
+/**
+ * ${pascal} plugin.
+ */
+interface ${pascal}PluginOptions {
+  // TODO: add your plugin options
+}
+
+export function ${ident}Plugin(options: ${pascal}PluginOptions = {}): NovaPlugin {
+  return {
+    name: '${ident}',
+
+    install(client: NovaClient) {
+      // TODO: implement plugin logic
+      void options  // remove this line once you use options
+    },
+  }
+}
+`;
+}
+function middlewareTemplate(name) {
+  const pascal = pascalCase(name);
+  const ident = camelCase(name);
+  return `import type { NovaMiddleware, MiddlewareContext, MiddlewareNext } from 'novaapp-sdk'
+
+/**
+ * ${pascal} middleware.
+ */
+export const ${ident}Middleware: NovaMiddleware = async (
+  ctx:  MiddlewareContext,
+  next: MiddlewareNext,
+): Promise<void> => {
+  // TODO: add ${name} logic here (before next())
+  await next()
+  // TODO: add ${name} logic here (after next())
+}
+`;
+}
+
+// src/cli/commands/deploy.ts
+var cp2 = __toESM(require("child_process"));
+async function runDeploy(args, flags) {
+  const options = {
+    skipBuild: flags["skip-build"] === true
+  };
+  const provider = typeof flags["provider"] === "string" ? flags["provider"] : "generic";
+  if (!options.skipBuild) {
+    await build();
+  } else {
+    printWarning("Skipping build (--skip-build)");
+  }
+  printDeployInstructions(provider);
+}
+function build() {
+  return new Promise((resolve5, reject) => {
+    printHeader("Building project\u2026");
+    printStep("npm run build");
+    const child = cp2.spawn("npm", ["run", "build"], {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        printSuccess("Build succeeded");
+        resolve5();
+      } else {
+        reject(new Error(`Build failed with exit code ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+}
+function printDeployInstructions(provider) {
+  printHeader("Deployment guide");
+  print("");
+  if (provider === "railway" || provider === "rail") {
+    printRailway();
+  } else if (provider === "docker") {
+    printDocker();
+  } else if (provider === "vps") {
+    printVps();
+  } else {
+    printGeneric();
+  }
+  print("");
+  printInfo("Tip: pass --provider=railway|docker|vps for provider-specific instructions.");
+  print("");
+}
+function printGeneric() {
+  print(colors.bold("  Generic (any Node.js host)"));
+  print("");
+  printStep("Ensure BOT_TOKEN and SERVER_URL are set as environment variables");
+  printStep("Upload your project (dist/, package.json, .env) to the host");
+  printStep("Run:  node dist/index.js");
+  print("");
+  print("  For platform-specific guides run:");
+  print(colors.cyan("    nova deploy --provider=railway"));
+  print(colors.cyan("    nova deploy --provider=docker"));
+  print(colors.cyan("    nova deploy --provider=vps"));
+}
+function printRailway() {
+  print(colors.bold("  Railway"));
+  print("");
+  printStep("Install Railway CLI:  npm i -g @railway/cli");
+  printStep("Login:                railway login");
+  printStep("Create project:       railway init");
+  printStep("Set secrets:          railway variables set BOT_TOKEN=xxx SERVER_URL=xxx");
+  printStep("Deploy:               railway up");
+  print("");
+  print("  Nova bot will auto-restart on crashes (Railway default).");
+}
+function printDocker() {
+  print(colors.bold("  Docker"));
+  print("");
+  printStep("Build image:  docker build -t my-nova-bot .");
+  printStep("Run:          docker run -e BOT_TOKEN=xxx -e SERVER_URL=xxx my-nova-bot");
+  print("");
+  print("  Sample Dockerfile:");
+  print(colors.dim([
+    "  FROM node:20-alpine",
+    "  WORKDIR /app",
+    "  COPY package*.json ./",
+    "  RUN npm ci --omit=dev",
+    "  COPY dist/ ./dist/",
+    '  CMD ["node", "dist/index.js"]'
+  ].join("\n")));
+}
+function printVps() {
+  print(colors.bold("  VPS / bare metal"));
+  print("");
+  printStep("Copy dist/ and package.json to the server");
+  printStep("npm ci --omit=dev");
+  printStep("Set BOT_TOKEN and SERVER_URL in your environment / .env");
+  printStep("Use PM2 for process management:");
+  print("");
+  print(colors.dim([
+    "  npm install -g pm2",
+    "  pm2 start dist/index.js --name my-nova-bot",
+    "  pm2 save",
+    "  pm2 startup  # persist across reboots"
+  ].join("\n")));
+}
+
+// src/cli/commands/dev.ts
+var cp3 = __toESM(require("child_process"));
+var fs3 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+
+// src/devtools/HotLoader.ts
+var import_node_events = require("events");
+var fs2 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var HotLoader = class extends import_node_events.EventEmitter {
+  constructor(watchPath, options = {}) {
+    super();
+    this.watcher = null;
+    this.debounceTimer = null;
+    this.lastChanged = null;
+    this.restartFn = null;
+    this.restarting = false;
+    this.watchPath = path4.resolve(watchPath);
+    this.debounceMs = options.debounce ?? 250;
+    this.recursive = options.recursive ?? true;
+    this.extensions = new Set(
+      options.extensions ?? [".ts", ".js", ".mjs", ".cjs", ".json"]
+    );
+  }
+  // ── Lifecycle ──────────────────────────────────────────────────────────────
+  /**
+   * Start watching for file changes.
+   *
+   * Calling `start()` again after `stop()` is safe — it creates a new watcher.
+   */
+  start() {
+    if (this.watcher) return;
+    this.watcher = fs2.watch(
+      this.watchPath,
+      { recursive: this.recursive, encoding: "utf8" },
+      (event, filename) => {
+        if (!filename) return;
+        const ext = path4.extname(filename);
+        if (!this.extensions.has(ext)) return;
+        const full = path4.join(this.watchPath, filename);
+        this.emit("change", full);
+        this.lastChanged = full;
+        if (this.debounceTimer) clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+          this.debounceTimer = null;
+          if (this.lastChanged) {
+            const f = this.lastChanged;
+            this.lastChanged = null;
+            this.emit("reload", f);
+            this.triggerRestart();
+          }
+        }, this.debounceMs);
+      }
+    );
+    this.watcher.on("error", (err) => {
+      this.emit("error", err);
+    });
+  }
+  /**
+   * Stop watching.  Safe to call even if not started.
+   */
+  stop() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+  }
+  // ── Restart helper ─────────────────────────────────────────────────────────
+  /**
+   * Register a callback that runs after every debounced `reload` event.
+   *
+   * If the callback is already running when another reload fires it will be
+   * queued once and run again after the current run finishes.
+   *
+   * @example
+   * ```ts
+   * loader.restart(async () => {
+   *   await client.disconnect()
+   *   await build()
+   *   await client.connect()
+   * })
+   * ```
+   */
+  restart(fn) {
+    this.restartFn = fn;
+  }
+  triggerRestart() {
+    if (!this.restartFn || this.restarting) return;
+    const fn = this.restartFn;
+    this.restarting = true;
+    const result = fn();
+    const finish = () => {
+      this.restarting = false;
+    };
+    if (result instanceof Promise) {
+      result.then(finish, (err) => {
+        finish();
+        this.emit("error", err instanceof Error ? err : new Error(String(err)));
+      });
+    } else {
+      finish();
+    }
+  }
+  // ── Typed event overloads ──────────────────────────────────────────────────
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  /** Whether the loader is currently active. */
+  get watching() {
+    return this.watcher !== null;
+  }
+};
+
+// src/cli/commands/dev.ts
+async function runDev(args, flags) {
+  const entry = typeof flags["entry"] === "string" ? flags["entry"] : detectEntry();
+  const debounce = typeof flags["debounce"] === "string" ? parseInt(flags["debounce"], 10) : 250;
+  const noWatch = flags["no-watch"] === true;
+  if (!fs3.existsSync(entry)) {
+    fatal(
+      `Entry file not found: ${entry}
+Specify one with --entry src/index.ts or --entry dist/index.js`
+    );
+  }
+  printHeader("Nova dev mode");
+  printStep(`Entry:  ${entry}`);
+  printStep(`Watch:  ${noWatch ? "disabled" : "enabled"}`);
+  print("");
+  if (noWatch) {
+    spawnOnce(entry);
+    return;
+  }
+  const nodeVersion = parseInt(process.versions.node.split(".")[0], 10);
+  const useNodeWatch = nodeVersion >= 18 && entry.endsWith(".js");
+  if (useNodeWatch) {
+    spawnWithNodeWatch(entry);
+  } else {
+    await spawnWithHotLoader(entry, debounce);
+  }
+}
+function spawnOnce(entry) {
+  printInfo("Starting bot (no watch)\u2026");
+  const child = cp3.spawn(process.execPath, [entry], {
+    stdio: "inherit",
+    env: { ...process.env }
+  });
+  child.on("close", (code) => {
+    print(`
+Bot exited with code ${code ?? 0}`);
+    process.exit(code ?? 0);
+  });
+  child.on("error", (err) => {
+    throw err;
+  });
+}
+function spawnWithNodeWatch(entry) {
+  printInfo("Starting bot with node --watch (Node 18+ built-in)\u2026");
+  printStep("Press Ctrl+C to stop");
+  print("");
+  const child = cp3.spawn(process.execPath, ["--watch", entry], {
+    stdio: "inherit",
+    env: { ...process.env }
+  });
+  child.on("error", (err) => {
+    throw err;
+  });
+  process.on("SIGINT", () => {
+    child.kill();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    child.kill();
+    process.exit(0);
+  });
+}
+async function spawnWithHotLoader(entry, debounce) {
+  const srcDir = path5.resolve("src");
+  if (!fs3.existsSync(srcDir)) {
+    printWarning("src/ directory not found \u2014 watching project root");
+  }
+  const watchDir = fs3.existsSync(srcDir) ? srcDir : process.cwd();
+  printInfo(`Watching ${watchDir} for changes\u2026`);
+  printStep("Press Ctrl+C to stop");
+  print("");
+  let current = null;
+  function spawnBot() {
+    if (current) {
+      current.kill();
+      current = null;
+    }
+    printStep("Starting bot\u2026");
+    current = cp3.spawn(process.execPath, [entry], {
+      stdio: "inherit",
+      env: { ...process.env }
+    });
+    current.on("close", (code) => {
+      if (code !== null && code !== 0) {
+        printWarning(`Bot exited with code ${code} \u2014 waiting for changes\u2026`);
+      }
+    });
+    current.on("error", (err) => {
+      printWarning(`Spawn error: ${err.message}`);
+    });
+  }
+  spawnBot();
+  const loader = new HotLoader(watchDir, { debounce });
+  loader.on("reload", (changed) => {
+    printInfo(`Reloading (${path5.relative(process.cwd(), changed)})`);
+    spawnBot();
+  });
+  loader.on("error", (err) => {
+    printWarning(`Watcher error: ${err.message}`);
+  });
+  loader.start();
+  await new Promise((resolve5) => {
+    process.on("SIGINT", () => {
+      loader.stop();
+      current?.kill();
+      resolve5();
+    });
+    process.on("SIGTERM", () => {
+      loader.stop();
+      current?.kill();
+      resolve5();
+    });
+  });
+}
+function detectEntry() {
+  const candidates = ["dist/index.js", "src/index.ts", "index.js", "index.ts"];
+  for (const c2 of candidates) {
+    if (fs3.existsSync(path5.resolve(c2))) {
+      if (c2.endsWith(".ts")) {
+        printWarning(
+          `Auto-detected TypeScript entry (${c2}).
+  Note: nova dev runs compiled JS. Run "npm run build" first, or
+  use ts-node / tsx: nova dev --entry dist/index.js`
+        );
+      }
+      return path5.resolve(c2);
+    }
+  }
+  return path5.resolve("dist/index.js");
+}
+
+// src/cli/runner.ts
+var VERSION = "1.4.1";
+async function run(argv) {
+  const parsed = parseArgs(argv);
+  const { command, positional, flags } = parsed;
+  if (flags["version"] || flags["v"]) {
+    print(`nova ${VERSION}`);
+    return;
+  }
+  if (!command || command === "help" || flags["help"] || flags["h"]) {
+    printHelp();
+    return;
+  }
+  try {
+    switch (command) {
+      case "new":
+        await runNew(positional, flags);
+        break;
+      case "generate":
+        await runGenerate(positional, flags);
+        break;
+      case "deploy":
+        await runDeploy(positional, flags);
+        break;
+      case "dev":
+        await runDev(positional, flags);
+        break;
+      default:
+        fatal(`Unknown command "${command}". Run "nova help" for usage.`);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    fatal(msg);
+  }
+}
+function printHelp() {
+  print("");
+  print(colors.bold(`  Nova CLI  v${VERSION}`));
+  print(colors.dim("  The Nova Discord SDK command-line interface"));
+  print("");
+  print(colors.bold("  Usage"));
+  print("    nova <command> [options]");
+  print("");
+  print(colors.bold("  Commands"));
+  printTable(
+    [
+      ["new <name>", "Scaffold a new Nova bot project"],
+      ["generate <kind> <name>", "Generate a command, event, plugin, or middleware"],
+      ["dev", "Start the bot with hot reload"],
+      ["deploy", "Build and print deployment instructions"],
+      ["help", "Show this help message"]
+    ],
+    30
+  );
+  print("");
+  print(colors.bold("  Generate kinds"));
+  printTable(
+    [
+      ["command", "Slash / prefix command handler"],
+      ["event", "Gateway event handler"],
+      ["plugin", "Reusable plugin"],
+      ["middleware", "Command middleware"]
+    ],
+    14
+  );
+  print("");
+  print(colors.bold("  Examples"));
+  print(colors.dim("    nova new my-bot"));
+  print(colors.dim("    nova generate command ban"));
+  print(colors.dim("    nova generate event messageDelete"));
+  print(colors.dim("    nova dev --entry dist/index.js"));
+  print(colors.dim("    nova deploy --provider=railway"));
+  print("");
+  print(colors.bold("  Options"));
+  printTable(
+    [
+      ["--version, -v", "Print version number"],
+      ["--help, -h", "Print this help text"]
+    ],
+    20
+  );
+  print("");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  run
+});