commandkit 0.1.11-dev.20250331145527 → 0.1.11-dev.20250402134128

package/dist/index.js

@@ -2021,6 +2021,13 @@ var init_RuntimePlugin = __esm({
        */
       async onCommandsRouterInit(ctx) {
       }
+      /**
+       * Called when HMR event is received
+       * @param ctx The context
+       * @param event The event
+       */
+      async performHMR(ctx, event) {
+      }
     };
     __name(_RuntimePlugin, "RuntimePlugin");
     RuntimePlugin = _RuntimePlugin;
@@ -2521,7 +2528,7 @@ var init_UseCacheTransformer = __esm({
     generate = import_generator.default.default || import_generator.default;
     IMPORT_PATH = "commandkit";
     DIRECTIVE = "use cache";
-    CACHE_IDENTIFIER = "super_duper_secret_internal_for_use_cache_directive_of_commandkit_cli_do_not_use_it_directly_or_you_will_be_fired_from_your_job_kthxbai";
+    CACHE_IDENTIFIER = "zzz_commandkit_secret_internal_use_cache_wrapper_do_not_use_or_you_will_be_fired";
     generateRandomString = /* @__PURE__ */ __name((length = 6) => {
       const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
       return Array.from(
@@ -2543,22 +2550,22 @@ var init_UseCacheTransformer = __esm({
       };
       traverse(ast, {
         Program: {
-          enter(path2) {
-            const binding = path2.scope.getBinding(CACHE_IDENTIFIER);
+          enter(path3) {
+            const binding = path3.scope.getBinding(CACHE_IDENTIFIER);
             if (binding) {
               state.cacheIdentifierName = `${CACHE_IDENTIFIER}_${generateRandomString()}`;
             }
           }
         },
-        ImportDeclaration(path2) {
-          if (path2.node.source.value === IMPORT_PATH && path2.node.specifiers.some(
+        ImportDeclaration(path3) {
+          if (path3.node.source.value === IMPORT_PATH && path3.node.specifiers.some(
             (spec) => t.isImportSpecifier(spec) && // @ts-ignore
             spec.imported.name === CACHE_IDENTIFIER
           )) {
             state.hasExistingImport = true;
             if (state.cacheIdentifierName !== CACHE_IDENTIFIER) {
               state.modifications.push(() => {
-                path2.node.specifiers.forEach((spec) => {
+                path3.node.specifiers.forEach((spec) => {
                   if (t.isImportSpecifier(spec) && // @ts-ignore
                   spec.imported.name === CACHE_IDENTIFIER) {
                     spec.local.name = state.cacheIdentifierName;
@@ -2568,14 +2575,14 @@ var init_UseCacheTransformer = __esm({
             }
           }
         },
-        "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression|ObjectMethod"(path2) {
+        "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression|ObjectMethod"(path3) {
           var _a2, _b, _c;
-          const body = t.isBlockStatement(path2.node.body) ? path2.node.body : null;
+          const body = t.isBlockStatement(path3.node.body) ? path3.node.body : null;
           const hasUseCache = (_a2 = body == null ? void 0 : body.directives) == null ? void 0 : _a2.some(
             (d) => d.value.value === DIRECTIVE
           );
-          if (!hasUseCache && !t.isBlockStatement(path2.node.body)) {
-            const parentFunction = path2.findParent(
+          if (!hasUseCache && !t.isBlockStatement(path3.node.body)) {
+            const parentFunction = path3.findParent(
               (p) => (p.isFunction() || p.isProgram()) && "directives" in p.node
             );
             if (!((_b = parentFunction == null ? void 0 : parentFunction.node.directives) == null ? void 0 : _b.some(
@@ -2584,35 +2591,35 @@ var init_UseCacheTransformer = __esm({
               return;
             }
           }
-          if (hasUseCache || !t.isBlockStatement(path2.node.body)) {
-            if (!path2.node.async) {
+          if (hasUseCache || !t.isBlockStatement(path3.node.body)) {
+            if (!path3.node.async) {
               throw new Error(
                 `"${DIRECTIVE}" directive may only be used in async functions at ${args.path}
 
-${path2.toString()}
+${path3.toString()}
 ^^^^${"-".repeat(6)} This function must be async`
               );
             }
             state.needsImport = true;
-            const isDeclaration = t.isFunctionDeclaration(path2.node);
-            const name = isDeclaration ? (_c = path2.node.id) == null ? void 0 : _c.name : void 0;
-            const newBody = t.isBlockStatement(path2.node.body) ? t.blockStatement(
-              path2.node.body.body,
-              path2.node.body.directives.filter(
+            const isDeclaration = t.isFunctionDeclaration(path3.node);
+            const name = isDeclaration ? (_c = path3.node.id) == null ? void 0 : _c.name : void 0;
+            const newBody = t.isBlockStatement(path3.node.body) ? t.blockStatement(
+              path3.node.body.body,
+              path3.node.body.directives.filter(
                 (d) => d.value.value !== DIRECTIVE
               )
-            ) : path2.node.body;
+            ) : path3.node.body;
             const wrapped = t.callExpression(
               t.identifier(state.cacheIdentifierName),
-              [t.arrowFunctionExpression(path2.node.params, newBody, true)]
+              [t.arrowFunctionExpression(path3.node.params, newBody, true)]
             );
             state.modifications.push(() => {
-              if (t.isObjectMethod(path2.node)) {
-                path2.replaceWith(
-                  t.objectProperty(t.identifier(path2.node.key.name), wrapped)
+              if (t.isObjectMethod(path3.node)) {
+                path3.replaceWith(
+                  t.objectProperty(t.identifier(path3.node.key.name), wrapped)
                 );
               } else if (name) {
-                path2.replaceWith(
+                path3.replaceWith(
                   t.variableDeclaration(
                     "const",
                     [
@@ -2620,10 +2627,10 @@ ${path2.toString()}
                     ]
                   )
                 );
-              } else if (!t.isVariableDeclarator(path2.parent)) {
-                path2.replaceWith(wrapped);
+              } else if (!t.isVariableDeclarator(path3.parent)) {
+                path3.replaceWith(wrapped);
               } else {
-                path2.parent.init = wrapped;
+                path3.parent.init = wrapped;
               }
             });
           }
@@ -2807,7 +2814,7 @@ var init_config = __esm({
 });
 
 // src/utils/constants.ts
-var COMMANDKIT_CACHE_TAG, COMMANDKIT_IS_DEV, COMMANDKIT_IS_TEST;
+var COMMANDKIT_CACHE_TAG, COMMANDKIT_IS_DEV, COMMANDKIT_IS_TEST, HMREventType;
 var init_constants = __esm({
   "src/utils/constants.ts"() {
     "use strict";
@@ -2815,6 +2822,12 @@ var init_constants = __esm({
     COMMANDKIT_CACHE_TAG = Symbol("kCommandKitCacheTag");
     COMMANDKIT_IS_DEV = !!process.env.COMMANDKIT_IS_DEV;
     COMMANDKIT_IS_TEST = process.env.COMMANDKIT_IS_TEST === "true";
+    HMREventType = {
+      ReloadCommands: "reload-commands",
+      ReloadEvents: "reload-events",
+      ReloadLocales: "reload-locales",
+      Unknown: "unknown"
+    };
   }
 });
 
@@ -2840,18 +2853,18 @@ var init_DefaultLocalizationStrategy = __esm({
         const paths = [".js", ".json", ".mjs", ".cjs"].map(
           (e) => (0, import_node_path.join)(localesPath, locale, scope) + e
         );
-        for (const path2 of paths) {
-          if (!(0, import_node_fs.existsSync)(path2)) {
+        for (const path3 of paths) {
+          if (!(0, import_node_fs.existsSync)(path3)) {
             continue;
           }
           try {
             let localeData;
             try {
-              if (path2.endsWith(".json")) {
-                const data = await (0, import_promises2.readFile)(path2, "utf-8");
+              if (path3.endsWith(".json")) {
+                const data = await (0, import_promises2.readFile)(path3, "utf-8");
                 localeData = JSON.parse(data);
               } else {
-                const { default: data } = await import(`file://${path2}`);
+                const { default: data } = await import(`file://${path3}`);
                 localeData = data;
               }
             } catch {
@@ -2882,8 +2895,8 @@ export {};
 declare module 'commandkit' {
   export interface CommandLocalizationTypeData {
 `;
-        const footer = `  type TranslatableCommandName = keyof CommandLocalizationTypeData
-}
+        const footer = `  }
+type TranslatableCommandName = keyof CommandLocalizationTypeData
 }`;
         const generateType = /* @__PURE__ */ __name((locale) => {
           const commandName = locale.command.name;
@@ -2982,6 +2995,13 @@ function getCurrentDirectory() {
   currentDir = root;
   return root;
 }
+function getSourceDirectories() {
+  const dist = getConfig().distDir;
+  const locations = ["src", ".commandkit", dist].map(
+    (dir) => (0, import_node_path2.join)(process.cwd(), dir)
+  );
+  return locations;
+}
 function findAppDirectory() {
   if (appDir) return appDir;
   let root = (0, import_node_path2.join)(
@@ -3031,6 +3051,7 @@ var init_utilities = __esm({
     appDir = null;
     currentDir = null;
     __name(getCurrentDirectory, "getCurrentDirectory");
+    __name(getSourceDirectories, "getSourceDirectories");
     __name(findAppDirectory, "findAppDirectory");
     __name(debounce, "debounce");
   }
@@ -3444,9 +3465,24 @@ var init_environment = __esm({
           deferredFunctions: /* @__PURE__ */ new Map(),
           marker: "",
           markStart: 0,
-          markEnd: 0
+          markEnd: 0,
+          context: null
         });
       }
+      /**
+       * Set the context.
+       * @param context - The context to set.
+       */
+      setContext(context2) {
+        __privateGet(this, _data).context = context2;
+      }
+      /**
+       * Get the context. `null` if not set.
+       * @internal
+       */
+      get context() {
+        return __privateGet(this, _data).context;
+      }
       /**
        * Get the execution error.
        * @internal
@@ -3769,7 +3805,7 @@ async function revalidate(tag, ...args) {
 function isCachedFunction(fn) {
   return Object.prototype.hasOwnProperty.call(fn, CACHED_FN_SYMBOL);
 }
-var import_node_async_hooks2, import_node_crypto2, import_ms, cacheContext, fnStore, DEFAULT_TTL, CACHE_FN_ID, CACHED_FN_SYMBOL;
+var import_node_async_hooks2, import_node_crypto2, import_ms, cacheContext, fnStore, DEFAULT_TTL, CACHE_FN_ID, CACHED_FN_SYMBOL, zzz_commandkit_secret_internal_use_cache_wrapper_do_not_use_or_you_will_be_fired;
 var init_cache = __esm({
   "src/cache/cache.ts"() {
     "use strict";
@@ -3792,6 +3828,7 @@ var init_cache = __esm({
     __name(invalidate, "invalidate");
     __name(revalidate, "revalidate");
     __name(isCachedFunction, "isCachedFunction");
+    zzz_commandkit_secret_internal_use_cache_wrapper_do_not_use_or_you_will_be_fired = useCache;
   }
 });
 
@@ -3856,6 +3893,9 @@ var init_Context = __esm({
         this.client = commandkit2.client;
         __privateSet(this, _store, config.store ?? /* @__PURE__ */ new Map());
         this.command = config.command;
+        if (this.config.environment) {
+          this.config.environment.setContext(this);
+        }
       }
       /**
        * The shared key-value store for this context. This can be used to store data that needs to be shared between middlewares or commands.
@@ -4876,8 +4916,8 @@ var init_CommandsRouter = __esm({
           middlewares: Object.fromEntries(this.middlewares.entries())
         };
       }
-      async traverse(path2, category) {
-        const entries = await (0, import_promises4.readdir)(path2, {
+      async traverse(path3, category) {
+        const entries = await (0, import_promises4.readdir)(path3, {
           withFileTypes: true
         });
         for (const entry of entries) {
@@ -4891,24 +4931,24 @@ var init_CommandsRouter = __esm({
       }
       async handle(entry, category = null) {
         const name = entry.name;
-        const path2 = (0, import_node_path4.join)(entry.parentPath, entry.name);
+        const path3 = (0, import_node_path4.join)(entry.parentPath, entry.name);
         if (this.isCommand(name)) {
           const command = {
             id: crypto.randomUUID(),
-            name: (0, import_node_path4.basename)(path2, (0, import_node_path4.extname)(path2)),
-            path: path2,
+            name: (0, import_node_path4.basename)(path3, (0, import_node_path4.extname)(path3)),
+            path: path3,
             category,
             parentPath: entry.parentPath,
-            relativePath: this.replaceEntrypoint(path2),
+            relativePath: this.replaceEntrypoint(path3),
             middlewares: []
           };
           this.commands.set(command.id, command);
         } else if (this.isMiddleware(name)) {
           const middleware = {
             id: crypto.randomUUID(),
-            name: (0, import_node_path4.basename)(path2, (0, import_node_path4.extname)(path2)),
-            path: path2,
-            relativePath: this.replaceEntrypoint(path2),
+            name: (0, import_node_path4.basename)(path3, (0, import_node_path4.extname)(path3)),
+            path: path3,
+            relativePath: this.replaceEntrypoint(path3),
             parentPath: entry.parentPath,
             global: GLOBAL_MIDDLEWARE_PATTERN.test(name)
           };
@@ -4926,8 +4966,8 @@ var init_CommandsRouter = __esm({
           );
         });
       }
-      replaceEntrypoint(path2) {
-        const normalized = (0, import_node_path4.normalize)(path2);
+      replaceEntrypoint(path3) {
+        const normalized = (0, import_node_path4.normalize)(path3);
         return normalized.replace(this.options.entrypoint, "");
       }
     };
@@ -5017,8 +5057,8 @@ var init_EventsRouter = __esm({
           const dirs = await (0, import_promises5.readdir)(entrypoint, { withFileTypes: true });
           for (const dir of dirs) {
             if (dir.isDirectory()) {
-              const path2 = (0, import_node_path5.join)(entrypoint, dir.name);
-              await this.scanEvent(dir.name, path2, null, [], true);
+              const path3 = (0, import_node_path5.join)(entrypoint, dir.name);
+              await this.scanEvent(dir.name, path3, null, [], true);
             }
           }
         }
@@ -5038,14 +5078,14 @@ var init_EventsRouter = __esm({
        * @param listeners - Array to collect listener file paths
        * @returns Promise resolving to the parsed event metadata
        */
-      async scanEvent(event, path2, _namespace = null, listeners = [], isRoot = false) {
-        const files = await (0, import_promises5.readdir)(path2, { withFileTypes: true });
+      async scanEvent(event, path3, _namespace = null, listeners = [], isRoot = false) {
+        const files = await (0, import_promises5.readdir)(path3, { withFileTypes: true });
         const isNamespace = isRoot && /^\(.+\)$/.test(event);
         const namespace = isNamespace ? event.slice(1, -1) : _namespace ?? null;
         for (const file of files) {
           if (file.name.includes("_")) continue;
           if (file.isDirectory()) {
-            const nextPath = (0, import_node_path5.join)(path2, file.name);
+            const nextPath = (0, import_node_path5.join)(path3, file.name);
             await this.scanEvent(file.name, nextPath, namespace, listeners);
             continue;
           }
@@ -5054,7 +5094,7 @@ var init_EventsRouter = __esm({
           }
         }
         if (!isNamespace) {
-          this.events.set(event, { event, path: path2, listeners, namespace });
+          this.events.set(event, { event, path: path3, listeners, namespace });
         }
       }
     };
@@ -5302,8 +5342,11 @@ var init_common2 = __esm({
 });
 
 // src/config/loader.ts
+function getPossibleConfigPaths(root) {
+  return CONFIG_FILE_NAMES.map((name) => (0, import_node_path7.join)(root, name));
+}
 function findConfigFile(cwd) {
-  const locations = CONFIG_FILE_NAMES.map((name) => (0, import_node_path7.join)(cwd, name));
+  const locations = getPossibleConfigPaths(cwd);
   for (const location of locations) {
     if ((0, import_node_fs7.existsSync)(location)) {
       return {
@@ -5337,6 +5380,7 @@ var init_loader = __esm({
       "commandkit.config.cjs",
       "commandkit.config.ts"
     ];
+    __name(getPossibleConfigPaths, "getPossibleConfigPaths");
     __name(findConfigFile, "findConfigFile");
     loadedConfig = null;
     __name(loadConfigFile, "loadConfigFile");
@@ -5346,23 +5390,55 @@ var init_loader = __esm({
 // src/utils/dev-hooks.ts
 function registerDevHooks(commandkit2) {
   if (!COMMANDKIT_IS_DEV) return;
-  process.on("message", (message) => {
+  process.on("message", async (message) => {
     if (typeof message !== "object" || message === null) return;
-    const { event, path: path2 } = message;
+    const { event, path: path3, id } = message;
     if (!event) return;
     if (process.env.COMMANDKIT_DEBUG_HMR === "true") {
-      Logger.info(`Received HMR event: ${event}${path2 ? ` for ${path2}` : ""}`);
+      Logger.info(`Received HMR event: ${event}${path3 ? ` for ${path3}` : ""}`);
     }
-    switch (event) {
-      case "reload-commands":
-        commandkit2.commandHandler.reloadCommands();
-        break;
-      case "reload-events":
-        commandkit2.eventHandler.reloadEvents();
-        break;
-      case "reload-locales":
-        commandkit2.commandHandler.reloadCommands();
-        break;
+    let accepted = false, prevented = false, handled = false;
+    const hmrEvent = {
+      accept() {
+        accepted = true;
+      },
+      preventDefault() {
+        prevented = true;
+      },
+      path: path3,
+      event
+    };
+    try {
+      await commandkit2.plugins.execute(async (ctx, plugin) => {
+        var _a;
+        if (accepted) return;
+        await ((_a = plugin.performHMR) == null ? void 0 : _a.call(plugin, ctx, hmrEvent));
+      });
+      if (prevented) return;
+      switch (event) {
+        case HMREventType.ReloadCommands:
+          commandkit2.commandHandler.reloadCommands();
+          handled = true;
+          break;
+        case HMREventType.ReloadEvents:
+        case HMREventType.ReloadLocales:
+          commandkit2.eventHandler.reloadEvents();
+          handled = true;
+          break;
+        case HMREventType.Unknown:
+          handled = false;
+          break;
+        default:
+          break;
+      }
+    } finally {
+      if (id && process.send) {
+        process.send({
+          type: "commandkit-hmr-ack",
+          id,
+          handled: handled || accepted
+        });
+      }
     }
   });
 }
@@ -5490,7 +5566,6 @@ var init_CommandKit = __esm({
         if (options.cacheProvider !== null && (!options.cacheProvider || !(options.cacheProvider instanceof CacheProvider))) {
           options.cacheProvider = new MemoryCache();
         }
-        this.eventInterceptor = new EventInterceptor(options.client);
         this.plugins = new CommandKitPluginRuntime(this);
         if (!_CommandKit.instance) {
           _CommandKit.instance = this;
@@ -5503,6 +5578,12 @@ var init_CommandKit = __esm({
        */
       async start(token) {
         if (__privateGet(this, _started)) return;
+        if (!this.options.client) {
+          throw new Error(
+            colors_default.red('"client" is required when starting CommandKit.')
+          );
+        }
+        this.eventInterceptor = new EventInterceptor(this.client);
         if (COMMANDKIT_IS_DEV) {
           try {
             registerDevHooks(this);
@@ -5716,7 +5797,7 @@ var init_version = __esm({
     "use strict";
     init_cjs_shims();
     version = /* @__MACRO__ $version */
-    "0.1.11-dev.20250331145527";
+    "0.1.11-dev.20250402134128";
   }
 });
 
@@ -5866,7 +5947,7 @@ ${wrapInAsyncIIFE([envScript(isDev), antiCrashScript, requireScript])}
 import { CommandKit } from 'commandkit';
 import app from './app.js';
 
-async function main() {
+async function bootstrap() {
   const commandkit = new CommandKit({
     client: app,
   });
@@ -5874,7 +5955,9 @@ async function main() {
   await commandkit.start();
 }
 
-await main();
+await bootstrap().catch((e) => {
+  console.error('Failed to bootstrap CommandKit application:\\n', e.stack);
+})
 `;
   const dist = isDev ? ".commandkit" : distDir || "dist";
   await (0, import_promises6.writeFile)((0, import_node_path10.join)(configPath, dist, "index.js"), code);
@@ -5956,52 +6039,116 @@ async function buildAndStart(configPath, skipStart = false) {
   });
   if (skipStart) return null;
   const ps = createAppProcess(mainFile, configPath, true);
-  ps.on("message", (message) => {
-    console.log(`Received message from child process: ${message}`);
-  });
   return ps;
 }
 async function bootstrapDevelopmentServer(configPath) {
   const start = performance.now();
   const cwd = configPath || process.cwd();
-  const watcher = (0, import_chokidar.watch)([(0, import_path2.join)(cwd, "src")], {
+  const configPaths = getPossibleConfigPaths(cwd);
+  const watcher = (0, import_chokidar.watch)([(0, import_path2.join)(cwd, "src"), ...configPaths], {
     ignoreInitial: true
   });
   let ps = null;
-  const performHMR = debounce(async (path2) => {
-    if (!path2 || !ps) return false;
-    if (!ps.send) return false;
-    if (isCommandSource(path2)) {
-      console.log(
-        `${colors_default.cyanBright("Reloading command(s) at ")} ${colors_default.yellowBright(path2)}`
+  const waitForAcknowledgment = /* @__PURE__ */ __name((messageId) => {
+    return new Promise((resolve) => {
+      if (!ps) return resolve(false);
+      let _handled = false;
+      const onMessage = /* @__PURE__ */ __name((message) => {
+        _handled = true;
+        if (typeof message !== "object" || message === null) return;
+        const { type, id, handled } = message;
+        if (type === "commandkit-hmr-ack" && id === messageId) {
+          ps == null ? void 0 : ps.off("message", onMessage);
+          resolve(!!handled);
+        }
+      }, "onMessage");
+      ps.once("message", onMessage);
+      if (!_handled) {
+        (0, import_promises7.setTimeout)(3e3).then(() => {
+          ps == null ? void 0 : ps.off("message", onMessage);
+          resolve(false);
+        });
+      }
+    });
+  }, "waitForAcknowledgment");
+  const sendHmrEvent = /* @__PURE__ */ __name(async (event, path3) => {
+    if (!ps || !ps.send) return false;
+    const messageId = (0, import_node_crypto3.randomUUID)();
+    const messagePromise = waitForAcknowledgment(messageId);
+    ps.send({ event, path: path3, id: messageId });
+    try {
+      let triggered = false;
+      const res = !!await Promise.race(
+        [
+          messagePromise,
+          (0, import_promises7.setTimeout)(3e3).then(() => {
+            if (!triggered) {
+              console.warn(
+                colors_default.yellow(
+                  `HMR acknowledgment timed out for event ${event} on path ${path3}`
+                )
+              );
+            }
+            return false;
+          })
+        ]
       );
-      await buildAndStart(cwd, true);
-      ps.send({ event: "reload-commands", path: path2 });
-      return true;
-    }
-    if (isEventSource(path2)) {
-      console.log(
-        `${colors_default.cyanBright("Reloading event(s) at ")} ${colors_default.yellowBright(path2)}`
+      triggered = true;
+      return res;
+    } catch (error) {
+      console.error(
+        colors_default.red(`Error waiting for HMR acknowledgment: ${error}`)
       );
-      await buildAndStart(cwd, true);
-      ps.send({ event: "reload-events", path: path2 });
-      return true;
+      return false;
     }
-    if (isLocaleSource(path2)) {
+  }, "sendHmrEvent");
+  const performHMR = debounce(async (path3) => {
+    if (!path3 || !ps) return false;
+    let eventType = null;
+    let eventDescription = "";
+    if (isCommandSource(path3)) {
+      eventType = HMREventType.ReloadCommands;
+      eventDescription = "command(s)";
+    } else if (isEventSource(path3)) {
+      eventType = HMREventType.ReloadEvents;
+      eventDescription = "event(s)";
+    } else if (isLocaleSource(path3)) {
+      eventType = HMREventType.ReloadLocales;
+      eventDescription = "locale(s)";
+    } else {
+      eventType = HMREventType.Unknown;
+      eventDescription = "unknown source";
+    }
+    if (eventType) {
       console.log(
-        `${colors_default.cyanBright("Reloading locale(s) at ")} ${colors_default.yellowBright(path2)}`
+        `${colors_default.cyanBright(`Attempting to reload ${eventDescription} at`)} ${colors_default.yellowBright(path3)}`
       );
       await buildAndStart(cwd, true);
-      ps.send({ event: "reload-locales", path: path2 });
-      return true;
+      const hmrHandled = await sendHmrEvent(eventType, path3);
+      if (hmrHandled) {
+        console.log(
+          `${colors_default.greenBright(`Successfully hot reloaded ${eventDescription} at`)} ${colors_default.yellowBright(path3)}`
+        );
+        return true;
+      }
     }
     return false;
   }, 300);
-  const hmrHandler = /* @__PURE__ */ __name(async (path2) => {
-    const hmr = await performHMR(path2);
+  const isConfigUpdate = /* @__PURE__ */ __name((path3) => {
+    const isConfig = configPaths.some((configPath2) => path3 === configPath2);
+    console.log(
+      colors_default.yellowBright(
+        "It seems like commandkit config file was updated, please restart the server manually to apply changes."
+      )
+    );
+    return isConfig;
+  }, "isConfigUpdate");
+  const hmrHandler = /* @__PURE__ */ __name(async (path3) => {
+    if (isConfigUpdate(path3)) return;
+    const hmr = await performHMR(path3);
     if (hmr) return;
     console.log(
-      `${colors_default.yellowBright("\u26A1\uFE0F Performing full restart due to the changes in")} ${colors_default.cyanBright(path2)}`
+      `${colors_default.yellowBright("\u26A1\uFE0F Performing full restart due to the changes in")} ${colors_default.cyanBright(path3)}`
     );
     ps == null ? void 0 : ps.kill();
     ps = await buildAndStart(cwd);
@@ -6013,19 +6160,19 @@ async function bootstrapDevelopmentServer(configPath) {
         console.log(`Received restart command, restarting...`);
         ps == null ? void 0 : ps.kill();
         ps = null;
-        await buildAndStart(cwd);
+        ps = await buildAndStart(cwd);
         break;
       case "rc":
         console.log(`Received reload commands command, reloading...`);
-        ps == null ? void 0 : ps.send({ event: "reload-commands" });
+        await sendHmrEvent(HMREventType.ReloadCommands);
         break;
       case "re":
         console.log(`Received reload events command, reloading...`);
-        ps == null ? void 0 : ps.send({ event: "reload-events" });
+        await sendHmrEvent(HMREventType.ReloadEvents);
         break;
       case "rl":
         console.log(`Received reload locales command, reloading...`);
-        ps == null ? void 0 : ps.send({ event: "reload-locales" });
+        await sendHmrEvent(HMREventType.ReloadLocales);
         break;
     }
   });
@@ -6049,7 +6196,7 @@ ${colors_default.yellowBright("re")} - Reload all events
 ${colors_default.yellowBright("rl")} - Reload all locales`
   );
 }
-var import_path2, import_chokidar, isCommandSource, isEventSource, isLocaleSource;
+var import_path2, import_chokidar, import_promises7, import_node_crypto3, isCommandSource, isEventSource, isLocaleSource;
 var init_development = __esm({
   "src/cli/development.ts"() {
     "use strict";
@@ -6062,6 +6209,9 @@ var init_development = __esm({
     import_chokidar = require("chokidar");
     init_utilities();
     init_colors();
+    import_promises7 = require("timers/promises");
+    import_node_crypto3 = require("crypto");
+    init_constants();
     __name(buildAndStart, "buildAndStart");
     isCommandSource = /* @__PURE__ */ __name((p) => p.replaceAll("\\", "/").includes("src/app/commands"), "isCommandSource");
     isEventSource = /* @__PURE__ */ __name((p) => p.replaceAll("\\", "/").includes("src/app/events"), "isEventSource");
@@ -6147,15 +6297,8 @@ __export(generators_exports, {
 function determineExtension() {
   return (0, import_fs2.existsSync)((0, import_path4.join)(BASE_PATH, "tsconfig.json")) ? "ts" : "js";
 }
-async function generateCommand(name, customPath) {
-  const cmdPath = (0, import_path4.join)(customPath || COMMANDS_DIR);
-  if (!(0, import_fs2.existsSync)(cmdPath)) await (0, import_promises7.mkdir)(cmdPath, { recursive: true });
-  const fileName = `${name}.${determineExtension()}`;
-  if ((0, import_fs2.existsSync)((0, import_path4.join)(cmdPath, fileName))) {
-    panic(`Command ${name} already exists.`);
-  }
-  const commandFile = `
-import type { CommandData, SlashCommand, MessageCommand } from 'commandkit';
+function TS_COMMAND_SOURCE(name) {
+  return `import type { CommandData, SlashCommand, MessageCommand } from 'commandkit';
 
 export const command: CommandData = {
   name: '${name}',
@@ -6169,8 +6312,43 @@ export const chatInput: SlashCommand = async (ctx) => {
 export const message: MessageCommand = async (ctx) => {
   await ctx.message.reply('Hello from ${name}!');
 };
-`.trim();
-  await (0, import_promises7.writeFile)((0, import_path4.join)(cmdPath, fileName), commandFile);
+`;
+}
+function JS_COMMAND_SOURCE(name) {
+  return `/**
+ * @type {import('commandkit').CommandData}
+ */
+export const command = {
+  name: '${name}',
+  description: '${name} command',
+};
+
+/**
+ * @type {import('commandkit').SlashCommand}
+ */
+export const chatInput = async (ctx) => {
+  await ctx.interaction.reply('Hello from ${name}!');
+};
+
+/**
+ * @type {import('commandkit').MessageCommand}
+ */
+export const message = async (ctx) => {
+  await ctx.message.reply('Hello from ${name}!');
+};
+`;
+}
+async function generateCommand(name, customPath) {
+  const cmdPath = (0, import_path4.join)(customPath || COMMANDS_DIR);
+  if (!(0, import_fs2.existsSync)(cmdPath)) await (0, import_promises8.mkdir)(cmdPath, { recursive: true });
+  const ext = determineExtension();
+  const isTypeScript = ext === "ts";
+  const fileName = `${name}.${ext}`;
+  if ((0, import_fs2.existsSync)((0, import_path4.join)(cmdPath, fileName))) {
+    panic(`Command ${name} already exists.`);
+  }
+  const commandFile = isTypeScript ? TS_COMMAND_SOURCE(name) : JS_COMMAND_SOURCE(name);
+  await (0, import_promises8.writeFile)((0, import_path4.join)(cmdPath, fileName), commandFile);
   console.log(
     colors_default.green(
       `Command ${colors_default.magenta(name)} created at ${colors_default.blue(formatPath(`${cmdPath}/${fileName}`))}`
@@ -6179,10 +6357,11 @@ export const message: MessageCommand = async (ctx) => {
 }
 async function generateEvent(name, customPath) {
   const eventPath = (0, import_path4.join)(customPath || EVENTS_DIR, name);
-  if (!(0, import_fs2.existsSync)(eventPath)) await (0, import_promises7.mkdir)(eventPath, { recursive: true });
-  let filename = "event.ts";
+  if (!(0, import_fs2.existsSync)(eventPath)) await (0, import_promises8.mkdir)(eventPath, { recursive: true });
+  const ext = determineExtension();
+  let filename = `event.${ext}`;
   if ((0, import_fs2.existsSync)((0, import_path4.join)(eventPath, filename))) {
-    const count = (await (0, import_promises7.readdir)(eventPath)).length;
+    const count = (await (0, import_promises8.readdir)(eventPath)).length;
     filename = `${String(count).padStart(2, "0")}_${filename}`;
   }
   const eventFile = `
@@ -6190,7 +6369,7 @@ export default async function on${name[0].toUpperCase() + name.slice(1)}() {
   console.log('${name} event fired!');
 };
 `.trim();
-  await (0, import_promises7.writeFile)((0, import_path4.join)(eventPath, filename), eventFile);
+  await (0, import_promises8.writeFile)((0, import_path4.join)(eventPath, filename), eventFile);
   console.log(
     colors_default.green(
       `Event ${colors_default.magenta(name)} created at ${colors_default.blue(formatPath(eventPath))}/${colors_default.magenta(filename)}`
@@ -6208,7 +6387,7 @@ async function generateLocale(locale, commandName, customPath) {
     panic("Command name is required.");
   }
   const localePath = (0, import_path4.join)(customPath || LOCALES_DIR, locale);
-  if (!(0, import_fs2.existsSync)(localePath)) await (0, import_promises7.mkdir)(localePath, { recursive: true });
+  if (!(0, import_fs2.existsSync)(localePath)) await (0, import_promises8.mkdir)(localePath, { recursive: true });
   if ((0, import_fs2.existsSync)((0, import_path4.join)(localePath, `${commandName}.json`))) {
     panic(`Locale file for ${commandName} already exists.`);
   }
@@ -6219,7 +6398,7 @@ async function generateLocale(locale, commandName, customPath) {
     },
     translations: {}
   };
-  await (0, import_promises7.writeFile)(
+  await (0, import_promises8.writeFile)(
     (0, import_path4.join)(localePath, `${commandName}.json`),
     JSON.stringify(localeFile, null, 2)
   );
@@ -6231,12 +6410,12 @@ async function generateLocale(locale, commandName, customPath) {
     )
   );
 }
-var import_promises7, import_path4, import_discord21, import_fs2, BASE_PATH, COMMANDS_DIR, EVENTS_DIR, LOCALES_DIR, formatPath;
+var import_promises8, import_path4, import_discord21, import_fs2, BASE_PATH, COMMANDS_DIR, EVENTS_DIR, LOCALES_DIR, formatPath;
 var init_generators = __esm({
   "src/cli/generators.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises7 = require("fs/promises");
+    import_promises8 = require("fs/promises");
     import_path4 = require("path");
     import_discord21 = require("discord.js");
     init_common2();
@@ -6246,14 +6425,169 @@ var init_generators = __esm({
     COMMANDS_DIR = (0, import_path4.join)(BASE_PATH, "src/app/commands");
     EVENTS_DIR = (0, import_path4.join)(BASE_PATH, "src/app/events");
     LOCALES_DIR = (0, import_path4.join)(BASE_PATH, "src/app/locales");
-    formatPath = /* @__PURE__ */ __name((path2) => path2.replace(process.cwd(), ".").replace(/\\/g, "/"), "formatPath");
+    formatPath = /* @__PURE__ */ __name((path3) => path3.replace(process.cwd(), ".").replace(/\\/g, "/"), "formatPath");
     __name(determineExtension, "determineExtension");
+    __name(TS_COMMAND_SOURCE, "TS_COMMAND_SOURCE");
+    __name(JS_COMMAND_SOURCE, "JS_COMMAND_SOURCE");
     __name(generateCommand, "generateCommand");
     __name(generateEvent, "generateEvent");
     __name(generateLocale, "generateLocale");
   }
 });
 
+// src/cli/information.ts
+var information_exports = {};
+__export(information_exports, {
+  showInformation: () => showInformation
+});
+function findPackageVersion(packageName) {
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`);
+    const packageJson = require(packageJsonPath);
+    return packageJson.version;
+  } catch (e) {
+    try {
+      const basePaths = [
+        import_node_path11.default.join(process.cwd(), "node_modules", packageName),
+        import_node_path11.default.join(process.cwd(), "..", "..", "node_modules", packageName),
+        import_node_path11.default.join(process.cwd(), "..", "..", ".pnpm", packageName),
+        import_node_path11.default.join(
+          process.cwd(),
+          "..",
+          "..",
+          "node_modules",
+          ".pnpm",
+          packageName
+        )
+      ];
+      for (const basePath of basePaths) {
+        const packageJsonPath = import_node_path11.default.join(basePath, "package.json");
+        if (import_node_fs10.default.existsSync(packageJsonPath)) {
+          const packageJson = JSON.parse(
+            import_node_fs10.default.readFileSync(packageJsonPath, "utf8")
+          );
+          return packageJson.version;
+        }
+      }
+      const nodeModulesPath = import_node_path11.default.join(
+        process.cwd(),
+        "..",
+        "..",
+        "node_modules",
+        ".pnpm"
+      );
+      if (import_node_fs10.default.existsSync(nodeModulesPath)) {
+        const folders = import_node_fs10.default.readdirSync(nodeModulesPath);
+        const packageFolder = folders.find(
+          (folder) => folder.startsWith(`${packageName.replace("/", "+")}@`)
+        );
+        if (packageFolder) {
+          const packageJsonPath = import_node_path11.default.join(
+            nodeModulesPath,
+            packageFolder,
+            "node_modules",
+            packageName,
+            "package.json"
+          );
+          if (import_node_fs10.default.existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(
+              import_node_fs10.default.readFileSync(packageJsonPath, "utf8")
+            );
+            return packageJson.version;
+          }
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+}
+function getBinaryVersion(binary) {
+  try {
+    const version2 = (0, import_node_child_process2.execSync)(`${binary} --version`).toString().trim();
+    return version2;
+  } catch {
+    return null;
+  }
+}
+async function showInformation() {
+  const knownPlugins = [
+    "@commandkit/redis",
+    "@commandkit/legacy",
+    "@commandkit/devtools"
+  ];
+  const runtimeName = (() => {
+    if ("Deno" in globalThis && typeof Deno !== "undefined") return "Deno";
+    if ("Bun" in globalThis && typeof Bun !== "undefined") return "Bun";
+    return "Node.js";
+  })();
+  const info = {
+    "Operating System": {
+      Platform: process.platform,
+      Arch: process.arch,
+      Version: import_node_os.default.version(),
+      "Available Memory (MB)": Math.round(import_node_os.default.totalmem() / 1024 / 1024),
+      "Available CPU cores": import_node_os.default.cpus().length
+    },
+    Runtime: runtimeName,
+    Binaries: {
+      Node: process.version,
+      npm: getBinaryVersion("npm") || "N/A",
+      Yarn: getBinaryVersion("yarn") || "N/A",
+      pnpm: getBinaryVersion("pnpm") || "N/A",
+      Bun: getBinaryVersion("bun") || "N/A",
+      Deno: getBinaryVersion("deno") || "N/A"
+    },
+    "Relevant Packages": {
+      commandkit: version,
+      "discord.js": findPackageVersion("discord.js") || "N/A",
+      typescript: findPackageVersion("typescript") || "N/A",
+      esbuild: findPackageVersion("esbuild") || "N/A",
+      tsup: findPackageVersion("tsup") || "N/A",
+      ...knownPlugins.reduce(
+        (acc, plugin) => {
+          acc[plugin] = findPackageVersion(plugin) || "N/A";
+          return acc;
+        },
+        {}
+      )
+    }
+  };
+  let output = "";
+  for (const [section, data] of Object.entries(info)) {
+    output += `${section}:
+`;
+    if (typeof data === "string") {
+      output += `  ${data}
+
+`;
+      continue;
+    }
+    for (const [key, value] of Object.entries(data)) {
+      output += `  ${key}: ${value}
+`;
+    }
+    output += "\n";
+  }
+  console.log(output.trim());
+}
+var import_node_os, import_node_child_process2, import_node_fs10, import_node_path11;
+var init_information = __esm({
+  "src/cli/information.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_os = __toESM(require("os"));
+    import_node_child_process2 = require("child_process");
+    init_version();
+    import_node_fs10 = __toESM(require("fs"));
+    import_node_path11 = __toESM(require("path"));
+    __name(findPackageVersion, "findPackageVersion");
+    __name(getBinaryVersion, "getBinaryVersion");
+    __name(showInformation, "showInformation");
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -6261,6 +6595,9 @@ __export(index_exports, {
   AppCommandHandler: () => AppCommandHandler,
   Button: () => Button,
   ButtonKit: () => ButtonKit,
+  COMMANDKIT_CACHE_TAG: () => COMMANDKIT_CACHE_TAG,
+  COMMANDKIT_IS_DEV: () => COMMANDKIT_IS_DEV,
+  COMMANDKIT_IS_TEST: () => COMMANDKIT_IS_TEST,
   CacheProvider: () => CacheProvider,
   ChannelSelectMenu: () => ChannelSelectMenu,
   ChannelSelectMenuKit: () => ChannelSelectMenuKit,
@@ -6279,6 +6616,7 @@ __export(index_exports, {
   EventInterceptor: () => EventInterceptor,
   EventsRouter: () => EventsRouter,
   Fragment: () => Fragment,
+  HMREventType: () => HMREventType,
   Localization: () => Localization,
   Logger: () => Logger,
   MemoryCache: () => MemoryCache,
@@ -6319,6 +6657,7 @@ __export(index_exports, {
   getContext: () => getContext,
   getCurrentDirectory: () => getCurrentDirectory,
   getElement: () => getElement,
+  getSourceDirectories: () => getSourceDirectories,
   invalidate: () => invalidate,
   isCachedFunction: () => isCachedFunction,
   isCommandKitElement: () => isCommandKitElement,
@@ -6331,9 +6670,9 @@ __export(index_exports, {
   redirect: () => redirect,
   rethrow: () => rethrow,
   revalidate: () => revalidate,
-  super_duper_secret_internal_for_use_cache_directive_of_commandkit_cli_do_not_use_it_directly_or_you_will_be_fired_from_your_job_kthxbai: () => useCache,
   useEnvironment: () => useEnvironment,
-  version: () => version
+  version: () => version,
+  zzz_commandkit_secret_internal_use_cache_wrapper_do_not_use_or_you_will_be_fired: () => zzz_commandkit_secret_internal_use_cache_wrapper_do_not_use_or_you_will_be_fired
 });
 module.exports = __toCommonJS(index_exports);
 init_cjs_shims();
@@ -6386,12 +6725,13 @@ init_router();
 init_version();
 init_plugins();
 init_utilities();
+init_constants();
 
 // src/cli/init.ts
 init_cjs_shims();
-var import_node_fs10 = require("fs");
-var import_promises8 = require("fs/promises");
-var import_node_path11 = require("path");
+var import_node_fs11 = require("fs");
+var import_promises9 = require("fs/promises");
+var import_node_path12 = require("path");
 async function bootstrapCommandkitCLI(argv, options) {
   process.title = "CommandKit CLI";
   const { Command } = await import("commander");
@@ -6399,6 +6739,7 @@ async function bootstrapCommandkitCLI(argv, options) {
   const { bootstrapProductionServer: bootstrapProductionServer2, createProductionBuild: createProductionBuild2 } = await Promise.resolve().then(() => (init_production(), production_exports));
   const { generateCommand: generateCommand2, generateEvent: generateEvent2, generateLocale: generateLocale2 } = await Promise.resolve().then(() => (init_generators(), generators_exports));
   const { version: version2 } = await Promise.resolve().then(() => (init_version(), version_exports));
+  const { showInformation: showInformation2 } = await Promise.resolve().then(() => (init_information(), information_exports));
   const program = new Command("commandkit");
   program.command("dev").version(version2).description("Start your bot in development mode.").option(
     "-c, --config [path]",
@@ -6408,6 +6749,11 @@ async function bootstrapCommandkitCLI(argv, options) {
     const options2 = program.opts();
     bootstrapDevelopmentServer2(options2.config);
   });
+  program.command("info").description(
+    "Show information about the system which can be used to report bugs."
+  ).action(async () => {
+    await showInformation2();
+  });
   program.command("start").description(
     "Start your bot in production mode after running the build command."
   ).option("-c, --config [path]", "Path to your commandkit.json file.").action(() => {
@@ -6439,9 +6785,9 @@ async function bootstrapCommandkitCLI(argv, options) {
     }
   });
   await program.parseAsync(argv, options);
-  const types = (0, import_node_path11.join)(process.cwd(), "node_modules", "commandkit-types");
-  if (!(0, import_node_fs10.existsSync)(types)) {
-    await (0, import_promises8.mkdir)(types, { recursive: true }).catch(() => {
+  const types = (0, import_node_path12.join)(process.cwd(), "node_modules", "commandkit-types");
+  if (!(0, import_node_fs11.existsSync)(types)) {
+    await (0, import_promises9.mkdir)(types, { recursive: true }).catch(() => {
     });
   }
 }
@@ -6455,6 +6801,9 @@ var index_default = CommandKit;
   AppCommandHandler,
   Button,
   ButtonKit,
+  COMMANDKIT_CACHE_TAG,
+  COMMANDKIT_IS_DEV,
+  COMMANDKIT_IS_TEST,
   CacheProvider,
   ChannelSelectMenu,
   ChannelSelectMenuKit,
@@ -6473,6 +6822,7 @@ var index_default = CommandKit;
   EventInterceptor,
   EventsRouter,
   Fragment,
+  HMREventType,
   Localization,
   Logger,
   MemoryCache,
@@ -6512,6 +6862,7 @@ var index_default = CommandKit;
   getContext,
   getCurrentDirectory,
   getElement,
+  getSourceDirectories,
   invalidate,
   isCachedFunction,
   isCommandKitElement,
@@ -6524,8 +6875,8 @@ var index_default = CommandKit;
   redirect,
   rethrow,
   revalidate,
-  super_duper_secret_internal_for_use_cache_directive_of_commandkit_cli_do_not_use_it_directly_or_you_will_be_fired_from_your_job_kthxbai,
   useEnvironment,
-  version
+  version,
+  zzz_commandkit_secret_internal_use_cache_wrapper_do_not_use_or_you_will_be_fired
 });
 //# sourceMappingURL=index.js.map