@seedcord/cli 0.1.0 → 0.2.0-next.0

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { n as SEEDCORD_CONFIG_FILENAMES, t as version } from "./src-BHkD3jCv.mjs";
+import { n as SEEDCORD_CONFIG_FILENAMES, t as version } from "./src-CZDimuFi.mjs";
 import { createRequire } from "node:module";
 import { Command } from "@commander-js/extra-typings";
 import { Logger, LoggerChannelRegistry, SeedcordErrorCode, StrictEventEmitter, isSeedcordError } from "@seedcord/services";
@@ -8,13 +8,15 @@ import { dirname, extname, isAbsolute, join, relative, resolve } from "node:path
 import { pathToFileURL } from "node:url";
 import { createJiti } from "jiti";
 import { tsImport } from "tsx/esm/api";
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
-import { assertNever, formatFilePath } from "@seedcord/utils";
+import { SeedcordBrand } from "@seedcord/types/internal";
+import { assertNever, formatFilePath, isTsOrJsFile } from "@seedcord/utils";
+import { ApplicationCommandOptionType, ApplicationCommandType } from "discord-api-types/v10";
+import { routeLeavesOf } from "@seedcord/utils/internal";
 import { Box, Text, measureElement, render, useAnimation, useInput, useWindowSize } from "ink";
 import React, { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 import Spinner from "ink-spinner";
-import { SeedcordBrand } from "@seedcord/types/internal";
 import { createServer, createServerModuleRunner, defineConfig, mergeConfig } from "vite";
 import { EvaluatedModules } from "vite/module-runner";
 import chalk from "chalk";
@@ -465,6 +467,297 @@ var BuildCommand = class extends BaseCommand {
 	}
 };
 
+//#endregion
+//#region src/commands/codegen/RegistryGenerator.ts
+const KIND_BY_TYPE = {
+	[ApplicationCommandOptionType.String]: "string",
+	[ApplicationCommandOptionType.Integer]: "integer",
+	[ApplicationCommandOptionType.Number]: "number",
+	[ApplicationCommandOptionType.Boolean]: "boolean",
+	[ApplicationCommandOptionType.User]: "user",
+	[ApplicationCommandOptionType.Channel]: "channel",
+	[ApplicationCommandOptionType.Role]: "role",
+	[ApplicationCommandOptionType.Mentionable]: "mentionable",
+	[ApplicationCommandOptionType.Attachment]: "attachment"
+};
+/**
+* Builds the generated registry from each command's `toJSON()`. Chat-input commands become the slash-option
+* tables, context-menu commands contribute their name to the user or message set. Reads the builder back
+* because djs erases option names at the type level.
+*/
+var RegistryGenerator = class {
+	logger;
+	constructor(logger) {
+		this.logger = logger;
+	}
+	generate(commands) {
+		const slash = {};
+		const sourceByRoute = /* @__PURE__ */ new Map();
+		const sourceByUserName = /* @__PURE__ */ new Map();
+		const sourceByMessageName = /* @__PURE__ */ new Map();
+		for (const command of commands) {
+			const { json } = command;
+			if (json.type === ApplicationCommandType.User) this.collectContextMenu("user", json, command.sourceFile, sourceByUserName);
+			else if (json.type === ApplicationCommandType.Message) this.collectContextMenu("message", json, command.sourceFile, sourceByMessageName);
+			else if (json.type === void 0 || json.type === ApplicationCommandType.ChatInput) this.collectSlash(json, command.sourceFile, slash, sourceByRoute);
+		}
+		const userContextMenus = [...sourceByUserName.keys()];
+		const messageContextMenus = [...sourceByMessageName.keys()];
+		this.logger.debug(`Generated ${Object.keys(slash).length} slash route(s), ${userContextMenus.length} user and ${messageContextMenus.length} message context-menu command(s)`);
+		return {
+			slash,
+			userContextMenus,
+			messageContextMenus
+		};
+	}
+	collectSlash(json, sourceFile, slash, sourceByRoute) {
+		this.warnEmptyGroups(json);
+		for (const leaf of routeLeavesOf(json)) {
+			const firstFile = sourceByRoute.get(leaf.route);
+			if (firstFile !== void 0) throw new SeedcordError(SeedcordErrorCode.CliCodegenDuplicateRoute, [
+				leaf.route,
+				firstFile,
+				sourceFile
+			]);
+			sourceByRoute.set(leaf.route, sourceFile);
+			slash[leaf.route] = this.mapOptions(leaf.options);
+		}
+	}
+	collectContextMenu(kind, json, sourceFile, sourceByName) {
+		const firstFile = sourceByName.get(json.name);
+		if (firstFile !== void 0) throw new SeedcordError(SeedcordErrorCode.CliCodegenDuplicateContextMenu, [
+			kind,
+			json.name,
+			firstFile,
+			sourceFile
+		]);
+		sourceByName.set(json.name, sourceFile);
+	}
+	warnEmptyGroups(json) {
+		for (const option of json.options ?? []) if (option.type === ApplicationCommandOptionType.SubcommandGroup && (option.options ?? []).length === 0) this.logger.warn(`Slash group \`${json.name}/${option.name}\` has no subcommands and will not deploy.`);
+	}
+	mapOptions(options) {
+		const table = {};
+		for (const option of options) {
+			if (option.type === ApplicationCommandOptionType.Subcommand || option.type === ApplicationCommandOptionType.SubcommandGroup) continue;
+			const choices = "choices" in option && option.choices && option.choices.length > 0 ? option.choices.map((choice) => choice.value) : void 0;
+			const autocomplete = "autocomplete" in option && option.autocomplete === true ? true : void 0;
+			table[option.name] = {
+				kind: KIND_BY_TYPE[option.type],
+				required: option.required ?? false,
+				...choices ? { choices } : {},
+				...autocomplete ? { autocomplete } : {}
+			};
+		}
+		return table;
+	}
+};
+
+//#endregion
+//#region src/commands/codegen/renderRegistry.ts
+const BANNER = `// Generated by \`seedcord codegen\`. Do not edit by hand.
+// Run \`seedcord codegen\` after changing a command's options.`;
+const DISCLAIMER = `    /**
+     * These option types come from your command source. Redeploy your commands to Discord after regenerating,
+     * or an interaction from a stale command can return null for an option this file types as non-null.
+     */`;
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const CONTROL_CHAR = 32;
+const HEX_RADIX = 16;
+/**
+* Renders the generated registry into the committed `declare module 'seedcord'` file, the slash option
+* tables plus the user and message context-menu name registries, all in one augmentation block. Keys are
+* sorted so the output is stable across filesystems. The result is byte-stable so `seedcord codegen --check`
+* can diff it directly.
+*/
+function renderRegistry(registry) {
+	return `${BANNER}\n\ndeclare module 'seedcord' {\n${DISCLAIMER}\n    interface SlashOptionRegistry {\n${renderSlashRows(registry.slash)}\n    }\n    interface UserContextMenuRegistry {\n${renderContextMenuRows(registry.userContextMenus)}\n    }\n    interface MessageContextMenuRegistry {\n${renderContextMenuRows(registry.messageContextMenus)}\n    }\n}\n\nexport {};\n`;
+}
+function renderSlashRows(tables) {
+	return Object.entries(tables).sort(([first], [second]) => compare(first, second)).map(([route, options]) => `        ${renderKey(route)}: ${renderRow(options)};`).join("\n");
+}
+function renderContextMenuRows(names) {
+	return [...names].sort(compare).map((name) => `        ${renderName(name)}: true;`).join("\n");
+}
+function renderRow(options) {
+	const entries = Object.entries(options);
+	if (entries.length === 0) return "{}";
+	return `{ ${entries.map(([name, opt]) => `${renderKey(name)}: ${renderOption(opt)}`).join("; ")} }`;
+}
+function renderOption(opt) {
+	const parts = [`kind: '${opt.kind}'`, `required: ${opt.required}`];
+	if (opt.choices && opt.choices.length > 0) parts.push(`choices: [${opt.choices.map(renderChoice).join(", ")}]`);
+	if (opt.autocomplete) parts.push("autocomplete: true");
+	return `{ ${parts.join("; ")} }`;
+}
+function renderChoice(value) {
+	if (typeof value !== "string") return String(value);
+	return `'${escapeLiteral(value)}'`;
+}
+function renderName(name) {
+	return IDENTIFIER.test(name) ? name : `'${escapeLiteral(name)}'`;
+}
+function renderKey(name) {
+	return IDENTIFIER.test(name) ? name : `'${name}'`;
+}
+function escapeLiteral(value) {
+	let escaped = "";
+	for (const char of value) {
+		const code = char.charCodeAt(0);
+		if (char === "\\") escaped += "\\\\";
+		else if (char === "'") escaped += "\\'";
+		else if (char === "\n") escaped += "\\n";
+		else if (char === "\r") escaped += "\\r";
+		else if (char === "	") escaped += "\\t";
+		else if (code < CONTROL_CHAR) escaped += `\\x${code.toString(HEX_RADIX).padStart(2, "0")}`;
+		else escaped += char;
+	}
+	return escaped;
+}
+function compare(first, second) {
+	if (first < second) return -1;
+	return first > second ? 1 : 0;
+}
+
+//#endregion
+//#region src/commands/codegen/CodegenRunner.ts
+const OUTPUT_FILENAME = "command-registry.gen.ts";
+/**
+* Orchestrates `seedcord codegen`. Locates and loads the CLI config, imports the user's Seedcord instance to
+* read its commands directory, scans and instantiates each command for its `toJSON()`, then renders the
+* registry and either writes it or, under `--check`, diffs it against the committed file.
+*/
+var CodegenRunner = class CodegenRunner {
+	locator;
+	configLoader;
+	moduleLoader;
+	generator;
+	logger;
+	constructor(locator, configLoader, moduleLoader, generator, logger) {
+		this.locator = locator;
+		this.configLoader = configLoader;
+		this.moduleLoader = moduleLoader;
+		this.generator = generator;
+		this.logger = logger;
+	}
+	static create(logger) {
+		const moduleLoader = new RuntimeModuleLoader();
+		return new CodegenRunner(new ConfigLocator(logger), new ConfigLoader(moduleLoader, logger), moduleLoader, new RegistryGenerator(logger), logger);
+	}
+	async run(check) {
+		const config = await this.loadConfig();
+		const rendered = renderRegistry(this.generator.generate(await this.scan(config)));
+		const outputPath = resolve(config.root, OUTPUT_FILENAME);
+		if (check) {
+			await this.check(rendered, outputPath);
+			return;
+		}
+		await this.write(rendered, outputPath);
+	}
+	async loadConfig() {
+		return this.configLoader.load(this.locator.locate());
+	}
+	async scan(config) {
+		const commandsDir = await this.resolveCommandsDir(config);
+		if (!commandsDir) return [];
+		const commands = [];
+		await this.walk(commandsDir, commands, /* @__PURE__ */ new Set(), true);
+		return commands;
+	}
+	async walk(dir, commands, seen, isRoot) {
+		let entries;
+		try {
+			entries = await readdir(dir, { withFileTypes: true });
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : "Unknown error";
+			if (isRoot) throw new SeedcordError(SeedcordErrorCode.CliCodegenCommandsDirUnreadable, [dir, reason]);
+			this.logger.warn(`Skipping unreadable directory ${dir}. ${reason}.`);
+			return;
+		}
+		for (const entry of entries) {
+			const fullPath = join(dir, entry.name);
+			if (entry.isDirectory()) await this.walk(fullPath, commands, seen, false);
+			else if (isTsOrJsFile(entry)) {
+				const imported = await this.moduleLoader.importModule(fullPath);
+				for (const exported of Object.values(imported)) {
+					if (seen.has(exported)) continue;
+					seen.add(exported);
+					const json = this.commandJsonOf(exported);
+					if (json) commands.push({
+						sourceFile: fullPath,
+						json
+					});
+				}
+			}
+		}
+	}
+	async resolveCommandsDir(config) {
+		this.logger.info("Loading instance to resolve the commands directory");
+		const instance = resolveDefaultExport(await this.moduleLoader.importModule(config.instance));
+		if (!this.isSeedcordInstance(instance)) throw new SeedcordError(SeedcordErrorCode.CliInstanceInvalid);
+		const commandsPath = instance.config.bot.commands.path;
+		return commandsPath ? resolve(process.cwd(), commandsPath) : void 0;
+	}
+	commandJsonOf(exported) {
+		if (typeof exported !== "function") return void 0;
+		let instance;
+		try {
+			instance = new exported();
+		} catch {
+			return;
+		}
+		if (!this.isBuilderLike(instance)) return void 0;
+		const json = instance.component.toJSON();
+		if (!this.isApplicationCommand(json)) return void 0;
+		return json;
+	}
+	isBuilderLike(value) {
+		if (typeof value !== "object" || value === null) return false;
+		const component = value.component;
+		return typeof component === "object" && component !== null && typeof component.toJSON === "function";
+	}
+	isApplicationCommand(json) {
+		if (typeof json !== "object" || json === null) return false;
+		const { name, type } = json;
+		if (typeof name !== "string") return false;
+		return type === void 0 || type === ApplicationCommandType.ChatInput || type === ApplicationCommandType.User || type === ApplicationCommandType.Message;
+	}
+	isSeedcordInstance(candidate) {
+		return typeof candidate === "object" && candidate !== null && candidate[SeedcordBrand] === true;
+	}
+	async write(rendered, outputPath) {
+		await mkdir(dirname(outputPath), { recursive: true });
+		await writeFile(outputPath, rendered, "utf8");
+		this.logger.info(`Command registry written to ${outputPath}`);
+	}
+	async check(rendered, outputPath) {
+		if ((existsSync(outputPath) ? await readFile(outputPath, "utf8") : "") === rendered) return;
+		this.logger.error(`Command registry is out of date. Run \`seedcord codegen\` and commit ${outputPath}.`);
+		process.exitCode = 1;
+	}
+};
+
+//#endregion
+//#region src/commands/codegen/CodegenCommand.ts
+var CodegenCommand = class extends BaseCommand {
+	runner;
+	constructor() {
+		super("codegen", "Generate the typed command registry (slash options and context menus) from your commands", "CLI:Codegen");
+		this.runner = CodegenRunner.create(this.logger);
+	}
+	register(program) {
+		program.command(this.name).description(this.description).option("--check", "Verify the committed registry is up to date instead of writing it").action(async (options) => {
+			try {
+				await this.runner.run(options.check ?? false);
+			} catch (error) {
+				this.logger.error("Seedcord codegen failed", error);
+				if (isSeedcordError(error)) process.exitCode = 1;
+				else process.exit(1);
+			}
+		});
+	}
+};
+
 //#endregion
 //#region src/ui/hooks/useDevState.ts
 function useDevState(store) {
@@ -865,10 +1158,16 @@ const PALETTE = [
 	"blue",
 	"cyanBright"
 ];
+const assigned = /* @__PURE__ */ new Map();
 function channelColor(channel) {
-	let hash = 0;
-	for (const char of channel) hash = (hash + char.charCodeAt(0)) % PALETTE.length;
-	return PALETTE[hash] ?? PALETTE[0];
+	const existing = assigned.get(channel);
+	if (existing) return existing;
+	const color = PALETTE[assigned.size % PALETTE.length] ?? PALETTE[0];
+	assigned.set(channel, color);
+	return color;
+}
+function resetChannelColors() {
+	assigned.clear();
 }
 
 //#endregion
@@ -929,7 +1228,7 @@ function Banner({ config, compact = false }) {
 	return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Wordmark, null), /* @__PURE__ */ React.createElement(Box, {
 		flexDirection: "column",
 		paddingTop: 1
-	}, /* @__PURE__ */ React.createElement(Text, { wrap: "truncate" }, /* @__PURE__ */ React.createElement(Text, { color: "blue" }, "➜"), " Interactions: ", /* @__PURE__ */ React.createElement(ConfigPath, { path: config.bot.interactions.path })), /* @__PURE__ */ React.createElement(Text, { wrap: "truncate" }, /* @__PURE__ */ React.createElement(Text, { color: "blue" }, "➜"), " Events: ", /* @__PURE__ */ React.createElement(ConfigPath, { path: config.bot.events.path })), /* @__PURE__ */ React.createElement(Text, { wrap: "truncate" }, /* @__PURE__ */ React.createElement(Text, { color: "blue" }, "➜"), " Pub/Sub: ", /* @__PURE__ */ React.createElement(ConfigPath, { path: config.subscribers.path }))));
+	}, /* @__PURE__ */ React.createElement(Text, null, /* @__PURE__ */ React.createElement(Text, { color: "blue" }, "➜"), " Interactions: ", /* @__PURE__ */ React.createElement(ConfigPath, { path: config.bot.interactions.path })), /* @__PURE__ */ React.createElement(Text, null, /* @__PURE__ */ React.createElement(Text, { color: "blue" }, "➜"), " Events: ", /* @__PURE__ */ React.createElement(ConfigPath, { path: config.bot.events.path })), /* @__PURE__ */ React.createElement(Text, null, /* @__PURE__ */ React.createElement(Text, { color: "blue" }, "➜"), " Pub/Sub: ", /* @__PURE__ */ React.createElement(ConfigPath, { path: config.subscribers.path }))));
 }
 
 //#endregion
@@ -1056,6 +1355,7 @@ function HotkeyBar({ phase, interactive, mode, following }) {
 //#endregion
 //#region src/ui/components/primitives/Sidebar.tsx
 const COMPACT_ROWS = 26;
+const MAX_RAIL = 40;
 const META_LABEL_WIDTH = 5;
 function logDir() {
 	const registry = LoggerChannelRegistry.instance;
@@ -1063,11 +1363,11 @@ function logDir() {
 	return path ? formatFilePath(path, { onlyDir: true }) : null;
 }
 function Meta({ label, value }) {
-	return /* @__PURE__ */ React.createElement(Text, { wrap: "truncate" }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, label.padEnd(META_LABEL_WIDTH)), value);
+	return /* @__PURE__ */ React.createElement(Text, null, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, label.padEnd(META_LABEL_WIDTH)), value);
 }
 function StatusBlock({ state, uptimeMs }) {
 	const dir = logDir();
-	return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(StatusBadge, { phase: state.phase }), state.status ? /* @__PURE__ */ React.createElement(Text, { wrap: "truncate" }, state.status) : null, uptimeMs === null ? null : /* @__PURE__ */ React.createElement(Meta, {
+	return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(StatusBadge, { phase: state.phase }), state.status ? /* @__PURE__ */ React.createElement(Text, null, state.status) : null, uptimeMs === null ? null : /* @__PURE__ */ React.createElement(Meta, {
 		label: "up",
 		value: formatUptime(uptimeMs)
 	}), dir === null ? null : /* @__PURE__ */ React.createElement(Meta, {
@@ -1075,12 +1375,15 @@ function StatusBlock({ state, uptimeMs }) {
 		value: dir
 	}));
 }
-function Sidebar({ state, enabled, uptimeMs, following, interactive, showToggles, cursor, width }) {
+function Sidebar({ state, enabled, uptimeMs, following, interactive, showToggles, cursor, width, ref }) {
 	const { rows } = useWindowSize();
 	const compact = rows < COMPACT_ROWS;
 	return /* @__PURE__ */ React.createElement(Box, {
+		ref,
 		flexDirection: "column",
-		width,
+		width: width ?? void 0,
+		maxWidth: MAX_RAIL,
+		flexShrink: 0,
 		paddingX: 1,
 		overflow: "hidden"
 	}, /* @__PURE__ */ React.createElement(Box, { flexShrink: 0 }, /* @__PURE__ */ React.createElement(Banner, {
@@ -1115,14 +1418,11 @@ function Sidebar({ state, enabled, uptimeMs, following, interactive, showToggles
 
 //#endregion
 //#region src/ui/layout/DevLayout.tsx
-const MAX_RAIL = 40;
-const MIN_RAIL = 26;
-const RAIL_FRACTION = .32;
 function DevLayout(props) {
-	const { state, columns, logBoxRef, scroll, viewportHeight, measured } = props;
+	const { state, railRef, railWidth, logBoxRef, scroll, viewportHeight, measured } = props;
 	const { enabled, showToggles, cursor, interactive, uptimeMs } = props;
-	const railWidth = Math.min(MAX_RAIL, Math.max(MIN_RAIL, Math.floor(columns * RAIL_FRACTION)));
 	return /* @__PURE__ */ React.createElement(Box, { flexGrow: 1 }, /* @__PURE__ */ React.createElement(Sidebar, {
+		ref: railRef,
 		state,
 		enabled,
 		uptimeMs,
@@ -1134,6 +1434,7 @@ function DevLayout(props) {
 	}), /* @__PURE__ */ React.createElement(Box, {
 		flexDirection: "column",
 		flexGrow: 1,
+		minWidth: 0,
 		borderStyle: "single",
 		borderColor: "gray",
 		borderTop: false,
@@ -1174,6 +1475,9 @@ function DevApp(props) {
 	const [cursor, setCursor] = useState(0);
 	const logBoxRef = useRef(null);
 	const [logBoxHeight, setLogBoxHeight] = useState(0);
+	const railRef = useRef(null);
+	const [railWidth, setRailWidth] = useState(null);
+	const measuredConfig = useRef(null);
 	const logs = useLogs(enabled);
 	const viewportHeight = Math.max(1, logBoxHeight);
 	const scroll = useScroll(logs, viewportHeight, logKey);
@@ -1190,6 +1494,18 @@ function DevApp(props) {
 		state.restartRequired,
 		state.commandUpdatePrompt
 	]);
+	useEffect(() => {
+		if (!railRef.current || !state.config || measuredConfig.current === state.config) return;
+		const measured = measureElement(railRef.current).width;
+		if (measured > 0) {
+			measuredConfig.current = state.config;
+			setRailWidth(measured);
+		}
+	}, [
+		rows,
+		columns,
+		state.config
+	]);
 	useInput((input, key) => {
 		dispatchHotkey({
 			input,
@@ -1228,7 +1544,8 @@ function DevApp(props) {
 		overflow: "hidden"
 	}, /* @__PURE__ */ React.createElement(DevLayout, {
 		state,
-		columns,
+		railRef,
+		railWidth,
 		logBoxRef,
 		scroll,
 		viewportHeight,
@@ -1782,19 +2099,27 @@ var DevRunner = class DevRunner {
 	locator;
 	configLoader;
 	store;
+	codegen;
+	codegenLogger;
 	currentSession = null;
 	signalResolve;
 	shouldQuit = false;
 	isDisconnected = false;
 	isRunning = false;
-	constructor(locator, configLoader, store) {
+	isRegenerating = false;
+	constructor(locator, configLoader, store, codegen, codegenLogger) {
 		this.locator = locator;
 		this.configLoader = configLoader;
 		this.store = store;
+		this.codegen = codegen;
+		this.codegenLogger = codegenLogger;
 	}
 	static create(logger, store) {
 		const moduleLoader = new RuntimeModuleLoader();
-		return new DevRunner(new ConfigLocator(logger), new ConfigLoader(moduleLoader, logger), store);
+		const locator = new ConfigLocator(logger);
+		const configLoader = new ConfigLoader(moduleLoader, logger);
+		const codegenLogger = new Logger("CLI:Codegen");
+		return new DevRunner(locator, configLoader, store, CodegenRunner.create(codegenLogger), codegenLogger);
 	}
 	async run() {
 		if (this.isRunning) return;
@@ -1823,6 +2148,7 @@ var DevRunner = class DevRunner {
 		if (!this.shouldQuit) this.isDisconnected = false;
 	}
 	async runSession() {
+		resetChannelColors();
 		this.store.setPhase("starting");
 		this.store.setBusy(true);
 		const config = await this.loadConfig();
@@ -1864,8 +2190,20 @@ var DevRunner = class DevRunner {
 		this.signalResolve?.();
 	}
 	refreshCommands(shouldRefresh) {
+		if (shouldRefresh) this.regenerateRegistry();
 		this.currentSession?.refreshCommands(shouldRefresh);
 	}
+	async regenerateRegistry() {
+		if (this.isRegenerating) return;
+		this.isRegenerating = true;
+		try {
+			await this.codegen.run(false);
+		} catch (error) {
+			this.codegenLogger.error("Command registry regeneration failed", error);
+		} finally {
+			this.isRegenerating = false;
+		}
+	}
 	async waitForSignal() {
 		return new Promise((resolve) => {
 			this.signalResolve = resolve;
@@ -1943,6 +2281,7 @@ async function main() {
 	const program = new Command().name("seedcord").description("Seedcord CLI").version(version);
 	new DevCommand().register(program);
 	new BuildCommand().register(program);
+	new CodegenCommand().register(program);
 	await program.parseAsync(process.argv);
 }
 main().catch((error) => {