bakit 2.0.0-alpha.1 → 2.0.0-alpha.10

package/bin/bakit.js

@@ -0,0 +1,39 @@
+// @ts-check
+import { config as useEnv } from "dotenv";
+import { program } from "commander";
+
+program.name("bakit");
+
+program.command("dev").action(async () => {
+	useEnv({
+		path: [".env.local", ".env"],
+		quiet: true,
+	});
+	const { default: nodemon } = await import("nodemon");
+
+	nodemon({
+		script: "src/index.ts",
+		exec: `${process.execPath} --import tsx`,
+		ext: "ts,js",
+		watch: ["src"],
+		env: {
+			...process.env,
+			FORCE_COLOR: "1",
+			NODE_ENV: "development",
+		},
+	});
+
+	nodemon.on("start", () => {
+		console.log("Starting bakit app...");
+	});
+
+	nodemon.on("restart", () => {
+		console.log("Bakit detected changes! Restarting...");
+	});
+
+	nodemon.on("quit", () => {
+		process.exit();
+	});
+});
+
+program.parse();

package/dist/index.d.ts

@@ -1,9 +1,15 @@
-import { GatewayIntentBits, ClientOptions, Message, Awaitable, ClientEvents, Client } from 'discord.js';
-import { z } from 'zod';
+import * as discord_js 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 * 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>>]>>;
     clientOptions: z.ZodOptional<z.ZodCustom<Omit<ClientOptions, "intents">, Omit<ClientOptions, "intents">>>;
+    entryDir: z.ZodDefault<z.ZodString>;
+    prefixes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    token: z.ZodString;
 }, z.core.$strip>;
 type ProjectConfigInput = z.input<typeof ProjectConfigSchema>;
 type ProjectConfig = z.output<typeof ProjectConfigSchema>;
@@ -25,13 +31,340 @@ 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[];
+/**
+ * Extracts a valid Discord Snowflake (User ID, Channel ID, etc.) from a string.
+ * @param input The raw string to parse
+ * @returns The extracted ID string, or null if invalid
+ */
+declare function extractSnowflakeId(input: string): string | null;
+
+declare const $jiti: jiti.Jiti;
+
+declare class Context {
+    canceled: boolean;
+    cancel(): void;
+}
+
+type ChatInputContextSendOptions = string | InteractionReplyOptions;
+type MessageContextSendOptions = string | MessageCreateOptions;
+type ContextSendOptions = ChatInputContextSendOptions | MessageContextSendOptions;
+declare abstract class BaseCommandContext<Cached extends boolean, InGuild extends boolean> extends Context {
+    source: ChatInputCommandInteraction<Cached extends true ? "cached" : CacheType> | Message<InGuild>;
+    constructor(source: ChatInputCommandInteraction<Cached extends true ? "cached" : CacheType> | Message<InGuild>);
+    get client(): BakitClient<true>;
+    get channel(): discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, discord_js.GuildTextBasedChannel | null, discord_js.GuildTextBasedChannel | null, discord_js.GuildTextBasedChannel | null, discord_js.TextBasedChannel | null> | discord_js.If<InGuild, discord_js.GuildTextBasedChannel, discord_js.TextBasedChannel>;
+    get channelId(): string;
+    get guild(): discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, discord_js.Guild, null, discord_js.Guild | null, discord_js.Guild | null> | discord_js.If<InGuild, discord_js.Guild, null>;
+    get guildId(): discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, string, string, string, string | null> | discord_js.If<InGuild, string, null>;
+    get member(): discord_js.GuildMember | discord_js.CacheTypeReducer<Cached extends true ? "cached" : CacheType, discord_js.GuildMember, discord_js.APIInteractionGuildMember, discord_js.GuildMember | discord_js.APIInteractionGuildMember, discord_js.GuildMember | discord_js.APIInteractionGuildMember | null> | null;
+    inGuild(): this is CommandContext<Cached, true>;
+    inCachedGuild(): this is CommandContext<true, true>;
+    get user(): User;
+    isChatInput(): this is ChatInputContext;
+    isMessage(): this is MessageContext;
+    abstract send(options: ContextSendOptions): Promise<Message<InGuild>>;
+}
+declare class ChatInputContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> extends BaseCommandContext<Cached, InGuild> {
+    source: ChatInputCommandInteraction<Cached extends true ? "cached" : CacheType>;
+    send(options: ContextSendOptions): Promise<Message<InGuild>>;
+}
+declare class MessageContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> extends BaseCommandContext<Cached, InGuild> {
+    source: Message<InGuild>;
+    send(options: string | MessageCreateOptions): Promise<Message<InGuild>>;
+}
+type CommandContext<Cached extends boolean = boolean, InGuild extends boolean = boolean> = ChatInputContext<Cached, InGuild> | MessageContext<Cached, InGuild>;
+
+declare enum HookState {
+    Pre = "PRE",
+    Main = "MAIN",
+    Post = "POST",
+    Error = "ERROR"
+}
+declare enum HookOrder {
+    First = 0,
+    Last = 1
+}
+type MainHookCallback<C extends Context, Args extends unknown[]> = (context: C, ...args: Args) => Awaitable<void>;
+type ErrorHookCallback<C extends Context, Args extends unknown[]> = (context: C, error: unknown, ...args: Args) => Awaitable<void>;
+declare class LifecycleManager<C extends Context, Args extends unknown[]> {
+    id: string;
+    private readonly hooks;
+    constructor(id: string);
+    getName(name: string): string;
+    setHook(name: string, state: HookState.Post, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
+    setHook(name: string, state: HookState.Main, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
+    setHook(name: string, state: HookState.Pre, callback: MainHookCallback<C, Args>, order?: HookOrder): this;
+    setHook(name: string, state: HookState.Error, callback: ErrorHookCallback<C, Args>, order?: HookOrder): this;
+    main(callback: MainHookCallback<C, Args>): this;
+    pre(callback: MainHookCallback<C, Args>): this;
+    post(callback: MainHookCallback<C, Args>): this;
+    error(callback: ErrorHookCallback<C, Args>): this;
+    execute(context: C, ...args: Args): Promise<void>;
+}
+
+declare enum ParamUserType {
+    Bot = "bot",
+    Normal = "normal",
+    Any = "any"
+}
+declare const BaseParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const StringParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const NumberParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    maxValue: z.ZodOptional<z.ZodNumber>;
+    minValue: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const UserParamSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type BaseParamOptions = z.input<typeof BaseParamSchema>;
+type StringOptions = z.input<typeof StringParamSchema>;
+type NumberOptions = z.input<typeof NumberParamSchema>;
+type UserOptions = z.input<typeof UserParamSchema>;
+
+type ParamResolvedOutputType<OutputType, Required extends boolean = true> = Required extends true ? OutputType : OutputType | null;
+declare abstract class BaseParam<Options extends BaseParamOptions, OutputType, Required extends boolean = true> {
+    private schema;
+    options: Options & {
+        required: Required;
+    };
+    /**
+     * **Internal Phantom Type**
+     *
+     * Used strictly for TypeScript type inference to determine the runtime value
+     * of this parameter. This property does not exist at runtime.
+     *
+     * @internal
+     */
+    readonly _type: Required extends true ? OutputType : OutputType | null;
+    constructor(options: Options, schema: z$1.ZodObject);
+    protected setOption(key: keyof Options, value: any): this;
+    name(value: string): this;
+    description(value: string): this;
+    required<V extends boolean>(value: V): BaseParam<Options, OutputType, V>;
+    resolve(context: CommandContext, value?: string): Promise<ParamResolvedOutputType<OutputType, Required>>;
+    abstract resolveMessage(context: MessageContext, value: string): Awaitable<ParamResolvedOutputType<OutputType, Required>>;
+    abstract resolveChatInput(context: ChatInputContext): Awaitable<ParamResolvedOutputType<OutputType, Required>>;
+    /**
+     * Helper to normalize string inputs into an options object.
+     */
+    protected static getOptions<Options>(options: Options | string): Options;
+}
+declare class StringParam<Required extends boolean = true> extends BaseParam<StringOptions, string, Required> {
+    constructor(options: string | StringOptions);
+    required<V extends boolean>(value: V): StringParam<V>;
+    resolveMessage(_context: CommandContext, value: string): ParamResolvedOutputType<string, Required>;
+    resolveChatInput(context: ChatInputContext): ParamResolvedOutputType<string, Required>;
+    /**
+     * Sets the minimum allowed length for this string.
+     * Pass `null` to remove this constraint.
+     */
+    min(length: number | null): this;
+    /**
+     * Sets the maximum allowed length for this string.
+     * Pass `null` to remove this constraint.
+     */
+    max(length: number | null): this;
+}
+declare class NumberParam<Required extends boolean = true> extends BaseParam<NumberOptions, number, Required> {
+    constructor(options: string | NumberOptions);
+    required<V extends boolean>(value: V): NumberParam<V>;
+    resolveMessage(_context: CommandContext, value: string): ParamResolvedOutputType<number, Required>;
+    resolveChatInput(context: ChatInputContext): ParamResolvedOutputType<number, Required>;
+    /**
+     * Sets the minimum allowed value for this number.
+     * Pass `null` to remove this constraint.
+     */
+    min(value: number | null): this;
+    /**
+     * Sets the maximum allowed value for this number.
+     * Pass `null` to remove this constraint.
+     */
+    max(value: number | null): this;
+}
+declare class UserParam<Required extends boolean = true> extends BaseParam<UserOptions, User, Required> {
+    constructor(options: string | UserOptions);
+    required<V extends boolean>(value: V): UserParam<V>;
+    resolveMessage(context: CommandContext, value: string): Promise<ParamResolvedOutputType<User, Required>>;
+    resolveChatInput(context: ChatInputContext): ParamResolvedOutputType<User, Required>;
+}
+type AnyParam<Required extends boolean = true> = BaseParam<any, any, Required>;
+/**
+ * Helper type to extract the runtime value of a Param instance.
+ *
+ * @example
+ * const p = new StringParam("name").required(false);
+ * type T = InferParamValue<typeof p>; // string | null
+ */
+type InferParamValue<P extends AnyParam<any>> = P["_type"];
+type InferParamTuple<T extends readonly BaseParam<any, any, any>[]> = {
+    [K in keyof T]: T[K] extends AnyParam<any> ? InferParamValue<T[K]> : never;
+};
+
+declare function validateParamsOrder(params: readonly AnyParam<boolean>[]): boolean;
+declare const CommandOptionsSchema: z.ZodPipe<z.ZodObject<{
+    name: z.ZodReadonly<z.ZodString>;
+    description: z.ZodReadonly<z.ZodOptional<z.ZodString>>;
+    nsfw: z.ZodReadonly<z.ZodDefault<z.ZodBoolean>>;
+    params: z.ZodReadonly<z.ZodDefault<z.ZodArray<z.ZodCustom<BaseParam<{
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+    }, unknown, boolean>, BaseParam<{
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+    }, unknown, boolean>>>>>;
+    quotes: z.ZodReadonly<z.ZodDefault<z.ZodBoolean>>;
+}, z.core.$strip>, z.ZodTransform<{
+    description: string;
+    name: string;
+    nsfw: boolean;
+    params: readonly BaseParam<{
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+    }, unknown, boolean>[];
+    quotes: boolean;
+}, {
+    name: string;
+    nsfw: boolean;
+    params: readonly BaseParam<{
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+    }, unknown, boolean>[];
+    quotes: boolean;
+    description?: string | undefined;
+}>>;
+type CommandOptionsInput = z.input<typeof CommandOptionsSchema>;
+type CommandOptions = z.output<typeof CommandOptionsSchema>;
+/**
+ * The command entry, used for registering command.
+ */
+declare class Command<ParamsList extends readonly AnyParam<any>[] = any[]> extends LifecycleManager<CommandContext, [
+    ...args: InferParamTuple<ParamsList>
+]> {
+    options: CommandOptions;
+    constructor(options: (Omit<CommandOptionsInput, "params"> & {
+        params?: ParamsList;
+    }) | string);
+    private handleSyntaxError;
+    toSlashCommandJSON(): discord_js.RESTPostAPIChatInputApplicationCommandsJSONBody;
+    private initSlashCommandOptions;
+    private initSlashCommandOption;
+}
+/**
+ * Define command entry, usually for modules.
+ * @param options The command options.
+ * @returns The entry of the command to deploy or register hooks.
+ * @example
+ * ```ts
+ * import { defineCommand } from "bakit";
+ *
+ * const command = defineCommand({
+ * 	name: "ping",
+ * 	description: "Displays bot's latency.",
+ * });
+ *
+ * command.main(async (context) => {
+ * 	await context.send(`Pong! ${context.client.ws.ping}ms!`);
+ * });
+ *
+ * export default command;
+ * ```
+ */
+declare function defineCommand<const ParamsList extends readonly AnyParam<any>[] = any[]>(options: (Omit<CommandOptionsInput, "params"> & {
+    params?: ParamsList;
+}) | string): Command<ParamsList>;
+
+declare class CommandManager extends BaseClientManager {
+    commands: Collection<string, Command<any[]>>;
+    loadModules(): Promise<Command[]>;
+    add(command: Command): void;
+    remove(target: string | Command): Command | undefined;
+    get(name: string): Command<any[]> | undefined;
+}
+
+declare const ListenerOptionsSchema: z$1.ZodObject<{
+    name: z$1.ZodEnum<typeof Events>;
+    once: z$1.ZodDefault<z$1.ZodBoolean>;
+}, z$1.z.core.$strip>;
+type ListenerOptions<K extends EventKey = EventKey> = Omit<z$1.input<typeof ListenerOptionsSchema>, "name"> & {
+    name: K;
+};
+type EventKey = keyof BakitClientEvents;
+declare class Listener<K extends EventKey = EventKey> extends LifecycleManager<Context, [
+    ...args: BakitClientEvents[K]
+]> {
+    options: ListenerOptions<K>;
+    constructor(options: K | ListenerOptions<K>);
+}
+declare function defineListener<const K extends EventKey = EventKey>(options: K | ListenerOptions<K>): Listener<K>;
+
+declare class ListenerManager extends BaseClientManager {
+    listeners: Listener[];
+    private executors;
+    loadModules(): Promise<Listener[]>;
+    add(listener: Listener): void;
+    remove(target: string | Listener): Listener[];
+    getBaseIntents(): IntentsBitField;
+    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> {
-    constructor(options: ClientOptions);
+    instance: Instance;
+    managers: {
+        commands: CommandManager;
+        listeners: ListenerManager;
+    };
+    constructor(options: ClientOptions, instance: Instance);
+    /**
+     * Check if the client is connected to gateway successfully and finished initialization.
+     */
     isReady(): this is BakitClient<true>;
     on<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
     once<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
@@ -39,6 +372,43 @@ declare class BakitClient<Ready extends boolean = boolean> extends Client<Ready>
     removeAllListeners(event?: keyof BakitClientEvents): this;
     removeListener<K extends keyof BakitClientEvents>(event: K, listener: (...args: BakitClientEvents[K]) => void): this;
     emit<K extends keyof BakitClientEvents>(event: K, ...args: BakitClientEvents[K]): boolean;
+    /**
+     * Override BakitClient output when using logger for security concern.
+     * @returns `BakitClient {}`
+     */
+    [inspect.custom](): string;
+}
+
+declare class BaseClientManager {
+    client: BakitClient;
+    constructor(client: BakitClient);
+}
+
+declare const Params: {
+    readonly string: <Required extends boolean = true>(options: string | {
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        maxLength?: number | undefined;
+        minLength?: number | undefined;
+    }) => StringParam<Required>;
+    readonly number: <Required extends boolean = true>(options: string | {
+        name: string;
+        description?: string | undefined;
+        required?: boolean | undefined;
+        maxValue?: number | undefined;
+        minValue?: number | undefined;
+    }) => 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 { BakitClient, type BakitClientEvents, type GetPrefixFunction, type ProjectConfig, type ProjectConfigInput, defineConfig, getConfig, loadConfig };
+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, type UserOptions, UserParam, UserParamSchema, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, loadConfig, tokenize, useApp, validateParamsOrder };

package/dist/index.js

@@ -1,12 +1,169 @@
-import { GatewayIntentBits, Client } from 'discord.js';
-import { z } from 'zod';
-import { pathToFileURL } from 'url';
+import { GatewayIntentBits, Events, Client, IntentsBitField, Collection, SlashCommandBuilder, SlashCommandStringOption, SlashCommandNumberOption, SlashCommandUserOption, ChatInputCommandInteraction, Message } from 'discord.js';
+import z4, { z } from 'zod';
 import glob from 'tiny-glob';
+import { createJiti } from 'jiti';
+import { inspect } from 'util';
+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 = {
+  [GatewayIntentBits.Guilds]: [
+    Events.GuildCreate,
+    Events.GuildDelete,
+    Events.GuildUpdate,
+    Events.GuildUnavailable,
+    Events.GuildRoleCreate,
+    Events.GuildRoleDelete,
+    Events.GuildRoleUpdate,
+    Events.ChannelCreate,
+    Events.ChannelDelete,
+    Events.ChannelUpdate,
+    Events.ChannelPinsUpdate,
+    Events.ThreadCreate,
+    Events.ThreadDelete,
+    Events.ThreadUpdate,
+    Events.ThreadListSync,
+    Events.ThreadMemberUpdate,
+    Events.ThreadMembersUpdate,
+    Events.StageInstanceCreate,
+    Events.StageInstanceUpdate,
+    Events.StageInstanceDelete
+  ],
+  [GatewayIntentBits.GuildMembers]: [
+    Events.GuildMemberAdd,
+    Events.GuildMemberUpdate,
+    Events.GuildMemberRemove,
+    Events.ThreadMembersUpdate
+  ],
+  [GatewayIntentBits.GuildModeration]: [Events.GuildAuditLogEntryCreate, Events.GuildBanAdd, Events.GuildBanRemove],
+  [GatewayIntentBits.GuildExpressions]: [
+    Events.GuildEmojiCreate,
+    Events.GuildEmojiDelete,
+    Events.GuildEmojiUpdate,
+    Events.GuildStickerCreate,
+    Events.GuildStickerDelete,
+    Events.GuildStickerUpdate,
+    Events.GuildSoundboardSoundCreate,
+    Events.GuildSoundboardSoundUpdate,
+    Events.GuildSoundboardSoundDelete,
+    Events.GuildSoundboardSoundsUpdate
+  ],
+  [GatewayIntentBits.GuildIntegrations]: [Events.GuildIntegrationsUpdate],
+  [GatewayIntentBits.GuildWebhooks]: [Events.WebhooksUpdate],
+  [GatewayIntentBits.GuildInvites]: [Events.InviteCreate, Events.InviteDelete],
+  [GatewayIntentBits.GuildVoiceStates]: [Events.VoiceStateUpdate],
+  [GatewayIntentBits.GuildPresences]: [Events.PresenceUpdate],
+  [GatewayIntentBits.GuildMessages]: [
+    Events.MessageCreate,
+    Events.MessageUpdate,
+    Events.MessageDelete,
+    Events.MessageBulkDelete
+  ],
+  [GatewayIntentBits.GuildMessageReactions]: [
+    Events.MessageReactionAdd,
+    Events.MessageReactionRemove,
+    Events.MessageReactionRemoveAll,
+    Events.MessageReactionRemoveEmoji
+  ],
+  [GatewayIntentBits.GuildMessageTyping]: [Events.TypingStart],
+  [GatewayIntentBits.DirectMessages]: [
+    Events.MessageCreate,
+    Events.MessageUpdate,
+    Events.MessageDelete,
+    Events.ChannelPinsUpdate
+  ],
+  [GatewayIntentBits.DirectMessageReactions]: [
+    Events.MessageReactionAdd,
+    Events.MessageReactionRemove,
+    Events.MessageReactionRemoveAll,
+    Events.MessageReactionRemoveEmoji
+  ],
+  [GatewayIntentBits.DirectMessageTyping]: [Events.TypingStart],
+  [GatewayIntentBits.MessageContent]: [Events.MessageCreate, Events.MessageUpdate],
+  [GatewayIntentBits.GuildScheduledEvents]: [
+    Events.GuildScheduledEventCreate,
+    Events.GuildScheduledEventDelete,
+    Events.GuildScheduledEventUpdate,
+    Events.GuildScheduledEventUserAdd,
+    Events.GuildScheduledEventUserRemove
+  ],
+  [GatewayIntentBits.AutoModerationConfiguration]: [
+    Events.AutoModerationRuleCreate,
+    Events.AutoModerationRuleDelete,
+    Events.AutoModerationRuleUpdate
+  ],
+  [GatewayIntentBits.AutoModerationExecution]: [Events.AutoModerationActionExecution],
+  [GatewayIntentBits.GuildMessagePolls]: [Events.MessagePollVoteAdd, Events.MessagePollVoteRemove],
+  [GatewayIntentBits.DirectMessagePolls]: [Events.MessagePollVoteAdd, Events.MessagePollVoteRemove]
+}, EVENT_INTENT_MAPPING = {};
+for (let [intentStr, events] of Object.entries(INTENT_GROUPS)) {
+  let intent = Number(intentStr);
+  for (let event of events)
+    EVENT_INTENT_MAPPING[event] ??= [], EVENT_INTENT_MAPPING[event].includes(intent) || EVENT_INTENT_MAPPING[event].push(intent);
+}
+
+// src/utils/string.ts
+function tokenize(content) {
+  let args = [], current = "", quoteChar = null, isEscaped = false;
+  for (let i = 0; i < content.length; i++) {
+    let char = content[i];
+    if (char === void 0)
+      break;
+    if (isEscaped) {
+      current += char, isEscaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      isEscaped = true;
+      continue;
+    }
+    quoteChar ? char === quoteChar ? quoteChar = null : current += char : char === '"' ? quoteChar = char : /\s/.test(char) ? current.length > 0 && (args.push(current), current = "") : current += char;
+  }
+  return current.length > 0 && args.push(current), args;
+}
+function extractSnowflakeId(input) {
+  if (!input) return null;
+  let mentionMatch = /^<@!?(\d{17,20})>$/.exec(input);
+  if (mentionMatch?.[1])
+    return mentionMatch[1];
+  let idMatch = /^(\d{17,20})$/.exec(input);
+  return idMatch?.[1] ? idMatch[1] : null;
+}
+
+// src/utils/index.ts
+var $jiti = createJiti(import.meta.url);
 
 // src/config.ts
 var ProjectConfigSchema = z.object({
+  /**
+   * The gateway intents to use for the Discord client.
+   *
+   * - `auto` — automatically determine the required intents.
+   * - bigint — a raw bitfield value representing the combined intents.
+   * - array — a list of individual intent flags from `GatewayIntentBits`.
+   *
+   * @defaultvalue `auto`
+   */
   intents: z.union([z.literal("auto"), z.bigint(), z.array(z.enum(GatewayIntentBits))]).default("auto"),
-  clientOptions: z.custom().optional()
+  /**
+   * Optional custom client options for Discord.js (excluding `intents`).
+   *
+   * These are passed directly to the `Client` constructor when initializing the bot.
+   *
+   * @see {@link https://discord.js.org/docs/packages/discord.js/main/ClientOptions:Interface}
+   */
+  clientOptions: z.custom().optional(),
+  /**
+   * The path to the main project source directory.
+   *
+   * @defaultvalue `src`
+   */
+  entryDir: z.string().default("src"),
+  prefixes: z.array(z.string()).default([]),
+  token: z.string()
 });
 function defineConfig(config) {
   return config;
@@ -23,7 +180,7 @@ async function loadConfig(cwd = process.cwd()) {
   if (!configPath)
     throw new Error("Missing config file");
   other && console.warn(`Multiple config files found in ${cwd}. Using ${configPath}.`);
-  let configFileURL = pathToFileURL(configPath).toString(), { default: config } = await import(configFileURL);
+  let config = await $jiti.import(configPath, { default: true });
   return _config = Object.freeze(await ProjectConfigSchema.parseAsync(config)), _config;
 }
 function getConfig() {
@@ -31,10 +188,516 @@ function getConfig() {
     throw new Error("Project config is not loaded.");
   return _config;
 }
-var BakitClient = class extends Client {
+
+// src/base/BaseClientManager.ts
+var BaseClientManager = class {
+  constructor(client) {
+    this.client = client;
+  }
+};
+
+// src/base/lifecycle/Context.ts
+var Context = class {
+  canceled = false;
+  cancel() {
+    this.canceled = true;
+  }
+};
+
+// src/base/command/CommandContext.ts
+var BaseCommandContext = class extends Context {
+  constructor(source) {
+    super();
+    this.source = source;
+  }
+  get client() {
+    return this.source.client;
+  }
+  get channel() {
+    return this.source.channel;
+  }
+  get channelId() {
+    return this.source.channelId;
+  }
+  get guild() {
+    return this.source.guild;
+  }
+  get guildId() {
+    return this.source.guildId;
+  }
+  get member() {
+    return this.source.member;
+  }
+  inGuild() {
+    return !!this.guildId;
+  }
+  inCachedGuild() {
+    if (this.isChatInput())
+      return this.source.inCachedGuild();
+    if (this.isMessage())
+      return this.source.inGuild();
+    throw new Error("Invalid source");
+  }
+  get user() {
+    if (this.isChatInput())
+      return this.source.user;
+    if (this.isMessage())
+      return this.source.author;
+    throw new Error("Invalid source");
+  }
+  isChatInput() {
+    return this.source instanceof ChatInputCommandInteraction;
+  }
+  isMessage() {
+    return this.source instanceof Message;
+  }
+}, ChatInputContext = class extends BaseCommandContext {
+  async send(options) {
+    typeof options == "string" && (options = { content: options });
+    let sendOptions = {
+      ...options,
+      withResponse: true
+    };
+    return this.source.deferred || this.source.replied ? await this.source.followUp(sendOptions) : (await this.source.reply(sendOptions)).resource?.message;
+  }
+}, MessageContext = class extends BaseCommandContext {
+  async send(options) {
+    let { channel } = this;
+    if (!channel?.isSendable())
+      throw new Error("Invalid channel or channel is not sendable");
+    return await channel.send(options);
+  }
+};
+var HookState = /* @__PURE__ */ ((HookState2) => (HookState2.Pre = "PRE", HookState2.Main = "MAIN", HookState2.Post = "POST", HookState2.Error = "ERROR", HookState2))(HookState || {}), HookOrder = /* @__PURE__ */ ((HookOrder2) => (HookOrder2[HookOrder2.First = 0] = "First", HookOrder2[HookOrder2.Last = 1] = "Last", HookOrder2))(HookOrder || {}), LifecycleManager = class {
+  constructor(id) {
+    this.id = id;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  hooks = {
+    MAIN: new Collection(),
+    PRE: new Collection(),
+    POST: new Collection(),
+    ERROR: new Collection()
+  };
+  getName(name) {
+    return `${this.id}:${name}`;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  setHook(name, state, callback, order = 1 /* Last */) {
+    let currentHooks = this.hooks[state], key = this.getName(name);
+    if (currentHooks.has(key) && console.warn(`Overriding duplicate hook '${key}' for state '${state}'`), order === 1 /* Last */)
+      currentHooks.set(key, callback);
+    else {
+      let existingEntries = [...currentHooks.entries()].filter(([k]) => k !== key);
+      currentHooks.clear(), currentHooks.set(key, callback);
+      for (let [k, v] of existingEntries)
+        currentHooks.set(k, v);
+    }
+    return this;
+  }
+  main(callback) {
+    return this.setHook("main", "MAIN" /* Main */, callback);
+  }
+  pre(callback) {
+    return this.setHook("pre", "PRE" /* Pre */, callback);
+  }
+  post(callback) {
+    return this.setHook("post", "POST" /* Post */, callback);
+  }
+  error(callback) {
+    return this.setHook("error", "ERROR" /* Error */, callback);
+  }
+  async execute(context, ...args) {
+    let pipeline = [
+      ...this.hooks.PRE.values(),
+      ...this.hooks.MAIN.values(),
+      ...this.hooks.POST.values()
+    ], error;
+    for (let hook of pipeline) {
+      if (context.canceled)
+        break;
+      try {
+        await hook(context, ...args);
+      } catch (e) {
+        error = e;
+        break;
+      }
+    }
+    if (!error)
+      return;
+    if (!this.hooks.ERROR.size)
+      throw error;
+    for (let [key, callback] of this.hooks.ERROR.entries()) {
+      if (context.canceled)
+        break;
+      try {
+        await callback(context, error, ...args);
+      } catch (innerError) {
+        console.error(`[Lifecycle] Error handler for '${key}' failed:`, innerError);
+      }
+    }
+  }
+};
+var ParamUserType = /* @__PURE__ */ ((ParamUserType2) => (ParamUserType2.Bot = "bot", ParamUserType2.Normal = "normal", ParamUserType2.Any = "any", ParamUserType2))(ParamUserType || {}), BaseParamSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  required: z.boolean().default(true)
+}), StringParamSchema = BaseParamSchema.extend({
+  maxLength: z.number().min(1).optional(),
+  minLength: z.number().min(1).optional()
+}), NumberParamSchema = BaseParamSchema.extend({
+  maxValue: z.number().optional(),
+  minValue: z.number().optional()
+}), UserParamSchema = BaseParamSchema.extend({});
+
+// src/errors/BakitError.ts
+var BakitError = class extends Error {
+  constructor(message) {
+    super(message), this.name = this.constructor.name, Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/errors/ArgumentError.ts
+var ArgumentError = class extends BakitError {
+  constructor(target, reason) {
+    super(`Invalid argument for '${target}': ${reason}`);
+    this.target = target;
+    this.reason = reason;
+  }
+};
+
+// src/base/command/param/Param.ts
+var BaseParam = class {
+  constructor(options, schema) {
+    this.schema = schema;
+    let parsed = schema.parse({
+      ...options,
+      description: options.description ?? options.name
+    });
+    this.options = parsed;
+  }
+  options;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  setOption(key, value) {
+    if (value === null)
+      return delete this.options[key], this;
+    let fieldValidator = this.schema.shape[key];
+    if (!fieldValidator)
+      return this.options[key] = value, this;
+    let parsedValue = fieldValidator.parse(value);
+    return this.options[key] = parsedValue, this;
+  }
+  name(value) {
+    return this.setOption("name", value);
+  }
+  description(value) {
+    return this.setOption("description", value);
+  }
+  required(value) {
+    return this.setOption("required", value);
+  }
+  async resolve(context, value) {
+    let { required, name } = this.options;
+    if (value === void 0) {
+      if (required)
+        throw new ArgumentError(name, "is required");
+      return null;
+    }
+    if (context.isChatInput())
+      return await this.resolveChatInput(context);
+    if (context.isMessage())
+      return await this.resolveMessage(context, value);
+    throw new Error("Invalid context type provided");
+  }
+  /**
+   * Helper to normalize string inputs into an options object.
+   */
+  static getOptions(options) {
+    return typeof options == "string" ? { name: options } : options;
+  }
+}, StringParam = class extends BaseParam {
+  constructor(options) {
+    super(BaseParam.getOptions(options), StringParamSchema);
+  }
+  required(value) {
+    return super.required(value);
+  }
+  resolveMessage(_context, value) {
+    let { minLength, maxLength, name } = this.options;
+    if (minLength && value.length < minLength)
+      throw new ArgumentError(name, `must be at least ${minLength} chars long`);
+    if (maxLength && value.length > maxLength)
+      throw new ArgumentError(name, `must be at most ${maxLength} chars long`);
+    return value;
+  }
+  resolveChatInput(context) {
+    let { name, required } = this.options;
+    return context.source.options.getString(name, required);
+  }
+  /**
+   * Sets the minimum allowed length for this string.
+   * Pass `null` to remove this constraint.
+   */
+  min(length) {
+    return this.setOption("minLength", length);
+  }
+  /**
+   * Sets the maximum allowed length for this string.
+   * Pass `null` to remove this constraint.
+   */
+  max(length) {
+    return this.setOption("maxLength", length);
+  }
+}, NumberParam = class extends BaseParam {
+  constructor(options) {
+    super(BaseParam.getOptions(options), NumberParamSchema);
+  }
+  required(value) {
+    return super.required(value);
+  }
+  resolveMessage(_context, value) {
+    let { minValue, maxValue, name } = this.options, num = Number(value);
+    if (isNaN(num))
+      throw new ArgumentError(name, "must be a number");
+    if (minValue !== void 0 && num < minValue)
+      throw new ArgumentError(name, `must be greater than ${minValue}`);
+    if (maxValue !== void 0 && num > maxValue)
+      throw new ArgumentError(name, `must be less than ${minValue}`);
+    return num;
+  }
+  resolveChatInput(context) {
+    let { name, required } = this.options;
+    return context.source.options.getString(name, required);
+  }
+  /**
+   * Sets the minimum allowed value for this number.
+   * Pass `null` to remove this constraint.
+   */
+  min(value) {
+    return this.setOption("minValue", value);
+  }
+  /**
+   * Sets the maximum allowed value for this number.
+   * Pass `null` to remove this constraint.
+   */
+  max(value) {
+    return this.setOption("maxValue", value);
+  }
+}, UserParam = class extends BaseParam {
+  constructor(options) {
+    super(BaseParam.getOptions(options), UserParamSchema);
+  }
+  required(value) {
+    return super.required(value);
+  }
+  async resolveMessage(context, value) {
+    let id = extractSnowflakeId(value);
+    if (!id)
+      return null;
+    let { users } = context.client;
+    return await users.fetch(id).catch(() => null);
+  }
+  resolveChatInput(context) {
+    let { name, required } = this.options;
+    return context.source.options.getUser(name, required);
+  }
+};
+function validateParamsOrder(params) {
+  let seenOptional = false;
+  for (let param of params)
+    if (param.options.required) {
+      if (seenOptional)
+        return false;
+    } else
+      seenOptional = true;
+  return true;
+}
+var CommandOptionsSchema = z.object({
+  name: z.string().readonly(),
+  description: z.string().min(1).max(100).optional().readonly(),
+  nsfw: z.boolean().default(false).readonly(),
+  params: z.array(z.instanceof(BaseParam)).default([]).readonly(),
+  quotes: z.boolean().default(true).readonly()
+}).transform((data) => ({
+  ...data,
+  description: data.description ?? `Command ${data.name}`
+})).refine(({ params }) => validateParamsOrder(params), {
+  path: ["params"],
+  error: "Required params must be placed before optional params"
+}), Command = class extends LifecycleManager {
+  constructor(options) {
+    let _options = CommandOptionsSchema.parse(typeof options == "string" ? { name: options } : options);
+    super(`command:${_options.name}`), this.options = _options, this.setHook("syntaxError", "ERROR" /* Error */, async (ctx, error, ...args) => {
+      await this.handleSyntaxError(ctx, error, args);
+    });
+  }
+  async handleSyntaxError(context, error, _args) {
+    error instanceof BakitError && await context.send(error.message);
+  }
+  toSlashCommandJSON() {
+    let { name, description, nsfw, params } = this.options, builder = new SlashCommandBuilder().setName(name).setDescription(description).setNSFW(nsfw);
+    return this.initSlashCommandOptions(builder, params), builder.toJSON();
+  }
+  initSlashCommandOptions(builder, params) {
+    for (let param of params)
+      this.initSlashCommandOption(builder, param);
+  }
+  initSlashCommandOption(builder, param) {
+    let initOption = (builder2) => {
+      let { name, description, required } = param.options;
+      return builder2.setName(name).setDescription(description).setRequired(required);
+    };
+    if (param instanceof StringParam) {
+      let { maxLength, minLength } = param.options, option = initOption(new SlashCommandStringOption());
+      maxLength && option.setMaxLength(maxLength), minLength && option.setMinLength(minLength), builder.addStringOption(option);
+      return;
+    }
+    if (param instanceof NumberParam) {
+      let { maxValue, minValue } = param.options, option = initOption(new SlashCommandNumberOption());
+      maxValue && option.setMaxValue(maxValue), minValue && option.setMinValue(minValue), builder.addNumberOption(option);
+      return;
+    }
+    if (param instanceof UserParam) {
+      let option = initOption(new SlashCommandUserOption());
+      builder.addUserOption(option);
+      return;
+    }
+  }
+};
+function defineCommand(options) {
+  return new Command(options);
+}
+
+// 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(),
+      absolute: true
+    })).map(async (file) => {
+      try {
+        let command = await $jiti.import(file, { default: !0 });
+        if (!command) {
+          console.warn(`[Loader] File has no default export: ${file}`);
+          return;
+        }
+        if (!(command instanceof Command)) {
+          console.warn(`[Loader] Default export is not a Command: ${file}`);
+          return;
+        }
+        return this.add(command), command;
+      } catch (error) {
+        console.error(`An error occurred while trying to add command for '${file}':`, error);
+      }
+    }), loaded = (await Promise.all(loads)).filter((x) => x !== void 0);
+    return console.log(`Loaded ${loaded.length} command(s).`), loaded;
+  }
+  add(command) {
+    if (!(command instanceof Command))
+      throw new Error("Invalid command provided");
+    let { name } = command.options;
+    if (this.commands.has(name)) {
+      console.warn(`[Loader] Duplicate command registered: '${name}'`);
+      return;
+    }
+    this.commands.set(name, command);
+  }
+  remove(target) {
+    let name = typeof target == "string" ? target : target.options.name, existing = this.commands.get(name);
+    if (existing)
+      return this.commands.delete(name), existing;
+  }
+  get(name) {
+    return this.commands.get(name);
+  }
+};
+var ListenerOptionsSchema = z4.object({
+  name: z4.enum(Events),
+  once: z4.boolean().default(false)
+}), Listener = class extends LifecycleManager {
+  options;
   constructor(options) {
+    let _options = ListenerOptionsSchema.parse(typeof options == "string" ? { name: options } : options);
+    super(`listener:${_options.name}`), this.options = _options;
+  }
+};
+function defineListener(options) {
+  return new Listener(options);
+}
+var ListenerManager = class extends BaseClientManager {
+  listeners = [];
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  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(),
+      absolute: true
+    })).map(async (file) => {
+      try {
+        let listener = await $jiti.import(file, { default: !0 });
+        if (!listener) {
+          console.warn(`[Loader] File has no default export: ${file}`);
+          return;
+        }
+        if (!(listener instanceof Listener)) {
+          console.warn(`[Loader] Default export is not a Listener: ${file}`);
+          return;
+        }
+        return this.add(listener), listener;
+      } catch (error) {
+        console.error(`An error occurred while trying to add listener for '${file}':`, error);
+      }
+    }), loaded = (await Promise.all(loads)).filter((x) => x !== void 0);
+    return console.log(`Loaded ${loaded.length} listener(s).`), loaded;
+  }
+  add(listener) {
+    if (!(listener instanceof Listener))
+      throw new Error("Invalid listener provided");
+    let execute = (...args) => {
+      listener.execute(new Context(), ...args);
+    };
+    this.listeners.push(listener), this.executors.set(listener, execute);
+    let { once, name } = listener.options;
+    this.client[once ? "once" : "on"](name, execute);
+  }
+  remove(target) {
+    let isMatched = (listener) => typeof target == "string" ? listener.options.name === target : listener === target, removed = [];
+    return this.listeners = this.listeners.filter((listener) => {
+      if (!isMatched(listener))
+        return true;
+      removed.push(listener);
+      let execute = this.executors.get(listener);
+      return execute && (this.client.removeListener(listener.options.name, execute), this.executors.delete(listener)), false;
+    }), removed;
+  }
+  getBaseIntents() {
+    return new IntentsBitField([GatewayIntentBits.Guilds]);
+  }
+  getNeededIntents() {
+    let result = this.getBaseIntents();
+    for (let listener of this.listeners) {
+      let eventName = listener.options.name, requiredIntents = EVENT_INTENT_MAPPING[eventName];
+      requiredIntents && result.add(requiredIntents);
+    }
+    return result;
+  }
+};
+
+// 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.
+   */
   isReady() {
     return super.isReady();
   }
@@ -56,6 +719,146 @@ var BakitClient = class extends Client {
   emit(event, ...args) {
     return super.emit(event, ...args);
   }
+  /**
+   * Override BakitClient output when using logger for security concern.
+   * @returns `BakitClient {}`
+   */
+  [inspect.custom]() {
+    return `${this.constructor.name} {}`;
+  }
 };
 
-export { BakitClient, defineConfig, getConfig, loadConfig };
+// src/base/command/param/Params.ts
+function createFactory(ctor) {
+  return (...args) => new ctor(...args);
+}
+var Params = {
+  string: createFactory(StringParam),
+  number: createFactory(NumberParam)
+};
+
+// src/defaults/command.ts
+var messageCommandHandler = defineListener(Events.MessageCreate), chatInputCommandHandler = defineListener(Events.InteractionCreate), registerCommandsHandler = defineListener({
+  name: Events.ClientReady,
+  once: true
+});
+registerCommandsHandler.main(async (_, client) => {
+  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();
+  if (message.author.bot)
+    return;
+  let { content } = message, client = message.client, lowerContent = content.toLowerCase(), prefix = config.prefixes.find((p) => lowerContent.startsWith(p));
+  if (!prefix)
+    return;
+  let [name, ...args] = content.slice(prefix.length).trim().split(/\s+/g);
+  if (!name)
+    return;
+  let command = client.managers.commands.get(name);
+  if (!command)
+    return;
+  let context = new MessageContext(message), { params, quotes } = command.options, rawArgs = quotes ? tokenize(args.join(" ")) : args, resolvedArgs = [];
+  for (let i = 0; i < params.length; i++) {
+    let param = params[i], arg = rawArgs[i];
+    if (!param)
+      break;
+    let resolved = await param.resolve(context, arg);
+    resolvedArgs.push(resolved);
+  }
+  await command.execute(context, ...resolvedArgs);
+});
+chatInputCommandHandler.main(async (_, interaction) => {
+  if (!interaction.isChatInputCommand())
+    return;
+  let { commandName } = interaction, command = interaction.client.managers.commands.get(commandName);
+  if (!command)
+    return;
+  let context = new ChatInputContext(interaction), { params } = command.options, resolvedArgs = [];
+  for (let param of params) {
+    let resolved = await param.resolve(context);
+    resolvedArgs.push(resolved);
+  }
+  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);
+    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/base/Instance.ts
+var Instance = class {
+  client;
+  cache;
+  constructor() {
+    this.cache = new ProjectCacheManager();
+  }
+  async start() {
+    await loadConfig();
+    let config = getConfig();
+    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), listeners.add(registerCommandsHandler), Promise.all([commands.loadModules(), listeners.loadModules()]);
+  }
+  initIntents() {
+    let config = getConfig(), { options, managers } = this.client, { listeners } = managers, intents;
+    config.intents === "auto" ? intents = listeners.getNeededIntents() : (intents = listeners.getBaseIntents(), typeof config.intents == "bigint" ? intents.bitfield = Number(config.intents) : intents.add(...config.intents)), options.intents = intents;
+  }
+};
+function useApp() {
+  return new Instance();
+}
+
+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, UserParam, UserParamSchema, defineCommand, defineConfig, defineListener, extractSnowflakeId, getConfig, loadConfig, tokenize, useApp, validateParamsOrder };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bakit",
-	"version": "2.0.0-alpha.1",
+	"version": "2.0.0-alpha.10",
 	"description": "A framework for discord.js",
 	"type": "module",
 	"types": "./dist/index.d.ts",
@@ -10,6 +10,9 @@
 		"type-check": "tsc --noEmit",
 		"test": "vitest run --pass-with-no-tests"
 	},
+	"bin": {
+		"bakit": "./bin/bakit.js"
+	},
 	"files": [
 		"dist"
 	],
@@ -34,11 +37,12 @@
 		"discord.js": "^14.0.0"
 	},
 	"dependencies": {
+		"commander": "^14.0.2",
+		"dotenv": "^17.2.1",
+		"jiti": "^2.6.1",
+		"nodemon": "^3.1.11",
 		"tiny-glob": "^0.2.9",
 		"type-fest": "^4.41.0",
 		"zod": "^4.1.12"
-	},
-	"devDependencies": {
-		"@swc/core": "^1.13.5"
 	}
 }