create-nexwire 4.1.2 → 4.2.0

package/express/src/database/migrations/sqlite/meta/_journal.json

@@ -1,13 +1,13 @@
-{
-  "version": "7",
-  "dialect": "sqlite",
-  "entries": [
-    {
-      "idx": 0,
-      "version": "6",
-      "when": 1791141133457,
-      "tag": "0000_init",
-      "breakpoints": true
-    }
-  ]
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1791141133457,
+      "tag": "0000_init",
+      "breakpoints": true
+    }
+  ]
 }

package/express/src/framework/maker-cli/db/index.mjs

@@ -42,7 +42,7 @@ function assertName(value, label) {
 
 function unsupported() {
   console.error(
-    'Drizzle Kit does not support Laravel-style rollback/refresh migrations. Use "npm run maker db:fresh -- --seed" (or "bun maker db:fresh --seed") for a SQLite development reset, or manage rollback SQL manually for production databases.'
+    'Drizzle Kit does not support rollback/refresh migrations. Use "npm run maker db:fresh -- --seed" (or "bun maker db:fresh --seed") for a SQLite development reset, or manage rollback SQL manually for production databases.'
   );
   process.exit(1);
 }

package/express/src/framework/maker-cli/deploy/core.mjs

@@ -69,7 +69,6 @@ const STUBS = {
   },
   controller: {
     openapi: "controller/openapi.ts.stub",
-    openapiWithModel: "controller/openapi.with-model.ts.stub",
     plain: "controller/plain.ts.stub",
     schema: {
       openapi: "controller/schema.ts.stub",

package/express/src/framework/maker-cli/index.mjs

@@ -6,7 +6,8 @@ import { registerDbCommands } from "./db/index.mjs";
 import { registerMiddlewareCommands } from "./middleware/index.mjs";
 import { registerModuleCommands } from "./module/index.mjs";
 import { registerRuntimeCommands } from "./runtime/index.mjs";
-import { makerCommandPrefix, showHelp } from "./utils/help.mjs";
+import { configureGroupedHelp, makerCommandPrefix, showHelp } from "./utils/help.mjs";
+import { registerProjectCommands } from "./utils/project-commands.mjs";
 
 const args = process.argv.slice(2);
 const [command] = args;
@@ -33,8 +34,11 @@ try {
     .name(namePrefix ? `${namePrefix} maker` : "maker")
     .allowUnknownOption(true)
     .allowExcessArguments(true)
-    .helpOption("-h, --help")
-    .addHelpText("beforeAll", "nexwire maker\n");
+    .helpOption("-h, --help");
+
+  // Grouped command list. Must be set before anything prints help. Per-command
+  // help is untouched, so `maker <command> --help` still uses commander's layout.
+  configureGroupedHelp(program);
 
   registerMiddlewareCommands(program, args);
   registerModuleCommands(program, args);
@@ -42,6 +46,12 @@ try {
   registerDbCommands(program, args);
   registerRuntimeCommands(program, args);
 
+  // The project's own commands come last, so a built-in always wins a name
+  // clash. Absent file is silent and free; a file that is present but broken
+  // throws, and the catch below reports it and exits rather than leaving the
+  // developer with commands that silently do not exist.
+  await registerProjectCommands(program, args);
+
   if (!command) {
     showHelp(program);
   } else {

package/express/src/framework/maker-cli/module/core.mjs

@@ -5,7 +5,7 @@ import { drizzleGenerateArgs, ensureDatabaseDirectory, ensureMigrationMeta, sync
 import { detectDialect, openApiEnabled } from "../utils/env-db.mjs";
 import { writeFiles } from "../utils/file-ops.mjs";
 import { hasFlag } from "../utils/flags.mjs";
-import { assertName, camelCase, pascal } from "../utils/naming.mjs";
+import { assertName, camelCase, normalizeName, pascal, plural, snakeCase } from "../utils/naming.mjs";
 import { packageScript, runNodeScript } from "../utils/process.mjs";
 
 const stubsRoot = path.resolve(import.meta.dirname, "../stubs");
@@ -18,7 +18,6 @@ const STUBS = {
   },
   controller: {
     openapi: "controller/openapi.ts.stub",
-    openapiWithModel: "controller/openapi.with-model.ts.stub",
     plain: "controller/plain.ts.stub",
     standalone: "controller/standalone.ts.stub"
   },
@@ -36,7 +35,8 @@ const STUBS = {
     }
   },
   seeder: {
-    named: "seeder/name.ts.stub"
+    named: "seeder/name.ts.stub",
+    standalone: "seeder/standalone.ts.stub"
   },
   service: {
     named: "service/name.ts.stub",
@@ -185,6 +185,35 @@ function resolveModuleRef(rawModule, ...flagGroups) {
   return { moduleName, leaf: leafName(moduleName) };
 }
 
+/**
+ * Find an existing module directory whose folder name spells the requested
+ * module differently, only in the separators used (`my_module` vs `my-module`).
+ *
+ * Names are canonicalised to kebab-case, so a module scaffolded before this
+ * happened can live in a folder the canonical name no longer resolves to.
+ * Without this lookup, normalising the name would lock a developer out of their
+ * own module. Matching is segment by segment so a panel path such as
+ * `admin/reporting` keeps working, and each candidate is a real directory
+ * inside src/modules, so the result cannot escape it.
+ */
+async function resolveExistingModuleDir(moduleName) {
+  let current = path.resolve(process.cwd(), "src/modules");
+  for (const segment of moduleName.split("/").filter(Boolean)) {
+    let entries;
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      return "";
+    }
+    const directories = entries.filter((entry) => entry.isDirectory());
+    const exact = directories.find((entry) => entry.name === segment);
+    const loose = exact ?? directories.find((entry) => normalizeName(entry.name) === normalizeName(segment));
+    if (!loose) return "";
+    current = path.join(current, loose.name);
+  }
+  return current;
+}
+
 /** Ensure a module directory exists, throwing a helpful error if not. */
 async function assertModuleExists(moduleName) {
   const root = moduleRoot(moduleName);
@@ -192,6 +221,8 @@ async function assertModuleExists(moduleName) {
   try {
     stats = await fs.stat(root);
   } catch {
+    const legacy = await resolveExistingModuleDir(moduleName);
+    if (legacy) return legacy;
     throw new Error(`Module does not exist: ${moduleName}. Create it first with: bun maker module:make ${moduleName}`);
   }
   if (!stats.isDirectory()) {
@@ -200,16 +231,30 @@ async function assertModuleExists(moduleName) {
   return root;
 }
 
-/** Build the placeholder substitution map shared by module file generators. */
+/**
+ * Build the placeholder substitution map shared by module file generators.
+ *
+ * The same developer-supplied name reaches four different places in a stub, and
+ * each needs a different shape: import paths use the kebab file name, the
+ * service identifier is camelCase, the table identifier is camelCase plural and
+ * the SQL table name is snake_case plural. Deriving all of them from one
+ * canonical name is what keeps a multi-word name from landing in an identifier
+ * position as `game-configService`, which parses as subtraction.
+ */
 function moduleFileVars(moduleName, controller) {
-    return {
-      module: moduleName,
-      controller,
-      ClassName: pascal(controller),
-      name: leafName(moduleName),
-      tableVariable: `${controller}s`
-    };
-  }
+  const base = normalizeName(controller);
+  return {
+    module: moduleName,
+    // File name on disk and therefore every import path that points at it.
+    controller: base,
+    // Identifier the stubs export and call.
+    ServiceName: `${camelCase(base)}Service`,
+    ClassName: pascal(base),
+    name: leafName(moduleName),
+    tableName: plural(snakeCase(base)),
+    tableVariable: plural(camelCase(base))
+  };
+}
 
 /**
  * Generate a controller file for a module.
@@ -244,8 +289,7 @@ async function serviceFile(moduleName, controllerName, withModel) {
 async function moduleFiles(moduleName, openApi) {
     const name = leafName(moduleName);
     const vars = moduleFileVars(moduleName, name);
-  // The with-model controller variant only exists for the openapi style.
-  const controllerStub = openApi ? STUBS.controller.openapiWithModel : STUBS.controller.plain;
+  const controllerStub = openApi ? STUBS.controller.openapi : STUBS.controller.plain;
   return {
     "facade.ts": await stub(STUBS.facade.named, vars),
     [`controllers/${name}.ts`]: await stub(controllerStub, vars),
@@ -286,25 +330,28 @@ return await stub(routeStub, {
 
 /** Generate a named model file for a module. */
 async function namedModelTemplate(moduleName, name, dialect) {
+  const base = normalizeName(name);
   return await stub(STUBS.model.named[dialect], {
     module: moduleName,
-    name,
-    controller: name,
-    ClassName: pascal(name),
-    tableName: `${name}s`,
-    tableVariable: `${name}s`
+    name: base,
+    controller: base,
+    ClassName: pascal(base),
+    tableName: plural(snakeCase(base)),
+    tableVariable: plural(camelCase(base))
   });
 }
 
 /** Generate a seeder file for a module model. */
 async function namedSeederTemplate(moduleName, modelName, className) {
+  const base = normalizeName(modelName);
   return await stub(STUBS.seeder.named, {
     module: moduleName,
-    name: modelName,
+    // Import path: the model file is named after the model, in kebab-case.
+    name: base,
     controller: className,
     ClassName: pascal(className),
-    tableName: `${modelName}s`,
-    tableVariable: `${modelName}s`
+    tableName: plural(snakeCase(base)),
+    tableVariable: plural(camelCase(base))
   });
 }
 
@@ -717,7 +764,16 @@ export async function makeModel(rawModule, rawNameOrFlag, extraFlags = []) {
   await writeFileSafe(modelPath, await namedModelTemplate(moduleName, name, dialect), flags, "Model file");
 }
 
-/** Generate a seeder file for an existing module model. */
+/**
+ * Generate a seeder file.
+ *
+ * A seeder does not have to own the table it writes to, and does not have to
+ * write to only one table, so a missing model is not fatal. When the model is
+ * there we import it and pre-wire the insert; when it is not we emit the
+ * standalone shape and let the developer choose what to write. That is the
+ * same trade the controller makes when there is no service, and the service
+ * makes when there is no model. Seeder was the only generator that refused.
+ */
 export async function makeSeeder(rawModule, rawNameOrFlag, extraFlags = []) {
   const { moduleName, leaf } = resolveModuleRef(rawModule, rawNameOrFlag, extraFlags);
   const flags = [];
@@ -728,36 +784,58 @@ export async function makeSeeder(rawModule, rawNameOrFlag, extraFlags = []) {
   }
   flags.push(...extraFlags);
   const root = await assertModuleExists(moduleName);
-  let modelName = name;
-  let modelPath = path.join(root, "database", "models", `${modelName}.ts`);
-
-  try {
-    await fs.access(modelPath);
-  } catch {
-    // Fall back to the module's own model. This must use the leaf, not
-    // moduleName: for a panel module moduleName is "admin/testme", so using it
-    // would probe database/models/admin/testme.ts and never match.
-    modelName = leaf;
-    modelPath = path.join(root, "database", "models", `${modelName}.ts`);
 
-    try {
-      await fs.access(modelPath);
+  // The fallback probes the leaf, not moduleName: for a panel module moduleName
+  // is "admin/testme", so using it would look for database/models/admin/testme.ts
+  // and never match.
+  const modelName = await existingModelName(root, name, leaf);
+  let seeder;
+  if (modelName) {
+    seeder = await namedSeederTemplate(moduleName, modelName, name);
+    if (modelName !== name) {
       console.log(`Model '${name}' not found, using module model '${modelName}' for seeder '${name}'.`);
-    } catch {
-      const panel = panelOf(moduleName);
-      const suggest = panel ? `${leaf} ${name} --path=${panel}` : `${leaf} ${name}`;
-      throw new Error(
-        `Model not found for seeder: src/modules/${moduleName}/database/models/${name}.ts. Create it first with: bun maker module:make-model ${suggest}`
-      );
     }
+  } else {
+    seeder = await stub(STUBS.seeder.standalone, {
+      module: moduleName,
+      name,
+      ClassName: pascal(name),
+      // The stub shows this as the conventional table name, so derive it the
+      // same way the bound stub does - it is what a model of this name exports.
+      tableVariable: plural(camelCase(name))
+    });
+    const available = await listModels(root);
+    console.log(`No model '${name}' in module ${moduleName}, so this is a standalone seeder: it imports no model and writes nothing until you fill it in.`);
+    console.log(
+      available.length
+        ? `  Models in this module: ${available.join(", ")}. Run module:make-seeder ${moduleName} <one of these> for a seeder with the model already imported.`
+        : `  This module has no models yet. Create one with: bun maker module:make-model ${moduleName} ${name}`
+    );
   }
 
-  const seeder = await namedSeederTemplate(moduleName, modelName, name);
   await writeFileSafe(path.join(root, `database/seeders/${name}.ts`), seeder, flags, "Seeder file");
 
   console.log(`Seeder ready: ${moduleName}/${name}`);
 }
 
+/** The model a seeder binds to: the requested one, else the module's own. Null when neither exists. */
+async function existingModelName(root, name, leaf) {
+  for (const candidate of [name, leaf]) {
+    if (await pathExists(path.join(root, "database", "models", `${candidate}.ts`))) return candidate;
+  }
+  return null;
+}
+
+/** Model file names in a module, without the extension. Empty when there are none. */
+async function listModels(root) {
+  try {
+    const entries = await fs.readdir(path.join(root, "database", "models"));
+    return entries.filter((f) => f.endsWith(".ts")).map((f) => f.slice(0, -3));
+  } catch {
+    return [];
+  }
+}
+
 /** Generate a job file for an existing module. */
 export async function makeJob(rawModule, rawNameOrFlag, extraFlags = []) {
   const { moduleName, leaf } = resolveModuleRef(rawModule, rawNameOrFlag, extraFlags);

package/express/src/framework/maker-cli/runtime/core.mjs

@@ -120,7 +120,7 @@ function serveRedisUnavailablePage(port, endpoint) {
 </html>
 `;
 
-  return new Promise((_resolve, reject) => {
+  return new Promise((resolve, reject) => {
     const server = http.createServer((_req, res) => {
       res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
       res.end(body);
@@ -498,24 +498,42 @@ export async function runVite(configPath) {
   await runCommand(localBin("vite"), ["--config", configPath]);
 }
 
-/** Run Vitest tests (backend). */
+/**
+ * Strip the argument separator npm inserts.
+ *
+ * `npm run maker test -- posts` reaches us as `test posts`, but
+ * `npm run maker test -- -- posts` reaches us as `test -- posts`, because npm
+ * eats one separator and forwards the other. Vitest reads a bare `--` as a
+ * positional filter that matches no test file, which silently runs the whole
+ * suite instead of the one you asked for - so the command appears to work while
+ * doing something else. Dropping a leading `--` makes both spellings behave the
+ * same, and makes the passthrough behave identically across package managers.
+ */
+function vitestArgs(rawArgs) {
+  return rawArgs[0] === "--" ? rawArgs.slice(1) : rawArgs;
+}
+
+/** Run Vitest tests once (backend). */
 export async function runTest(rawArgs = []) {
-  await runCommand(localBin("vitest"), rawArgs);
+  // "run" is required. Bare `vitest` is watch mode, which never exits - so
+  // without this, `maker test` hung in any interactive terminal while CI and
+  // piped runs exited normally, and the two looked identical from a log.
+  await runCommand(localBin("vitest"), ["run", ...vitestArgs(rawArgs)]);
 }
 
 /** Run Vitest in watch mode (backend). */
 export async function runTestWatch(rawArgs = []) {
-  await runCommand(localBin("vitest"), rawArgs);
+  await runCommand(localBin("vitest"), vitestArgs(rawArgs));
 }
 
-/** Run Vitest with coverage (backend). */
+/** Run Vitest once with coverage (backend). */
 export async function runTestCoverage(rawArgs = []) {
-  await runCommand(localBin("vitest"), ["--coverage", ...rawArgs]);
+  await runCommand(localBin("vitest"), ["run", "--coverage", ...vitestArgs(rawArgs)]);
 }
 
 /** Run Vitest in UI mode (backend). */
 export async function runTestUI(rawArgs = []) {
-  await runCommand(localBin("vitest"), ["--ui", ...rawArgs]);
+  await runCommand(localBin("vitest"), ["--ui", ...vitestArgs(rawArgs)]);
 }
 
 /** Clear Vite cache directories. */
@@ -540,3 +558,4 @@ export async function clearViteCache() {
 
   console.log("Vite cache cleared.");
 }
+

package/express/src/framework/maker-cli/runtime/index.mjs

@@ -1,104 +1,120 @@
-import { clearViteCache, runRuntime, runTest, runTestCoverage, runTestUI, runTestWatch, runUi, runVite } from "./core.mjs";
-
-/** Register runtime commands (dev, serve, queue, schedule, UI tools) on the CLI program. */
-export function registerRuntimeCommands(program, rawArgs) {
-  program
-    .command("dev")
-    .description("Start API + Vue 3 UI plus optional workers/tools")
-    .option("--view <tools>", "Comma-separated UI tools to launch (redis,maildev,studio)")
-    .option("--viewer <tools>", "Alias for --view (npm expands --view to --viewer)")
-    .option("--with <tools>", "Alias for --view")
-    .option("--with-redis-view", "Launch Redis Commander")
-    .option("--with-maildev", "Launch MailDev")
-    .option("--with-db-studio", "Launch Drizzle Studio")
-    .allowUnknownOption(true)
-    .action(async () => runRuntime("dev", rawArgs));
-  program
-    .command("serve")
-    .description("Start HTTP server (dist first if built, else src)")
-    .option("--prod", "Run production build")
-    .option("--runtime <name>", "Runtime: node or bun", "node")
-    .option("--watch", "Watch for file changes (src mode)")
-    .option("--src", "Force source mode even if dist exists")
-    .allowUnknownOption(true)
-    .action(async () => runRuntime("serve", rawArgs));
-  program
-    .command("queue:work")
-    .description("Start queue worker (dist first if built, else src)")
-    .option("--queue <name>", "Queue name", "default")
-    .option("--prod", "Run production build")
-    .option("--runtime <name>", "Runtime: node or bun", "node")
-    .option("--src", "Force source mode even if dist exists")
-    .allowUnknownOption(true)
-    .action(async () => runRuntime("queue:work", rawArgs));
-  program
-    .command("queue:clear")
-    .description("Clear all queue keys")
-    .allowUnknownOption(true)
-    .action(async () => runRuntime("queue:clear", rawArgs));
-  program
-    .command("schedule:work")
-    .description("Start scheduler worker (dist first if built, else src)")
-    .option("--prod", "Run production build")
-    .option("--runtime <name>", "Runtime: node or bun", "node")
-    .option("--src", "Force source mode even if dist exists")
-    .allowUnknownOption(true)
-    .action(async () => runRuntime("schedule:work", rawArgs));
-  program
-    .command("maildev:view")
-    .description("Start MailDev SMTP and web UI")
-    .allowUnknownOption(true)
-    .action(async () => runUi("maildev:view"));
-  program
-    .command("redis:view")
-    .description("Start Redis Commander UI")
-    .allowUnknownOption(true)
-    .action(async () => runUi("redis:view"));
-  program
-    .command("ui:dev")
-    .description("Start Vue 3 UI from src/resources")
-    .allowUnknownOption(true)
-    .action(async () => runVite("src/resources/vite.config.ts"));
-  program
-    .command("admin:dev")
-    .description("Start admin UI dev server")
-    .allowUnknownOption(true)
-    .action(async () => runVite("src/resources/vite.config.ts"));
-  program
-    .command("vite:cache:clear")
-    .description("Clear Vite cache folders (cross-platform)")
-    .allowUnknownOption(true)
-    .action(async () => clearViteCache());
-  program
-    .command("test")
-    .description("Run Vitest backend tests")
-    .allowUnknownOption(true)
-    .action(async () => {
-      const args = process.argv.slice(3);
-      await runTest(args);
-    });
-  program
-    .command("test:watch")
-    .description("Run Vitest backend tests in watch mode")
-    .allowUnknownOption(true)
-    .action(async () => {
-      const args = process.argv.slice(3);
-      await runTestWatch(args);
-    });
-  program
-    .command("test:coverage")
-    .description("Run Vitest backend tests with code coverage")
-    .allowUnknownOption(true)
-    .action(async () => {
-      const args = process.argv.slice(3);
-      await runTestCoverage(args);
-    });
-  program
-    .command("test:ui")
-    .description("Run Vitest backend tests in UI mode")
-    .allowUnknownOption(true)
-    .action(async () => {
-      const args = process.argv.slice(3);
-      await runTestUI(args);
-    });
-}
+import { clearViteCache, runRuntime, runTest, runTestCoverage, runTestUI, runTestWatch, runUi, runVite } from "./core.mjs";
+import { initProjectCommands, PROJECT_COMMANDS_PATH } from "../utils/project-commands.mjs";
+
+/** Register runtime commands (dev, serve, queue, schedule, UI tools) on the CLI program. */
+export function registerRuntimeCommands(program, rawArgs) {
+  program
+    .command("dev")
+    .description("Start API + Vue 3 UI plus optional workers/tools")
+    .option("--view <tools>", "Comma-separated UI tools to launch (redis,maildev,studio)")
+    .option("--viewer <tools>", "Alias for --view (npm expands --view to --viewer)")
+    .option("--with <tools>", "Alias for --view")
+    .option("--with-redis-view", "Launch Redis Commander")
+    .option("--with-maildev", "Launch MailDev")
+    .option("--with-db-studio", "Launch Drizzle Studio")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("dev", rawArgs));
+  program
+    .command("serve")
+    .description("Start HTTP server (dist first if built, else src)")
+    .option("--prod", "Run production build")
+    .option("--runtime <name>", "Runtime: node or bun", "node")
+    .option("--watch", "Watch for file changes (src mode)")
+    .option("--src", "Force source mode even if dist exists")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("serve", rawArgs));
+  program
+    .command("queue:work")
+    .description("Start queue worker (dist first if built, else src)")
+    .option("--queue <name>", "Queue name", "default")
+    .option("--prod", "Run production build")
+    .option("--runtime <name>", "Runtime: node or bun", "node")
+    .option("--src", "Force source mode even if dist exists")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("queue:work", rawArgs));
+  program
+    .command("queue:clear")
+    .description("Clear all queue keys")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("queue:clear", rawArgs));
+  program
+    .command("schedule:work")
+    .description("Start scheduler worker (dist first if built, else src)")
+    .option("--prod", "Run production build")
+    .option("--runtime <name>", "Runtime: node or bun", "node")
+    .option("--src", "Force source mode even if dist exists")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("schedule:work", rawArgs));
+  program
+    .command("maildev:view")
+    .description("Start MailDev SMTP and web UI")
+    .allowUnknownOption(true)
+    .action(async () => runUi("maildev:view"));
+  program
+    .command("redis:view")
+    .description("Start Redis Commander UI")
+    .allowUnknownOption(true)
+    .action(async () => runUi("redis:view"));
+  program
+    .command("ui:dev")
+    .description("Start Vue 3 UI from src/resources")
+    .allowUnknownOption(true)
+    .action(async () => runVite("src/resources/vite.config.ts"));
+  program
+    .command("admin:dev")
+    .description("Start admin UI dev server")
+    .allowUnknownOption(true)
+    .action(async () => runVite("src/resources/vite.config.ts"));
+  program
+    .command("vite:cache:clear")
+    .description("Clear Vite cache folders (cross-platform)")
+    .allowUnknownOption(true)
+    .action(async () => clearViteCache());
+  program
+    .command("maker:init")
+    .description(`Create ${PROJECT_COMMANDS_PATH} for your own commands`)
+    .option("--force", "Overwrite an existing file")
+    .allowUnknownOption(true)
+    .action(async (options) => {
+      const { created, overwritten } = await initProjectCommands(process.cwd(), { force: Boolean(options?.force) });
+      // created = written into a new file; overwritten = replaced under --force.
+      // Neither means the file was already there and was left alone.
+      console.log(
+        created || overwritten
+          ? `Add your commands to ${PROJECT_COMMANDS_PATH}, then run: maker --help`
+          : `${PROJECT_COMMANDS_PATH} already exists and was left alone. Edit it to add commands, or re-run with --force to replace it.`
+      );
+    });
+  program
+    .command("test")
+    .description("Run Vitest backend tests")
+    .allowUnknownOption(true)
+    .action(async () => {
+      const args = process.argv.slice(3);
+      await runTest(args);
+    });
+  program
+    .command("test:watch")
+    .description("Run Vitest backend tests in watch mode")
+    .allowUnknownOption(true)
+    .action(async () => {
+      const args = process.argv.slice(3);
+      await runTestWatch(args);
+    });
+  program
+    .command("test:coverage")
+    .description("Run Vitest backend tests with code coverage")
+    .allowUnknownOption(true)
+    .action(async () => {
+      const args = process.argv.slice(3);
+      await runTestCoverage(args);
+    });
+  program
+    .command("test:ui")
+    .description("Run Vitest backend tests in UI mode")
+    .allowUnknownOption(true)
+    .action(async () => {
+      const args = process.argv.slice(3);
+      await runTestUI(args);
+    });
+}