bakit 2.0.0-alpha.6 → 2.0.0-alpha.8

package/bin/bakit.js

@@ -31,10 +31,6 @@ program.command("dev").action(async () => {
 		console.log("Bakit detected changes! Restarting...");
 	});
 
-	nodemon.on("exit", () => {
-		console.log("Proccess exited! Did you start bakit correctly?");
-	});
-
 	nodemon.on("quit", () => {
 		process.exit();
 	});

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import * as discord_js from 'discord.js';
-import { GatewayIntentBits, ClientOptions, ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, Events, IntentsBitField, ClientEvents, Client } from 'discord.js';
+import { GatewayIntentBits, ClientOptions, ChatInputCommandInteraction, CacheType, Message, User, MessageCreateOptions, InteractionReplyOptions, Awaitable, Collection, Events, IntentsBitField, Client, ClientEvents } from 'discord.js';
 import z$1, { z } from 'zod';
-import { inspect } from 'node:util';
 import * as jiti from 'jiti';
+import { inspect } from 'node:util';
 
 declare const ProjectConfigSchema: z.ZodObject<{
     intents: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodBigInt, z.ZodArray<z.ZodEnum<typeof GatewayIntentBits>>]>>;
@@ -31,6 +31,12 @@ declare function loadConfig(cwd?: string): Promise<ProjectConfig>;
  */
 declare function getConfig(): ProjectConfig;
 
+declare const EVENT_INTENT_MAPPING: Record<string, number[]>;
+
+declare function tokenize(content: string): string[];
+
+declare const $jiti: jiti.Jiti;
+
 declare class Context {
     canceled: boolean;
     cancel(): void;
@@ -298,11 +304,6 @@ declare function defineCommand<const ParamsList extends readonly AnyParam<any>[]
     params?: ParamsList;
 }) | string): Command<ParamsList>;
 
-declare class BaseClientManager {
-    client: BakitClient;
-    constructor(client: BakitClient);
-}
-
 declare class CommandManager extends BaseClientManager {
     commands: Collection<string, Command<any[]>>;
     loadModules(): Promise<Command[]>;
@@ -337,17 +338,39 @@ declare class ListenerManager extends BaseClientManager {
     getNeededIntents(): IntentsBitField;
 }
 
+declare class ProjectCacheManager {
+    private readonly rootDir;
+    constructor(root?: string);
+    private ensureRoot;
+    getHash(data: unknown): string;
+    write(path: string, data: unknown): Promise<void>;
+    read<T>(path: string): Promise<T | null>;
+    clear(): Promise<void>;
+    clearSync(): void;
+}
+
+declare class Instance {
+    client: BakitClient;
+    cache: ProjectCacheManager;
+    constructor();
+    start(): Promise<void>;
+    private loadModules;
+    private initIntents;
+}
+declare function useApp(): Instance;
+
 type GetPrefixFunction = (message: Message) => Awaitable<string[] | string>;
 interface BakitClientEvents extends ClientEvents {
     ready: [BakitClient<true>];
     clientReady: [BakitClient<true>];
 }
 declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready> {
+    instance: Instance;
     managers: {
         commands: CommandManager;
         listeners: ListenerManager;
     };
-    constructor(options: ClientOptions);
+    constructor(options: ClientOptions, instance: Instance);
     /**
      * Check if the client is connected to gateway successfully and finished initialization.
      */
@@ -365,28 +388,9 @@ declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready>
     [inspect.custom](): string;
 }
 
-declare class Instance {
+declare class BaseClientManager {
     client: BakitClient;
-    start(): Promise<void>;
-    private loadModules;
-    private initIntents;
-}
-declare function useApp(): Instance;
-
-declare const EVENT_INTENT_MAPPING: Record<string, number[]>;
-
-declare function tokenize(content: string): string[];
-
-declare const $jiti: jiti.Jiti;
-
-declare class BakitError extends Error {
-    constructor(message: string);
-}
-
-declare class ArgumentError extends BakitError {
-    target: string;
-    reason: string;
-    constructor(target: string, reason: string);
+    constructor(client: BakitClient);
 }
 
 declare const Params: {
@@ -406,4 +410,14 @@ declare const Params: {
     }) => NumberParam<Required>;
 };
 
+declare class BakitError extends Error {
+    constructor(message: string);
+}
+
+declare class ArgumentError extends BakitError {
+    target: string;
+    reason: string;
+    constructor(target: string, reason: string);
+}
+
 export { $jiti, type AnyParam, ArgumentError, BakitClient, type BakitClientEvents, BakitError, BaseClientManager, BaseCommandContext, BaseParam, type BaseParamOptions, BaseParamSchema, ChatInputContext, type ChatInputContextSendOptions, Command, type CommandContext, CommandManager, type CommandOptions, type CommandOptionsInput, CommandOptionsSchema, Context, type ContextSendOptions, EVENT_INTENT_MAPPING, type ErrorHookCallback, type GetPrefixFunction, HookOrder, HookState, type InferParamTuple, type InferParamValue, Instance, LifecycleManager, Listener, ListenerManager, type ListenerOptions, ListenerOptionsSchema, type MainHookCallback, MessageContext, type MessageContextSendOptions, type NumberOptions, NumberParam, NumberParamSchema, type ParamResolvedOutputType, ParamUserType, Params, type ProjectConfig, type ProjectConfigInput, ProjectConfigSchema, type StringOptions, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig, tokenize, useApp, validateParamsOrder };

package/dist/index.js

@@ -3,7 +3,10 @@ import z3, { z } from 'zod';
 import glob from 'tiny-glob';
 import { createJiti } from 'jiti';
 import { inspect } from 'util';
-import { posix } from 'path';
+import { posix, join, dirname } from 'path';
+import { existsSync, mkdirSync, rmSync } from 'fs';
+import { mkdir, writeFile, readFile, rm } from 'fs/promises';
+import { createHash } from 'crypto';
 
 // src/config.ts
 var INTENT_GROUPS = {
@@ -178,6 +181,13 @@ function getConfig() {
   return _config;
 }
 
+// src/base/BaseClientManager.ts
+var BaseClientManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+};
+
 // src/base/lifecycle/Context.ts
 var Context = class {
   canceled = false;
@@ -186,7 +196,7 @@ var Context = class {
   }
 };
 
-// src/command/CommandContext.ts
+// src/base/command/CommandContext.ts
 var BaseCommandContext = class extends Context {
   constructor(source) {
     super();
@@ -337,7 +347,7 @@ var ArgumentError = class extends BakitError {
   }
 };
 
-// src/command/param/Param.ts
+// src/base/command/param/Param.ts
 var BaseParam = class {
   options;
   constructor(options) {
@@ -510,19 +520,13 @@ function defineCommand(options) {
   return new Command(options);
 }
 
-// src/base/BaseClientManager.ts
-var BaseClientManager = class {
-  constructor(client) {
-    this.client = client;
-  }
-};
-
-// src/command/CommandManager.ts
+// src/base/command/CommandManager.ts
 var CommandManager = class extends BaseClientManager {
   commands = new Collection();
   async loadModules() {
     let entryDir = posix.resolve(getConfig().entryDir), pattern = posix.join(entryDir, "commands", "**/*.{ts,js}"), loads = (await glob(pattern, {
-      cwd: process.cwd()
+      cwd: process.cwd(),
+      absolute: true
     })).map(async (file) => {
       try {
         let command = await $jiti.import(file, { default: !0 });
@@ -579,7 +583,8 @@ var ListenerManager = class extends BaseClientManager {
   executors = /* @__PURE__ */ new WeakMap();
   async loadModules() {
     let entryDir = posix.resolve(getConfig().entryDir), pattern = posix.join(entryDir, "listeners", "**/*.{ts,js}"), loads = (await glob(pattern, {
-      cwd: process.cwd()
+      cwd: process.cwd(),
+      absolute: true
     })).map(async (file) => {
       try {
         let listener = await $jiti.import(file, { default: !0 });
@@ -631,15 +636,17 @@ var ListenerManager = class extends BaseClientManager {
   }
 };
 
-// src/BakitClient.ts
-var BakitClient3 = class extends Client {
-  managers;
-  constructor(options) {
-    super(options), this.managers = {
+// src/base/BakitClient.ts
+var BakitClient2 = class extends Client {
+  constructor(options, instance) {
+    super(options);
+    this.instance = instance;
+    this.managers = {
       commands: new CommandManager(this),
       listeners: new ListenerManager(this)
     };
   }
+  managers;
   /**
    * Check if the client is connected to gateway successfully and finished initialization.
    */
@@ -687,7 +694,7 @@ var ParamUserType = /* @__PURE__ */ ((ParamUserType2) => (ParamUserType2.Bot = "
   minValue: z.number().optional()
 }).transform(withDefaultDescription);
 
-// src/command/param/Params.ts
+// src/base/command/param/Params.ts
 function createFactory(ctor) {
   return (...args) => new ctor(...args);
 }
@@ -702,8 +709,22 @@ var messageCommandHandler = defineListener(Events.MessageCreate), chatInputComma
   once: true
 });
 registerCommandsHandler.main(async (_, client) => {
-  let { commands } = client.managers, data = commands.commands.map((cmd) => cmd.toSlashCommandJSON()), result = await client.application.commands.set(data);
-  console.log(`Registered ${result.size} application command(s)`);
+  let { managers, instance } = client, { commands } = managers, { cache } = instance, payload = commands.commands.map((cmd) => cmd.toSlashCommandJSON()).sort((a, b) => a.name.localeCompare(b.name)), currentHash = cache.getHash(payload), CACHE_KEY = "commands/meta.json", cachedMeta = await cache.read(CACHE_KEY);
+  if (cachedMeta && cachedMeta.hash === currentHash) {
+    let { timestamp, count } = cachedMeta, time = new Date(timestamp).toLocaleString();
+    console.log(`${count} command(s) are up to date (Last sync: ${time}). Skipping registration.`);
+    return;
+  }
+  try {
+    let result = await client.application.commands.set(payload);
+    cache.write(CACHE_KEY, {
+      hash: currentHash,
+      timestamp: Date.now(),
+      count: result.size
+    }), cache.write("commands/debug_dump.json", payload), console.log(`Registered ${result.size} application command(s).`);
+  } catch (error) {
+    console.error("Failed to register commands:", error);
+  }
 });
 messageCommandHandler.main(async (_, message) => {
   let config = getConfig();
@@ -741,20 +762,61 @@ chatInputCommandHandler.main(async (_, interaction) => {
   }
   await command.execute(context, ...resolvedArgs);
 });
+var ProjectCacheManager = class {
+  rootDir;
+  constructor(root = process.cwd()) {
+    this.rootDir = join(root, ".bakit"), this.ensureRoot();
+  }
+  ensureRoot() {
+    existsSync(this.rootDir) || mkdirSync(this.rootDir, { recursive: true });
+  }
+  getHash(data) {
+    return createHash("sha256").update(JSON.stringify(data)).digest("hex");
+  }
+  async write(path, data) {
+    let fullPath = join(this.rootDir, path), dir = dirname(fullPath);
+    await mkdir(dir, { recursive: true });
+    let content = typeof data == "string" ? data : JSON.stringify(data, null, 2);
+    await writeFile(fullPath, content, "utf-8");
+  }
+  async read(path) {
+    let fullPath = join(this.rootDir, path);
+    try {
+      let content = await readFile(fullPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async clear() {
+    await rm(this.rootDir, { recursive: true, force: true });
+  }
+  clearSync() {
+    existsSync(this.rootDir) && rmSync(this.rootDir, { recursive: true, force: true });
+  }
+};
 
-// src/Instance.ts
+// src/base/Instance.ts
 var Instance = class {
   client;
+  cache;
+  constructor() {
+    this.cache = new ProjectCacheManager();
+  }
   async start() {
     await loadConfig();
     let config = getConfig();
-    this.client = new BakitClient3({
-      intents: []
-    }), await this.loadModules(), this.initIntents(), await this.client.login(config.token);
+    this.client = new BakitClient2(
+      {
+        intents: [],
+        ...config.clientOptions
+      },
+      this
+    ), await this.loadModules(), this.initIntents(), await this.client.login(config.token);
   }
   loadModules() {
     let { managers } = this.client, { commands, listeners } = managers;
-    return listeners.add(chatInputCommandHandler), listeners.add(messageCommandHandler), Promise.all([commands.loadModules(), listeners.loadModules()]);
+    return listeners.add(chatInputCommandHandler), listeners.add(messageCommandHandler), listeners.add(registerCommandsHandler), Promise.all([commands.loadModules(), listeners.loadModules()]);
   }
   initIntents() {
     let config = getConfig(), { options, managers } = this.client, { listeners } = managers, intents;
@@ -765,4 +827,4 @@ function useApp() {
   return new Instance();
 }
 
-export { $jiti, ArgumentError, BakitClient3 as BakitClient, BakitError, BaseClientManager, BaseCommandContext, BaseParam, BaseParamSchema, ChatInputContext, Command, CommandManager, CommandOptionsSchema, Context, EVENT_INTENT_MAPPING, HookOrder, HookState, Instance, LifecycleManager, Listener, ListenerManager, ListenerOptionsSchema, MessageContext, NumberParam, NumberParamSchema, ParamUserType, Params, ProjectConfigSchema, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig, tokenize, useApp, validateParamsOrder };
+export { $jiti, ArgumentError, BakitClient2 as BakitClient, BakitError, BaseClientManager, BaseCommandContext, BaseParam, BaseParamSchema, ChatInputContext, Command, CommandManager, CommandOptionsSchema, Context, EVENT_INTENT_MAPPING, HookOrder, HookState, Instance, LifecycleManager, Listener, ListenerManager, ListenerOptionsSchema, MessageContext, NumberParam, NumberParamSchema, ParamUserType, Params, ProjectConfigSchema, StringParam, StringParamSchema, defineCommand, defineConfig, defineListener, getConfig, loadConfig, tokenize, useApp, validateParamsOrder };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bakit",
-	"version": "2.0.0-alpha.6",
+	"version": "2.0.0-alpha.8",
 	"description": "A framework for discord.js",
 	"type": "module",
 	"types": "./dist/index.d.ts",