@ooneex/cli 1.16.0 → 1.17.1

package/dist/index.js

@@ -4878,11 +4878,197 @@ var require_pluralize = __commonJS((exports, module) => {
 // src/index.ts
 import { run } from "@ooneex/command";
 
-// src/commands/CompletionZshCommand.ts
-import { homedir } from "os";
+// src/commands/AppBuildCommand.ts
 import { join } from "path";
 import { decorator } from "@ooneex/command";
 import { TerminalLogger } from "@ooneex/logger";
+class AppBuildCommand {
+  getName() {
+    return "app:build";
+  }
+  getDescription() {
+    return "Build the application";
+  }
+  async run() {
+    const logger = new TerminalLogger;
+    const appDir = join(process.cwd(), "modules", "app");
+    const packageJsonFile = Bun.file(join(appDir, "package.json"));
+    if (!await packageJsonFile.exists()) {
+      logger.error("Module app not found", undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+      return;
+    }
+    const packageJson = await packageJsonFile.json();
+    const name = packageJson.name ?? "app";
+    logger.info(`Building ${name}...`, undefined, {
+      showTimestamp: false,
+      showArrow: false,
+      useSymbol: true
+    });
+    const proc = Bun.spawn(["bun", "build", "./src/index.ts", "--outdir", "./dist", "--target", "bun"], {
+      cwd: appDir,
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode === 0) {
+      logger.success(`Build completed for ${name}`, undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+    } else {
+      logger.error(`Build failed for ${name} (exit code: ${exitCode})`, undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+    }
+  }
+}
+AppBuildCommand = __legacyDecorateClassTS([
+  decorator.command()
+], AppBuildCommand);
+// src/commands/AppStartCommand.ts
+import { join as join2 } from "path";
+import { decorator as decorator2 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger2 } from "@ooneex/logger";
+class AppStartCommand {
+  getName() {
+    return "app:start";
+  }
+  getDescription() {
+    return "Start the application";
+  }
+  async run() {
+    const logger = new TerminalLogger2;
+    const appDir = join2(process.cwd(), "modules", "app");
+    const packageJsonFile = Bun.file(join2(appDir, "package.json"));
+    if (!await packageJsonFile.exists()) {
+      logger.error("Module app not found", undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+      return;
+    }
+    const packageJson = await packageJsonFile.json();
+    const name = packageJson.name ?? "app";
+    const composeFile = join2(appDir, "docker-compose.yml");
+    const composeExists = await Bun.file(composeFile).exists();
+    if (composeExists) {
+      logger.info(`Starting Docker services for ${name}...`, undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+      const docker = Bun.spawn(["docker", "compose", "up", "-d"], {
+        cwd: appDir,
+        stdout: "inherit",
+        stderr: "inherit"
+      });
+      const dockerExitCode = await docker.exited;
+      if (dockerExitCode === 0) {
+        logger.success(`Docker services started for ${name}`, undefined, {
+          showTimestamp: false,
+          showArrow: false,
+          useSymbol: true
+        });
+      } else {
+        logger.error(`Docker services failed for ${name} (exit code: ${dockerExitCode})`, undefined, {
+          showTimestamp: false,
+          showArrow: false,
+          useSymbol: true
+        });
+        return;
+      }
+    }
+    logger.info(`Starting ${name}...`, undefined, {
+      showTimestamp: false,
+      showArrow: false,
+      useSymbol: true
+    });
+    const entryPoint = join2(appDir, "src", "index.ts");
+    const app = Bun.spawn(["bun", "--hot", "run", entryPoint], {
+      cwd: process.cwd(),
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    const appExitCode = await app.exited;
+    if (appExitCode !== 0) {
+      logger.error(`Application exited with code ${appExitCode}`, undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+    }
+  }
+}
+AppStartCommand = __legacyDecorateClassTS([
+  decorator2.command()
+], AppStartCommand);
+// src/commands/AppStopCommand.ts
+import { join as join3 } from "path";
+import { decorator as decorator3 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger3 } from "@ooneex/logger";
+class AppStopCommand {
+  getName() {
+    return "app:stop";
+  }
+  getDescription() {
+    return "Stop the application";
+  }
+  async run() {
+    const logger = new TerminalLogger3;
+    const appDir = join3(process.cwd(), "modules", "app");
+    const packageJsonFile = Bun.file(join3(appDir, "package.json"));
+    if (!await packageJsonFile.exists()) {
+      logger.error("Module app not found", undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+      return;
+    }
+    const packageJson = await packageJsonFile.json();
+    const name = packageJson.name ?? "app";
+    logger.info(`Stopping Docker services for ${name}...`, undefined, {
+      showTimestamp: false,
+      showArrow: false,
+      useSymbol: true
+    });
+    const proc = Bun.spawn(["docker", "compose", "down"], {
+      cwd: appDir,
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode === 0) {
+      logger.success(`Docker services stopped for ${name}`, undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+    } else {
+      logger.error(`Failed to stop Docker services for ${name} (exit code: ${exitCode})`, undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+    }
+  }
+}
+AppStopCommand = __legacyDecorateClassTS([
+  decorator3.command()
+], AppStopCommand);
+// src/commands/CompletionZshCommand.ts
+import { homedir } from "os";
+import { join as join4 } from "path";
+import { decorator as decorator4 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger4 } from "@ooneex/logger";
 
 // src/templates/completions/_oo.txt
 var _oo_default = `#compdef oo ooneex
@@ -4898,7 +5084,11 @@ _oo_modules() {
 _oo() {
   local -a commands
   commands=(
+    'app\\:build:Build the application'
+    'app\\:start:Start the application'
+    'app\\:stop:Stop the application'
     'completion\\:zsh:Install Zsh completion for oo command'
+    'help:Show available commands'
     'make\\:ai:Generate a new AI class'
     'make\\:analytics:Generate a new analytics class'
     'make\\:app:Generate a new application'
@@ -4914,6 +5104,7 @@ _oo() {
     'make\\:mailer:Generate a new mailer class'
     'make\\:middleware:Generate a new middleware class'
     'make\\:migration:Generate a new migration file'
+    'migration\\:up:Run migrations for all modules'
     'make\\:module:Generate a new module'
     'make\\:permission:Generate a new permission class'
     'make\\:pubsub:Generate a new PubSub event class'
@@ -4934,6 +5125,7 @@ _oo() {
     'make\\:resource\\:user:Generate user resource (entity, migration, repository)'
     'make\\:resource\\:video:Generate video resource (entity, migration, repository)'
     'make\\:seed:Generate a new seed file'
+    'seed\\:run:Run seeds for all modules'
     'make\\:service:Generate a new service class'
     'make\\:storage:Generate a new storage class'
     'make\\:vector-database:Generate a new vector database class'
@@ -5005,7 +5197,7 @@ _oo() {
             '--name=[Name of the resource]:name' \\
             '--module=[Module name]:module:_oo_modules'
           ;;
-        make:release|make:resource:book|make:resource:calendar-event|make:resource:category|make:resource:color|make:resource:discount|make:resource:folder|make:resource:image|make:resource:note|make:resource:status|make:resource:tag|make:resource:task|make:resource:topic|make:resource:user|make:resource:video|make:claude:skill|completion:zsh)
+        app:build|app:start|app:stop|help|make:release|make:resource:book|make:resource:calendar-event|make:resource:category|make:resource:color|make:resource:discount|make:resource:folder|make:resource:image|make:resource:note|make:resource:status|make:resource:tag|make:resource:task|make:resource:topic|make:resource:user|make:resource:video|make:claude:skill|migration:up|seed:run|completion:zsh)
           ;;
       esac
       ;;
@@ -5029,7 +5221,11 @@ _ooneex_modules() {
 _ooneex() {
   local -a commands
   commands=(
+    'app\\:build:Build the application'
+    'app\\:start:Start the application'
+    'app\\:stop:Stop the application'
     'completion\\:zsh:Install Zsh completion for oo command'
+    'help:Show available commands'
     'make\\:ai:Generate a new AI class'
     'make\\:analytics:Generate a new analytics class'
     'make\\:app:Generate a new application'
@@ -5045,6 +5241,7 @@ _ooneex() {
     'make\\:mailer:Generate a new mailer class'
     'make\\:middleware:Generate a new middleware class'
     'make\\:migration:Generate a new migration file'
+    'migration\\:up:Run migrations for all modules'
     'make\\:module:Generate a new module'
     'make\\:permission:Generate a new permission class'
     'make\\:pubsub:Generate a new PubSub event class'
@@ -5065,6 +5262,7 @@ _ooneex() {
     'make\\:resource\\:user:Generate user resource (entity, migration, repository)'
     'make\\:resource\\:video:Generate video resource (entity, migration, repository)'
     'make\\:seed:Generate a new seed file'
+    'seed\\:run:Run seeds for all modules'
     'make\\:service:Generate a new service class'
     'make\\:storage:Generate a new storage class'
     'make\\:vector-database:Generate a new vector database class'
@@ -5136,7 +5334,7 @@ _ooneex() {
             '--name=[Name of the resource]:name' \\
             '--module=[Module name]:module:_ooneex_modules'
           ;;
-        make:release|make:resource:book|make:resource:calendar-event|make:resource:category|make:resource:color|make:resource:discount|make:resource:folder|make:resource:image|make:resource:note|make:resource:status|make:resource:tag|make:resource:task|make:resource:topic|make:resource:user|make:resource:video|make:claude:skill|completion:zsh)
+        app:build|app:start|app:stop|help|make:release|make:resource:book|make:resource:calendar-event|make:resource:category|make:resource:color|make:resource:discount|make:resource:folder|make:resource:image|make:resource:note|make:resource:status|make:resource:tag|make:resource:task|make:resource:topic|make:resource:user|make:resource:video|make:claude:skill|migration:up|seed:run|completion:zsh)
           ;;
       esac
       ;;
@@ -5155,12 +5353,12 @@ class CompletionZshCommand {
     return "Install Zsh completion for oo command";
   }
   async run() {
-    const completionDir = join(homedir(), ".zsh");
-    const ooFilePath = join(completionDir, "_oo");
+    const completionDir = join4(homedir(), ".zsh");
+    const ooFilePath = join4(completionDir, "_oo");
     await Bun.write(ooFilePath, _oo_default);
-    const ooneexFilePath = join(completionDir, "_ooneex");
+    const ooneexFilePath = join4(completionDir, "_ooneex");
     await Bun.write(ooneexFilePath, _ooneex_default);
-    const logger = new TerminalLogger;
+    const logger = new TerminalLogger4;
     logger.success(`${ooFilePath} created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
@@ -5181,12 +5379,42 @@ class CompletionZshCommand {
   }
 }
 CompletionZshCommand = __legacyDecorateClassTS([
-  decorator.command()
+  decorator4.command()
 ], CompletionZshCommand);
+// src/commands/HelpCommand.ts
+import { COMMANDS_CONTAINER, decorator as decorator5 } from "@ooneex/command";
+class HelpCommand {
+  getName() {
+    return "help";
+  }
+  getDescription() {
+    return "Show available commands";
+  }
+  run() {
+    const commands = [];
+    for (const CommandClass of COMMANDS_CONTAINER) {
+      const command = new CommandClass;
+      commands.push({ name: command.getName(), description: command.getDescription() });
+    }
+    commands.sort((a, b) => a.name.localeCompare(b.name));
+    const maxNameLength = Math.max(...commands.map((c) => c.name.length));
+    const lines = ["", "Available commands:", ""];
+    for (const { name, description } of commands) {
+      lines.push(`  ${name.padEnd(maxNameLength + 2)}${description}`);
+    }
+    lines.push("");
+    process.stdout.write(`${lines.join(`
+`)}
+`);
+  }
+}
+HelpCommand = __legacyDecorateClassTS([
+  decorator5.command()
+], HelpCommand);
 // src/commands/MakeAiCommand.ts
-import { join as join4 } from "path";
-import { decorator as decorator3 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger3 } from "@ooneex/logger";
+import { join as join7 } from "path";
+import { decorator as decorator7 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger6 } from "@ooneex/logger";
 import { toPascalCase as toPascalCase2 } from "@ooneex/utils";
 
 // src/prompts/askName.ts
@@ -5283,12 +5511,12 @@ export class {{NAME}}Ai implements IAiChat<OpenAiConfigType> {
 `;
 
 // src/utils.ts
-import { join as join3 } from "path";
+import { join as join6 } from "path";
 
 // src/commands/MakeModuleCommand.ts
-import { join as join2 } from "path";
-import { decorator as decorator2 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger2 } from "@ooneex/logger";
+import { join as join5 } from "path";
+import { decorator as decorator6 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger5 } from "@ooneex/logger";
 import { toKebabCase, toPascalCase } from "@ooneex/utils";
 
 // src/templates/module/command.run.txt
@@ -5436,53 +5664,53 @@ class MakeModuleCommand {
     }
     const pascalName = toPascalCase(name).replace(/Module$/, "");
     const kebabName = toKebabCase(pascalName);
-    const moduleDir = join2(cwd, "modules", kebabName);
-    const srcDir = join2(moduleDir, "src");
-    const testsDir = join2(moduleDir, "tests");
+    const moduleDir = join5(cwd, "modules", kebabName);
+    const srcDir = join5(moduleDir, "src");
+    const testsDir = join5(moduleDir, "tests");
     const moduleContent = module_default.replace(/{{NAME}}/g, pascalName);
     const packageContent = package_default.replace(/{{NAME}}/g, kebabName);
     const testContent = test_default.replace(/{{NAME}}/g, pascalName);
-    await Bun.write(join2(srcDir, `${pascalName}Module.ts`), moduleContent);
+    await Bun.write(join5(srcDir, `${pascalName}Module.ts`), moduleContent);
     if (!skipMigrations) {
-      await Bun.write(join2(srcDir, "migrations", "migrations.ts"), "");
+      await Bun.write(join5(srcDir, "migrations", "migrations.ts"), "");
     }
     if (!skipSeeds) {
-      await Bun.write(join2(srcDir, "seeds", "seeds.ts"), "");
+      await Bun.write(join5(srcDir, "seeds", "seeds.ts"), "");
     }
     if (!skipCommands) {
-      await Bun.write(join2(srcDir, "commands", "commands.ts"), "");
-      const binCommandRunPath = join2(moduleDir, "bin", "command", "run.ts");
+      await Bun.write(join5(srcDir, "commands", "commands.ts"), "");
+      const binCommandRunPath = join5(moduleDir, "bin", "command", "run.ts");
       const binCommandRunFile = Bun.file(binCommandRunPath);
       if (!await binCommandRunFile.exists()) {
         await Bun.write(binCommandRunPath, command_run_default);
       }
     }
-    await Bun.write(join2(moduleDir, "package.json"), packageContent);
-    await Bun.write(join2(moduleDir, "tsconfig.json"), tsconfig_default);
-    await Bun.write(join2(testsDir, `${pascalName}Module.spec.ts`), testContent);
+    await Bun.write(join5(moduleDir, "package.json"), packageContent);
+    await Bun.write(join5(moduleDir, "tsconfig.json"), tsconfig_default);
+    await Bun.write(join5(testsDir, `${pascalName}Module.spec.ts`), testContent);
     if (kebabName !== "app") {
-      const appModulePath = join2(cwd, "modules", "app", "src", "AppModule.ts");
+      const appModulePath = join5(cwd, "modules", "app", "src", "AppModule.ts");
       if (await Bun.file(appModulePath).exists()) {
         await this.addToAppModule(appModulePath, pascalName, kebabName);
       }
-      const appTsconfigPath = join2(cwd, "modules", "app", "tsconfig.json");
+      const appTsconfigPath = join5(cwd, "modules", "app", "tsconfig.json");
       if (await Bun.file(appTsconfigPath).exists()) {
         await this.addPathAlias(appTsconfigPath, kebabName);
       }
     }
-    const commitlintPath = join2(cwd, ".commitlintrc.ts");
+    const commitlintPath = join5(cwd, ".commitlintrc.ts");
     if (await Bun.file(commitlintPath).exists()) {
       await this.addModuleScope(commitlintPath, kebabName);
     }
     if (!silent) {
-      const logger = new TerminalLogger2;
+      const logger = new TerminalLogger5;
       logger.success(`modules/${kebabName} created successfully`, undefined, {
         showTimestamp: false,
         showArrow: false,
         useSymbol: true
       });
     }
-    const packageJsonPath = join2(process.cwd(), "package.json");
+    const packageJsonPath = join5(process.cwd(), "package.json");
     const packageJson = await Bun.file(packageJsonPath).json();
     const deps = packageJson.dependencies ?? {};
     const devDeps = packageJson.devDependencies ?? {};
@@ -5497,13 +5725,13 @@ class MakeModuleCommand {
   }
 }
 MakeModuleCommand = __legacyDecorateClassTS([
-  decorator2.command()
+  decorator6.command()
 ], MakeModuleCommand);
 
 // src/utils.ts
 var ensureModule = async (module) => {
-  const moduleDir = join3(process.cwd(), "modules", module);
-  const moduleDirExists = await Bun.file(join3(moduleDir, "package.json")).exists();
+  const moduleDir = join6(process.cwd(), "modules", module);
+  const moduleDirExists = await Bun.file(join6(moduleDir, "package.json")).exists();
   if (!moduleDirExists) {
     const makeModule = new MakeModuleCommand;
     await makeModule.run({ name: module, cwd: process.cwd(), silent: true });
@@ -5528,28 +5756,28 @@ class MakeAiCommand {
       await ensureModule(module);
     }
     const content = ai_default.replace(/{{NAME}}/g, name);
-    const base = module ? join4("modules", module) : ".";
-    const aiLocalDir = join4(base, "src", "ai");
-    const aiDir = join4(process.cwd(), aiLocalDir);
-    const filePath = join4(aiDir, `${name}Ai.ts`);
+    const base = module ? join7("modules", module) : ".";
+    const aiLocalDir = join7(base, "src", "ai");
+    const aiDir = join7(process.cwd(), aiLocalDir);
+    const filePath = join7(aiDir, `${name}Ai.ts`);
     await Bun.write(filePath, content);
     const testContent = ai_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join4(base, "tests", "ai");
-    const testsDir = join4(process.cwd(), testsLocalDir);
-    const testFilePath = join4(testsDir, `${name}Ai.spec.ts`);
+    const testsLocalDir = join7(base, "tests", "ai");
+    const testsDir = join7(process.cwd(), testsLocalDir);
+    const testFilePath = join7(testsDir, `${name}Ai.spec.ts`);
     await Bun.write(testFilePath, testContent);
-    const logger = new TerminalLogger3;
-    logger.success(`${join4(aiLocalDir, name)}Ai.ts created successfully`, undefined, {
+    const logger = new TerminalLogger6;
+    logger.success(`${join7(aiLocalDir, name)}Ai.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join4(testsLocalDir, name)}Ai.spec.ts created successfully`, undefined, {
+    logger.success(`${join7(testsLocalDir, name)}Ai.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    const packageJsonPath = join4(process.cwd(), "package.json");
+    const packageJsonPath = join7(process.cwd(), "package.json");
     const packageJson = await Bun.file(packageJsonPath).json();
     const deps = packageJson.dependencies ?? {};
     const devDeps = packageJson.devDependencies ?? {};
@@ -5564,12 +5792,12 @@ class MakeAiCommand {
   }
 }
 MakeAiCommand = __legacyDecorateClassTS([
-  decorator3.command()
+  decorator7.command()
 ], MakeAiCommand);
 // src/commands/MakeAnalyticsCommand.ts
-import { join as join5 } from "path";
-import { decorator as decorator4 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger4 } from "@ooneex/logger";
+import { join as join8 } from "path";
+import { decorator as decorator8 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger7 } from "@ooneex/logger";
 import { toPascalCase as toPascalCase3 } from "@ooneex/utils";
 
 // src/templates/analytics.test.txt
@@ -5620,28 +5848,28 @@ class MakeAnalyticsCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join5("modules", module) : ".";
-    const analyticsLocalDir = join5(base, "src", "analytics");
-    const analyticsDir = join5(process.cwd(), analyticsLocalDir);
-    const filePath = join5(analyticsDir, `${name}Analytics.ts`);
+    const base = module ? join8("modules", module) : ".";
+    const analyticsLocalDir = join8(base, "src", "analytics");
+    const analyticsDir = join8(process.cwd(), analyticsLocalDir);
+    const filePath = join8(analyticsDir, `${name}Analytics.ts`);
     await Bun.write(filePath, content);
     const testContent = analytics_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join5(base, "tests", "analytics");
-    const testsDir = join5(process.cwd(), testsLocalDir);
-    const testFilePath = join5(testsDir, `${name}Analytics.spec.ts`);
+    const testsLocalDir = join8(base, "tests", "analytics");
+    const testsDir = join8(process.cwd(), testsLocalDir);
+    const testFilePath = join8(testsDir, `${name}Analytics.spec.ts`);
     await Bun.write(testFilePath, testContent);
-    const logger = new TerminalLogger4;
-    logger.success(`${join5(analyticsLocalDir, name)}Analytics.ts created successfully`, undefined, {
+    const logger = new TerminalLogger7;
+    logger.success(`${join8(analyticsLocalDir, name)}Analytics.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join5(testsLocalDir, name)}Analytics.spec.ts created successfully`, undefined, {
+    logger.success(`${join8(testsLocalDir, name)}Analytics.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    const packageJsonPath = join5(process.cwd(), "package.json");
+    const packageJsonPath = join8(process.cwd(), "package.json");
     const packageJson = await Bun.file(packageJsonPath).json();
     const deps = packageJson.dependencies ?? {};
     const devDeps = packageJson.devDependencies ?? {};
@@ -5656,13 +5884,13 @@ class MakeAnalyticsCommand {
   }
 }
 MakeAnalyticsCommand = __legacyDecorateClassTS([
-  decorator4.command()
+  decorator8.command()
 ], MakeAnalyticsCommand);
 // src/commands/MakeAppCommand.ts
-import { join as join7 } from "path";
-import { decorator as decorator6 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger6 } from "@ooneex/logger";
-import { toKebabCase as toKebabCase3, toSnakeCase } from "@ooneex/utils";
+import { join as join9 } from "path";
+import { decorator as decorator9 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger8 } from "@ooneex/logger";
+import { toKebabCase as toKebabCase2, toSnakeCase } from "@ooneex/utils";
 
 // src/prompts/askDestination.ts
 var import_enquirer2 = __toESM(require_enquirer(), 1);
@@ -6134,10 +6362,6 @@ FROM base AS prerelease
 COPY --from=build /temp/dev/node_modules node_modules
 COPY . .
 
-# run migrations and seed
-RUN bun run migration:up
-RUN bun run seed:run
-
 # build
 ENV NODE_ENV=production
 RUN bun run build
@@ -6479,9 +6703,7 @@ var package_json_default = `{
     "fmt": "bunx biome check --write",
     "lint": "bunx nx run-many -t lint --output-style=stream --verbose",
     "test": "bunx nx run-many -t test --output-style=stream --verbose",
-    "docker:stop": "bunx nx run-many -t docker:stop --output-style=stream --verbose",
-    "migration:up": "bunx nx run-many -t migration:up --output-style=stream --verbose",
-    "seed:run": "bunx nx run-many -t seed:run --output-style=stream --verbose",
+    "stop": "bunx nx run-many -t stop --output-style=stream --verbose",
     "commit": "bunx commit"
   },
   "workspaces": [
@@ -6521,14 +6743,7 @@ cp modules/app/.env.example modules/app/.env
 
 Edit \`modules/app/.env\` with your configuration values.
 
-### 3. Run migrations and seeds
-
-\`\`\`bash
-bun run migration:up
-bun run seed:run
-\`\`\`
-
-### 4. Start the development server
+### 3. Start the development server
 
 \`\`\`bash
 bun run dev
@@ -6545,9 +6760,7 @@ The server starts on \`http://localhost:3000\` by default.
 | \`bun run test\`         | Run all tests                        |
 | \`bun run lint\`         | Run TypeScript check + Biome linting |
 | \`bun run fmt\`          | Format code with Biome               |
-| \`bun run migration:up\` | Execute pending database migrations  |
-| \`bun run seed:run\`     | Populate database with seed data     |
-| \`bun run docker:stop\`  | Stop all Docker containers           |
+| \`bun run stop\`  | Stop all Docker containers           |
 | \`bun run commit\`       | Interactive conventional commit      |
 
 ## Module Architecture
@@ -6791,500 +7004,33 @@ var zed_settings_json_default = `{
 }
 `;
 
-// src/commands/MakeControllerCommand.ts
-import { basename, join as join6 } from "path";
-import { decorator as decorator5 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger5 } from "@ooneex/logger";
-import { toKebabCase as toKebabCase2, toPascalCase as toPascalCase4, trim } from "@ooneex/utils";
-
-// src/prompts/askConfirm.ts
-var import_enquirer3 = __toESM(require_enquirer(), 1);
-var askConfirm = async (config) => {
-  const response = await import_enquirer3.prompt({
-    type: "confirm",
-    name: "confirm",
-    message: config.message,
-    initial: config.initial
-  });
-  return response.confirm;
-};
-
-// ../types/dist/index.js
-var HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"];
-
-// src/prompts/askRouteMethod.ts
-var import_enquirer4 = __toESM(require_enquirer(), 1);
-
-// src/constraints/AssertRouteMethod.ts
-import { Assert as Assert2, Validation as Validation2 } from "@ooneex/validation";
-
-class AssertRouteMethod extends Validation2 {
-  getConstraint() {
-    return Assert2("string >= 3");
+// src/commands/MakeAppCommand.ts
+class MakeAppCommand {
+  getName() {
+    return "make:app";
   }
-  getErrorMessage() {
-    return `Route method must be one of: ${HTTP_METHODS.join(", ")}`;
+  getDescription() {
+    return "Generate a new application";
   }
-  validate(data, constraint) {
-    const basicValidation = super.validate(data, constraint);
-    if (!basicValidation.isValid) {
-      return basicValidation;
-    }
-    const method = data;
-    if (method.trim() !== method) {
-      return {
-        isValid: false,
-        message: this.getErrorMessage() || "Invalid route method format"
-      };
-    }
-    const upperMethod = method.toUpperCase();
-    if (!HTTP_METHODS.includes(upperMethod)) {
-      return {
-        isValid: false,
-        message: this.getErrorMessage() || "Invalid route method"
-      };
+  async run(options) {
+    let { name, destination } = options;
+    if (!name) {
+      name = await askName({ message: "Enter application name" });
     }
-    return {
-      isValid: true
-    };
-  }
-}
-
-// src/prompts/askRouteMethod.ts
-var askRouteMethod = async (config) => {
-  const response = await import_enquirer4.prompt({
-    type: "select",
-    name: "method",
-    message: config.message,
-    initial: config.initial ?? 0,
-    choices: HTTP_METHODS.map((method) => method),
-    validate: (value) => {
-      const constraint = new AssertRouteMethod;
-      const result = constraint.validate(value);
-      if (!result.isValid) {
-        return result.message || "Route method is invalid";
-      }
-      return true;
-    }
-  });
-  return response.method;
-};
-
-// src/prompts/askRouteName.ts
-var import_enquirer5 = __toESM(require_enquirer(), 1);
-
-// src/constraints/AssertRouteName.ts
-import { Assert as Assert3, Validation as Validation3 } from "@ooneex/validation";
-var ROUTE_NAME_REGEX = /^[a-zA-Z0-9]+\.[a-zA-Z0-9]+\.[a-zA-Z0-9]+$/;
-
-class AssertRouteName extends Validation3 {
-  getConstraint() {
-    return Assert3("string >= 7");
-  }
-  getErrorMessage() {
-    return "Route name must follow format: namespace.resource.action (e.g., 'api.users.list')";
-  }
-  validate(data, constraint) {
-    const basicValidation = super.validate(data, constraint);
-    if (!basicValidation.isValid) {
-      return basicValidation;
-    }
-    const routeName = data;
-    if (routeName.trim() !== routeName) {
-      return {
-        isValid: false,
-        message: this.getErrorMessage() || "Invalid route name format"
-      };
-    }
-    if (!ROUTE_NAME_REGEX.test(routeName)) {
-      return {
-        isValid: false,
-        message: this.getErrorMessage() || "Invalid route name format"
-      };
-    }
-    const segments = routeName.split(".");
-    if (segments.length !== 3) {
-      return {
-        isValid: false,
-        message: this.getErrorMessage() || "Invalid route name format"
-      };
-    }
-    const [namespace, resource, action] = segments;
-    if (!namespace || !resource || !action) {
-      return {
-        isValid: false,
-        message: this.getErrorMessage() || "Invalid route name format"
-      };
-    }
-    return {
-      isValid: true
-    };
-  }
-}
-
-// src/prompts/askRouteName.ts
-var askRouteName = async (config) => {
-  const response = await import_enquirer5.prompt({
-    type: "input",
-    name: "routeName",
-    message: config.message,
-    validate: (value) => {
-      const constraint = new AssertRouteName;
-      const result = constraint.validate(value);
-      if (!result.isValid) {
-        return result.message || "Route name is invalid";
-      }
-      return true;
-    }
-  });
-  return response.routeName;
-};
-
-// src/prompts/askRoutePath.ts
-var import_enquirer6 = __toESM(require_enquirer(), 1);
-
-// src/constraints/AssertRoutePath.ts
-import { Assert as Assert4, Validation as Validation4 } from "@ooneex/validation";
-var ROUTE_PATH_MIN_LENGTH = 1;
-var ROUTE_PATH_REGEX = /^\/[\w\-/:]*$/;
-var VALID_SEGMENT_REGEX = /^[a-zA-Z0-9\-_]+$/;
-var PARAM_SEGMENT_REGEX = /^:[a-zA-Z][a-zA-Z0-9]*$/;
-
-class AssertRoutePath extends Validation4 {
-  getConstraint() {
-    return Assert4(`string >= ${ROUTE_PATH_MIN_LENGTH}`);
-  }
-  getErrorMessage() {
-    return "Route path must start with '/' and contain only valid segments (e.g., '/users', '/api/users/:id')";
-  }
-  validate(data, constraint) {
-    const basicValidation = super.validate(data, constraint);
-    if (!basicValidation.isValid) {
-      return basicValidation;
-    }
-    const path = data;
-    if (path.trim() !== path) {
-      return {
-        isValid: false,
-        message: this.getErrorMessage() || "Invalid route path format"
-      };
-    }
-    if (!path.startsWith("/")) {
-      return {
-        isValid: false,
-        message: "Route path must start with '/'"
-      };
-    }
-    if (path.length > 1 && path.endsWith("/")) {
-      return {
-        isValid: false,
-        message: "Route path cannot end with '/' (except for root path)"
-      };
-    }
-    if (!ROUTE_PATH_REGEX.test(path)) {
-      return {
-        isValid: false,
-        message: this.getErrorMessage() || "Invalid route path format"
-      };
-    }
-    if (path === "/") {
-      return {
-        isValid: true
-      };
-    }
-    const segments = path.slice(1).split("/");
-    for (const segment of segments) {
-      if (!segment) {
-        return {
-          isValid: false,
-          message: "Route path cannot contain empty segments (double slashes)"
-        };
-      }
-      if (segment.startsWith(":")) {
-        if (!PARAM_SEGMENT_REGEX.test(segment)) {
-          return {
-            isValid: false,
-            message: `Invalid parameter segment '${segment}'. Parameters must follow format ':paramName' with alphanumeric characters only`
-          };
-        }
-      } else {
-        if (!VALID_SEGMENT_REGEX.test(segment)) {
-          return {
-            isValid: false,
-            message: `Invalid path segment '${segment}'. Segments must contain only letters, numbers, hyphens, and underscores`
-          };
-        }
-      }
-    }
-    return {
-      isValid: true
-    };
-  }
-}
-
-// src/prompts/askRoutePath.ts
-var askRoutePath = async (config) => {
-  const response = await import_enquirer6.prompt({
-    type: "input",
-    name: "path",
-    message: config.message,
-    initial: config.initial ?? "/",
-    validate: (value) => {
-      const constraint = new AssertRoutePath;
-      const result = constraint.validate(value);
-      if (!result.isValid) {
-        return result.message || "Route path is invalid";
-      }
-      return true;
-    }
-  });
-  return response.path;
-};
-
-// src/templates/controller.socket.txt
-var controller_socket_default = `import type { ContextType } from "@ooneex/socket";
-import { ERole } from "@ooneex/role";
-import { Route } from "@ooneex/routing";
-import { Assert } from "@ooneex/validation";
-
-export type {{TYPE_NAME}}RouteType = {
-  params: {
-
-  },
-  payload: {
-
-  },
-  queries: {
-
-  },
-  response: {
-
-  },
-};
-
-@Route.socket("{{ROUTE_PATH}}", {
-  name: "{{ROUTE_NAME}}",
-  version: 1,
-  description: "",
-  params: {
-    // id: Assert("string"),
-  },
-  payload: Assert({
-
-  }),
-  queries: Assert({
-
-  }),
-  response: Assert({
-
-  }),
-  roles: [ERole.USER],
-})
-export class {{NAME}}Controller {
-  public async index(context: ContextType<{{TYPE_NAME}}RouteType>) {
-    // const { id } = context.params;
-
-    return context.response.json({
-
-    });
-  }
-}
-`;
-
-// src/templates/controller.test.txt
-var controller_test_default = `import { describe, expect, test } from "bun:test";
-import { {{NAME}}Controller } from "@/controllers/{{NAME}}Controller";
-
-describe("{{NAME}}Controller", () => {
-  test("should have class name ending with 'Controller'", () => {
-    expect({{NAME}}Controller.name.endsWith("Controller")).toBe(true);
-  });
-
-  test("should have 'index' method", () => {
-    expect({{NAME}}Controller.prototype.index).toBeDefined();
-    expect(typeof {{NAME}}Controller.prototype.index).toBe("function");
-  });
-});
-`;
-
-// src/templates/controller.txt
-var controller_default = `import type { ContextType } from "@ooneex/controller";
-import { ERole } from "@ooneex/role";
-import { Route } from "@ooneex/routing";
-import { Assert } from "@ooneex/validation";
-
-export type {{TYPE_NAME}}RouteType = {
-  params: {
-
-  },
-  payload: {
-
-  },
-  queries: {
-
-  },
-  response: {
-
-  },
-};
-
-@Route.{{ROUTE_METHOD}}("{{ROUTE_PATH}}", {
-  name: "{{ROUTE_NAME}}",
-  version: 1,
-  description: "",
-  params: {
-    // id: Assert("string"),
-  },
-  payload: Assert({
-
-  }),
-  queries: Assert({
-
-  }),
-  response: Assert({
-
-  }),
-  roles: [ERole.USER],
-})
-export class {{NAME}}Controller {
-  public async index(context: ContextType<{{TYPE_NAME}}RouteType>) {
-    // const { id } = context.params;
-
-    return context.response.json({
-
-    });
-  }
-}
-`;
-
-// src/commands/MakeControllerCommand.ts
-class MakeControllerCommand {
-  getName() {
-    return "make:controller";
-  }
-  getDescription() {
-    return "Generate a new controller class";
-  }
-  async addToModule(modulePath, controllerName) {
-    let content = await Bun.file(modulePath).text();
-    const className = `${controllerName}Controller`;
-    const importLine = `import { ${className} } from "./controllers/${className}";
-`;
-    const lastImportIndex = content.lastIndexOf("import ");
-    const lineEnd = content.indexOf(`
-`, lastImportIndex);
-    content = `${content.slice(0, lineEnd + 1)}${importLine}${content.slice(lineEnd + 1)}`;
-    const regex = /(controllers:\s*\[)([^\]]*)/s;
-    const match = content.match(regex);
-    if (match) {
-      const existing = match[2]?.trim();
-      const newValue = existing ? `${existing}, ${className}` : className;
-      content = content.replace(regex, `$1${newValue}`);
-    }
-    await Bun.write(modulePath, content);
-  }
-  async run(options) {
-    let { name, module, isSocket } = options;
-    if (!name) {
-      name = await askName({ message: "Enter controller name" });
-    }
-    if (isSocket === undefined) {
-      isSocket = await askConfirm({ message: "Is this a socket controller?" });
-    }
-    name = toPascalCase4(name).replace(/Controller$/, "");
-    const { route = {} } = options;
-    const selectedTemplate = isSocket ? controller_socket_default : controller_default;
-    let content = selectedTemplate.replaceAll("{{NAME}}", name);
-    if (!route.name) {
-      route.name = await askRouteName({ message: "Enter route name (e.g., api.user.create)" });
-    }
-    const routeTypeName = toPascalCase4(route.name);
-    content = content.replaceAll("{{ROUTE_NAME}}", route.name).replaceAll("{{TYPE_NAME}}", routeTypeName);
-    if (!route.path) {
-      route.path = await askRoutePath({ message: "Enter route path", initial: "/" });
-    }
-    const routePath = `/${toKebabCase2(trim(route.path, "/"))}`;
-    content = content.replaceAll("{{ROUTE_PATH}}", routePath);
-    if (!isSocket && !route.method) {
-      route.method = await askRouteMethod({ message: "Enter route method" });
-    }
-    if (!isSocket && route.method) {
-      content = content.replaceAll("{{ROUTE_METHOD}}", route.method.toLowerCase());
-    }
-    if (module) {
-      await ensureModule(module);
-    }
-    const base = module ? join6("modules", module) : ".";
-    const controllersLocalDir = join6(base, "src", "controllers");
-    const controllersDir = join6(process.cwd(), controllersLocalDir);
-    const filePath = join6(controllersDir, `${name}Controller.ts`);
-    await Bun.write(filePath, content);
-    const testContent = controller_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join6(base, "tests", "controllers");
-    const testsDir = join6(process.cwd(), testsLocalDir);
-    const testFilePath = join6(testsDir, `${name}Controller.spec.ts`);
-    await Bun.write(testFilePath, testContent);
-    const modulePascalName = module ? toPascalCase4(module) : toPascalCase4(basename(process.cwd()));
-    const modulePath = join6(process.cwd(), base, "src", `${modulePascalName}Module.ts`);
-    if (await Bun.file(modulePath).exists()) {
-      await this.addToModule(modulePath, name);
-    }
-    const logger = new TerminalLogger5;
-    logger.success(`${join6(controllersLocalDir, name)}Controller.ts created successfully`, undefined, {
-      showTimestamp: false,
-      showArrow: false,
-      useSymbol: true
-    });
-    logger.success(`${join6(testsLocalDir, name)}Controller.spec.ts created successfully`, undefined, {
-      showTimestamp: false,
-      showArrow: false,
-      useSymbol: true
-    });
-    const packageJsonPath = join6(process.cwd(), "package.json");
-    const packageJson = await Bun.file(packageJsonPath).json();
-    const deps = packageJson.dependencies ?? {};
-    const devDeps = packageJson.devDependencies ?? {};
-    if (!deps["@ooneex/controller"] && !devDeps["@ooneex/controller"]) {
-      const install = Bun.spawn(["bun", "add", "@ooneex/controller"], {
-        cwd: process.cwd(),
-        stdout: "ignore",
-        stderr: "inherit"
-      });
-      await install.exited;
-    }
-  }
-}
-MakeControllerCommand = __legacyDecorateClassTS([
-  decorator5.command()
-], MakeControllerCommand);
-
-// src/commands/MakeAppCommand.ts
-class MakeAppCommand {
-  getName() {
-    return "make:app";
-  }
-  getDescription() {
-    return "Generate a new application";
-  }
-  async run(options) {
-    let { name, destination } = options;
-    if (!name) {
-      name = await askName({ message: "Enter application name" });
-    }
-    const kebabName = toKebabCase3(name);
-    if (!destination) {
-      destination = await askDestination({ message: "Enter destination path", initial: kebabName });
+    const kebabName = toKebabCase2(name);
+    if (!destination) {
+      destination = await askDestination({ message: "Enter destination path", initial: kebabName });
     }
     const packageContent = package_json_default.replace(/{{NAME}}/g, kebabName);
-    await Bun.write(join7(destination, ".commitlintrc.ts"), _commitlintrc_ts_default);
-    await Bun.write(join7(destination, ".gitignore"), _gitignore_default);
-    await Bun.write(join7(destination, "biome.jsonc"), biome_jsonc_default);
-    await Bun.write(join7(destination, "bunfig.toml"), bunfig_toml_default);
-    await Bun.write(join7(destination, "nx.json"), nx_json_default);
-    await Bun.write(join7(destination, "package.json"), packageContent);
-    await Bun.write(join7(destination, "README.md"), README_md_default.replace(/{{NAME}}/g, kebabName));
-    await Bun.write(join7(destination, "tsconfig.json"), tsconfig_json_default);
-    await Bun.write(join7(destination, ".zed", "settings.json"), zed_settings_json_default);
+    await Bun.write(join9(destination, ".commitlintrc.ts"), _commitlintrc_ts_default);
+    await Bun.write(join9(destination, ".gitignore"), _gitignore_default);
+    await Bun.write(join9(destination, "biome.jsonc"), biome_jsonc_default);
+    await Bun.write(join9(destination, "bunfig.toml"), bunfig_toml_default);
+    await Bun.write(join9(destination, "nx.json"), nx_json_default);
+    await Bun.write(join9(destination, "package.json"), packageContent);
+    await Bun.write(join9(destination, "README.md"), README_md_default.replace(/{{NAME}}/g, kebabName));
+    await Bun.write(join9(destination, "tsconfig.json"), tsconfig_json_default);
+    await Bun.write(join9(destination, ".zed", "settings.json"), zed_settings_json_default);
     const makeModuleCommand = new MakeModuleCommand;
     await makeModuleCommand.run({
       name: "app",
@@ -7293,34 +7039,23 @@ class MakeAppCommand {
       skipMigrations: true,
       skipSeeds: true
     });
-    const appModulePackagePath = join7(destination, "modules", "app", "package.json");
+    const appModulePackagePath = join9(destination, "modules", "app", "package.json");
     const appModulePackageJson = await Bun.file(appModulePackagePath).json();
     appModulePackageJson.scripts.dev = "docker compose up -d && bun --hot run ./src/index.ts";
-    appModulePackageJson.scripts["docker:stop"] = "docker compose down";
+    appModulePackageJson.scripts.stop = "docker compose down";
     appModulePackageJson.scripts.build = "bun build ./src/index.ts --outdir ./dist --target bun";
     await Bun.write(appModulePackagePath, JSON.stringify(appModulePackageJson, null, 2));
     const envContent = env_default.replace(/^DATABASE_URL=/m, 'DATABASE_URL="postgresql://ooneex:ooneex@localhost:5432/ooneex"').replace(/^CACHE_REDIS_URL=/m, 'CACHE_REDIS_URL="redis://localhost:6379"').replace(/^PUBSUB_REDIS_URL=/m, 'PUBSUB_REDIS_URL="redis://localhost:6379"').replace(/^RATE_LIMIT_REDIS_URL=/m, 'RATE_LIMIT_REDIS_URL="redis://localhost:6379"').replace(/^DATABASE_REDIS_URL=/m, 'DATABASE_REDIS_URL="redis://localhost:6379"');
-    await Bun.write(join7(destination, "modules", "app", ".env"), envContent);
-    await Bun.write(join7(destination, "modules", "app", ".env.example"), env_default);
-    await Bun.write(join7(destination, "modules", "app", "src", "databases", "AppDatabase.ts"), app_database_default);
-    await Bun.write(join7(destination, "modules", "app", "src", "index.ts"), index_ts_default);
+    await Bun.write(join9(destination, "modules", "app", ".env"), envContent);
+    await Bun.write(join9(destination, "modules", "app", ".env.example"), env_default);
+    await Bun.write(join9(destination, "modules", "app", "src", "databases", "AppDatabase.ts"), app_database_default);
+    await Bun.write(join9(destination, "modules", "app", "src", "index.ts"), index_ts_default);
     const snakeName = toSnakeCase(name);
     const dockerComposeContent = docker_compose_yml_default.replace(/{{NAME}}/g, snakeName);
-    await Bun.write(join7(destination, "modules", "app", "docker-compose.yml"), dockerComposeContent);
+    await Bun.write(join9(destination, "modules", "app", "docker-compose.yml"), dockerComposeContent);
     const dockerfileContent = Dockerfile_default.replace(/{{NAME}}/g, snakeName);
-    await Bun.write(join7(destination, "modules", "app", "Dockerfile"), dockerfileContent);
-    await Bun.write(join7(destination, "modules", "app", "var", ".gitkeep"), "");
-    const makeControllerCommand = new MakeControllerCommand;
-    await makeControllerCommand.run({
-      name: "HealthCheck",
-      isSocket: false,
-      module: "app",
-      route: {
-        name: "api.health.check",
-        path: "/healthcheck",
-        method: "GET"
-      }
-    });
+    await Bun.write(join9(destination, "modules", "app", "Dockerfile"), dockerfileContent);
+    await Bun.write(join9(destination, "modules", "app", "var", ".gitkeep"), "");
     const gitInit = Bun.spawn(["git", "init"], { cwd: destination, stdout: "ignore", stderr: "inherit" });
     await gitInit.exited;
     const addDeps = Bun.spawn([
@@ -7379,9 +7114,9 @@ class MakeAppCommand {
     await addDevDeps.exited;
     const huskyInit = Bun.spawn(["bunx", "husky", "init"], { cwd: destination, stdout: "ignore", stderr: "inherit" });
     await huskyInit.exited;
-    await Bun.write(join7(destination, ".husky", "pre-commit"), "lint-staged");
-    await Bun.write(join7(destination, ".husky", "commit-msg"), `bunx commitlint --edit "$1"`);
-    const logger = new TerminalLogger6;
+    await Bun.write(join9(destination, ".husky", "pre-commit"), "lint-staged");
+    await Bun.write(join9(destination, ".husky", "commit-msg"), `bunx commitlint --edit "$1"`);
+    const logger = new TerminalLogger8;
     logger.success(`${kebabName} created successfully at ${destination}`, undefined, {
       showTimestamp: false,
       showArrow: false,
@@ -7390,512 +7125,978 @@ class MakeAppCommand {
   }
 }
 MakeAppCommand = __legacyDecorateClassTS([
-  decorator6.command()
+  decorator9.command()
 ], MakeAppCommand);
 // src/commands/MakeCacheCommand.ts
-import { join as join8 } from "path";
-import { decorator as decorator7 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger7 } from "@ooneex/logger";
-import { toPascalCase as toPascalCase5 } from "@ooneex/utils";
+import { join as join10 } from "path";
+import { decorator as decorator10 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger9 } from "@ooneex/logger";
+import { toPascalCase as toPascalCase4 } from "@ooneex/utils";
+
+// src/templates/cache.test.txt
+var cache_test_default = `import { describe, expect, test } from "bun:test";
+import { {{NAME}}Cache } from "@/cache/{{NAME}}Cache";
+
+describe("{{NAME}}Cache", () => {
+  test("should have class name ending with 'Cache'", () => {
+    expect({{NAME}}Cache.name.endsWith("Cache")).toBe(true);
+  });
+
+  test("should have 'get' method", () => {
+    expect({{NAME}}Cache.prototype.get).toBeDefined();
+    expect(typeof {{NAME}}Cache.prototype.get).toBe("function");
+  });
+
+  test("should have 'set' method", () => {
+    expect({{NAME}}Cache.prototype.set).toBeDefined();
+    expect(typeof {{NAME}}Cache.prototype.set).toBe("function");
+  });
+
+  test("should have 'delete' method", () => {
+    expect({{NAME}}Cache.prototype.delete).toBeDefined();
+    expect(typeof {{NAME}}Cache.prototype.delete).toBe("function");
+  });
+
+  test("should have 'has' method", () => {
+    expect({{NAME}}Cache.prototype.has).toBeDefined();
+    expect(typeof {{NAME}}Cache.prototype.has).toBe("function");
+  });
+});
+`;
+
+// src/templates/cache.txt
+var cache_default = `import { CacheException, decorator } from "@ooneex/cache";
+import type { ICache } from "@ooneex/cache";
+
+@decorator.cache()
+export class {{NAME}}Cache implements ICache {
+  public async get<T = unknown>(key: string): Promise<T | undefined> {
+    throw new CacheException(\`Failed to get key "\${key}": Not implemented\`);
+  }
+
+  public async set<T = unknown>(key: string, value: T, ttl?: number): Promise<void> {
+    throw new CacheException(\`Failed to set key "\${key}": Not implemented\`);
+  }
+
+  public async delete(key: string): Promise<boolean> {
+    throw new CacheException(\`Failed to delete key "\${key}": Not implemented\`);
+  }
+
+  public async has(key: string): Promise<boolean> {
+    throw new CacheException(\`Failed to check if key "\${key}" exists: Not implemented\`);
+  }
+}
+`;
+
+// src/commands/MakeCacheCommand.ts
+class MakeCacheCommand {
+  getName() {
+    return "make:cache";
+  }
+  getDescription() {
+    return "Generate a new cache class";
+  }
+  async run(options) {
+    let { name, module } = options;
+    if (!name) {
+      name = await askName({ message: "Enter cache name" });
+    }
+    name = toPascalCase4(name).replace(/Cache$/, "");
+    const content = cache_default.replace(/{{NAME}}/g, name);
+    if (module) {
+      await ensureModule(module);
+    }
+    const base = module ? join10("modules", module) : ".";
+    const cacheLocalDir = join10(base, "src", "cache");
+    const cacheDir = join10(process.cwd(), cacheLocalDir);
+    const filePath = join10(cacheDir, `${name}Cache.ts`);
+    await Bun.write(filePath, content);
+    const testContent = cache_test_default.replace(/{{NAME}}/g, name);
+    const testsLocalDir = join10(base, "tests", "cache");
+    const testsDir = join10(process.cwd(), testsLocalDir);
+    const testFilePath = join10(testsDir, `${name}Cache.spec.ts`);
+    await Bun.write(testFilePath, testContent);
+    const logger = new TerminalLogger9;
+    logger.success(`${join10(cacheLocalDir, name)}Cache.ts created successfully`, undefined, {
+      showTimestamp: false,
+      showArrow: false,
+      useSymbol: true
+    });
+    logger.success(`${join10(testsLocalDir, name)}Cache.spec.ts created successfully`, undefined, {
+      showTimestamp: false,
+      showArrow: false,
+      useSymbol: true
+    });
+    const packageJsonPath = join10(process.cwd(), "package.json");
+    const packageJson = await Bun.file(packageJsonPath).json();
+    const deps = packageJson.dependencies ?? {};
+    const devDeps = packageJson.devDependencies ?? {};
+    if (!deps["@ooneex/cache"] && !devDeps["@ooneex/cache"]) {
+      const install = Bun.spawn(["bun", "add", "@ooneex/cache"], {
+        cwd: process.cwd(),
+        stdout: "ignore",
+        stderr: "inherit"
+      });
+      await install.exited;
+    }
+  }
+}
+MakeCacheCommand = __legacyDecorateClassTS([
+  decorator10.command()
+], MakeCacheCommand);
+// src/commands/MakeClaudeSkillCommand.ts
+import { join as join11 } from "path";
+import { decorator as decorator11 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger10 } from "@ooneex/logger";
+
+// src/templates/claude/skills/commit.md.txt
+var commit_md_default = `---
+name: commit
+description: Create commit messages grouped by module. Analyzes git changes, groups files under modules/ by module name, and creates separate commits following commitlint conventions. Uses common scope for non-module changes.
+---
+
+# Commit by Module
+
+Create separate commits for each modified module, following the project's commitlint conventions.
+
+## Workflow
+
+1. **Analyze staged/unstaged changes**
+   - Run \`git status --porcelain\` to get all modified files
+   - Group changes by module (files under \`modules/<module-name>/\`)
+   - Identify non-module changes (files not in \`modules/\`) as scope \`common\`
+
+2. **For each module with changes**
+   - Stage only that module's files: \`git add modules/<module-name>/\`
+   - Determine the appropriate commit type based on changes
+   - Create a commit with proper format: \`type(scope): Subject\`
+   - The scope is the module name in lower-case
+   - Repeat for next module
+
+3. **Handle non-module changes**
+   - Files outside \`modules/\` (e.g., \`bun.lock\`, \`package.json\`, config files, \`packages/\` changes) use scope \`common\`
+   - Stage and commit separately from module changes
+
+## Commit Message Format
+
+\`\`\`
+type(scope): Subject line
+\`\`\`
+
+### Valid Types
+- \`feat\`: New feature
+- \`fix\`: Bug fix
+- \`refactor\`: Code refactoring (no new feature, no bug fix)
+- \`test\`: Adding/updating tests
+- \`chore\`: Maintenance tasks (dependencies, configs)
+- \`docs\`: Documentation changes
+- \`style\`: Code style changes (formatting, whitespace)
+- \`perf\`: Performance improvements
+- \`build\`: Build system changes
+- \`ci\`: CI configuration changes
+- \`revert\`: Revert previous commit
+
+### Scope Rules
+- For files under \`modules/<name>/\`: use the module name as scope (e.g., \`module\` scope matches the commitlint config)
+- For all other files: use \`common\`
+- Scope must be lower-case
+- Scope must never be empty
+- If the module name matches a valid commitlint scope, use it directly
+- If it does not match, use \`module\` as the scope
+
+### Subject Rules
+- Use sentence-case, start-case, pascal-case, or upper-case
+- No period at the end
+- Maximum 100 characters for entire header
+- Use imperative mood ("Add feature" not "Added feature")
+
+## Determining Commit Type
+
+Analyze the changes to determine the appropriate type:
+
+| Change Pattern | Type |
+|---------------|------|
+| New files with functionality | \`feat\` |
+| Bug fixes, error corrections | \`fix\` |
+| Code restructuring, renaming | \`refactor\` |
+| New/updated test files (\`*.spec.ts\`) | \`test\` |
+| Documentation files (\`*.md\`) | \`docs\` |
+| Dependency updates, lock files | \`chore\` |
+| Build configs, scripts | \`build\` |
+| CI/CD files | \`ci\` |
+| Formatting only | \`style\` |
+| Performance optimizations | \`perf\` |
 
-// src/templates/cache.test.txt
-var cache_test_default = `import { describe, expect, test } from "bun:test";
-import { {{NAME}}Cache } from "@/cache/{{NAME}}Cache";
+## Examples
 
-describe("{{NAME}}Cache", () => {
-  test("should have class name ending with 'Cache'", () => {
-    expect({{NAME}}Cache.name.endsWith("Cache")).toBe(true);
-  });
+### Example 1: Multiple Module Changes
 
-  test("should have 'get' method", () => {
-    expect({{NAME}}Cache.prototype.get).toBeDefined();
-    expect(typeof {{NAME}}Cache.prototype.get).toBe("function");
-  });
+Git status shows:
+\`\`\`
+M modules/user/src/services/UserService.ts
+A modules/user/src/services/AuthService.ts
+M modules/user/tests/UserService.spec.ts
+M modules/product/src/entities/Product.ts
+M modules/product/src/repositories/ProductRepository.ts
+M bun.lock
+M packages/cache/src/index.ts
+\`\`\`
 
-  test("should have 'set' method", () => {
-    expect({{NAME}}Cache.prototype.set).toBeDefined();
-    expect(typeof {{NAME}}Cache.prototype.set).toBe("function");
-  });
+Commands to execute:
+\`\`\`bash
+# Commit user module
+git add modules/user/
+git commit -m "feat(user): Add AuthService and update UserService"
 
-  test("should have 'delete' method", () => {
-    expect({{NAME}}Cache.prototype.delete).toBeDefined();
-    expect(typeof {{NAME}}Cache.prototype.delete).toBe("function");
-  });
+# Commit product module
+git add modules/product/
+git commit -m "refactor(product): Update Product entity and repository"
 
-  test("should have 'has' method", () => {
-    expect({{NAME}}Cache.prototype.has).toBeDefined();
-    expect(typeof {{NAME}}Cache.prototype.has).toBe("function");
-  });
-});
+# Commit non-module changes
+git add bun.lock packages/cache/
+git commit -m "chore(common): Update dependencies and cache package"
+\`\`\`
+
+### Example 2: Single Module with Tests
+
+Git status shows:
+\`\`\`
+A modules/payment/src/services/StripeService.ts
+A modules/payment/tests/StripeService.spec.ts
+\`\`\`
+
+Command:
+\`\`\`bash
+git add modules/payment/
+git commit -m "feat(payment): Add StripeService with tests"
+\`\`\`
+
+### Example 3: Only Non-module Changes
+
+Git status shows:
+\`\`\`
+M package.json
+M bun.lock
+M packages/logger/src/Logger.ts
+\`\`\`
+
+Command:
+\`\`\`bash
+git add package.json bun.lock packages/logger/
+git commit -m "chore(common): Update dependencies and logger package"
+\`\`\`
+
+### Example 4: Module Refactoring with Deletions
+
+Git status shows:
+\`\`\`
+D modules/order/src/services/OldOrderService.ts
+A modules/order/src/services/OrderService.ts
+M modules/order/src/index.ts
+\`\`\`
+
+Command:
+\`\`\`bash
+git add modules/order/
+git commit -m "refactor(order): Replace OldOrderService with OrderService"
+\`\`\`
+
+## Subject Line Guidelines
+
+Write clear, descriptive subjects:
+
+| Good | Bad |
+|------|-----|
+| \`Add Stripe payment integration\` | \`stripe\` |
+| \`Fix null check in user validation\` | \`fix bug\` |
+| \`Update order processing flow\` | \`changes\` |
+| \`Remove deprecated auth methods\` | \`cleanup\` |
+| \`Rename UserAdapter to UserService\` | \`rename\` |
+
+## Pre-commit Checklist
+
+Before committing, verify:
+1. Changes are logically grouped by module
+2. Tests pass for modified modules
+3. No debug code or console.logs left in
+4. Commit message follows the format exactly
+5. For Entity class, if property is optional, add \`null\` to its type.
+
+## Handling Special Cases
+
+### Mixed Changes in One Module
+If a module has both new features and bug fixes, prioritize:
+1. \`feat\` if primary change is new functionality
+2. \`fix\` if primary change is a bug fix
+3. Split into multiple commits if changes are truly independent
+
+### Deleted Files Only
+Use \`refactor\` for removing deprecated code:
+\`\`\`bash
+git add modules/user/
+git commit -m "refactor(user): Remove deprecated UserAdapter"
+\`\`\`
+
+### Renamed/Moved Files
+Use \`refactor\` for file reorganization:
+\`\`\`bash
+git add modules/product/
+git commit -m "refactor(product): Reorganize service file structure"
+\`\`\`
 `;
 
-// src/templates/cache.txt
-var cache_default = `import { CacheException, decorator } from "@ooneex/cache";
-import type { ICache } from "@ooneex/cache";
+// src/templates/claude/skills/make.ai.md.txt
+var make_ai_md_default = '---\nname: make:ai\ndescription: Generate a new AI class with its test file, then complete the generated code. Use when creating a new AI chat class that uses OpenAI via the @ooneex/ai package.\n---\n\n# Make AI Class\n\nGenerate a new AI class and its test file using the `make:ai` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the AI class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:ai --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/ai/<Name>Ai.ts` - The AI class file (or `modules/<module>/src/ai/<Name>Ai.ts` with `--module`)\n- `tests/ai/<Name>Ai.spec.ts` - The test file (or `modules/<module>/tests/ai/<Name>Ai.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the AI class\n\nEdit `src/ai/<Name>Ai.ts` to complete the implementation:\n\n- Update the prompt in the `run` method from `"My prompt"` to a meaningful prompt based on the class purpose\n- Update the prompt in the `runStream` method from `"My prompt"` to a meaningful prompt based on the class purpose\n- Add any additional configuration or methods relevant to the AI class purpose\n- Ensure proper typing for the `run<T>()` generic return type\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { decorator, type IAiChat, OpenAi, type OpenAiConfigType } from "@ooneex/ai";\nimport { inject } from "@ooneex/container";\n\n@decorator.ai()\nexport class <Name>Ai implements IAiChat<OpenAiConfigType> {\n  constructor(@inject(OpenAi) private readonly ai: OpenAi) {}\n\n  public async run<T>(prompt?: string, config?: Omit<OpenAiConfigType, "prompt">): Promise<T> {\n    return this.ai.run<T>(prompt || "My prompt", config);\n  }\n\n  public async *runStream(\n    prompt?: string,\n    config?: Omit<OpenAiConfigType, "prompt" | "output">,\n  ): AsyncGenerator<string, void, unknown> {\n    yield* this.ai.runStream(prompt || "My prompt", config);\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/ai/<Name>Ai.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, run method, runStream method)\n- Add tests relevant to the specific AI class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from "bun:test";\nimport { <Name>Ai } from "@/ai/<Name>Ai";\n\ndescribe("<Name>Ai", () => {\n  test("should have class name ending with \'Ai\'", () => {\n    expect(<Name>Ai.name.endsWith("Ai")).toBe(true);\n  });\n\n  test("should have \'run\' method", () => {\n    expect(<Name>Ai.prototype.run).toBeDefined();\n    expect(typeof <Name>Ai.prototype.run).toBe("function");\n  });\n\n  test("should have \'runStream\' method", () => {\n    expect(<Name>Ai.prototype.runStream).toBeDefined();\n    expect(typeof <Name>Ai.prototype.runStream).toBe("function");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/ai/<Name>Ai.ts tests/ai/<Name>Ai.spec.ts\n```\n';
 
-@decorator.cache()
-export class {{NAME}}Cache implements ICache {
-  public async get<T = unknown>(key: string): Promise<T | undefined> {
-    throw new CacheException(\`Failed to get key "\${key}": Not implemented\`);
-  }
+// src/templates/claude/skills/make.analytics.md.txt
+var make_analytics_md_default = '---\nname: make:analytics\ndescription: Generate a new analytics class with its test file, then complete the generated code. Use when creating a new analytics tracking class that uses the @ooneex/analytics package.\n---\n\n# Make Analytics Class\n\nGenerate a new analytics class and its test file using the `make:analytics` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the analytics class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:analytics --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/analytics/<Name>Analytics.ts` - The analytics class file (or `modules/<module>/src/analytics/<Name>Analytics.ts` with `--module`)\n- `tests/analytics/<Name>Analytics.spec.ts` - The test file (or `modules/<module>/tests/analytics/<Name>Analytics.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the analytics class\n\nEdit `src/analytics/<Name>Analytics.ts` to complete the implementation:\n\n- Implement the `capture` method with actual analytics tracking logic\n- Define a proper type for `CaptureOptionsType` instead of `Record<string, unknown>` based on the analytics purpose\n- Add any additional methods or properties relevant to the analytics class purpose\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { type IAnalytics, decorator } from "@ooneex/analytics";\n\ntype CaptureOptionsType = Record<string, unknown>;\n\n@decorator.analytics()\nexport class <Name>Analytics<T extends CaptureOptionsType = CaptureOptionsType> implements IAnalytics<T> {\n  public capture(options: T): void {\n    // console.log("Analytics captured:", options);\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/analytics/<Name>Analytics.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, capture method)\n- Add tests relevant to the specific analytics class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from "bun:test";\nimport { <Name>Analytics } from "@/analytics/<Name>Analytics";\n\ndescribe("<Name>Analytics", () => {\n  test("should have class name ending with \'Analytics\'", () => {\n    expect(<Name>Analytics.name.endsWith("Analytics")).toBe(true);\n  });\n\n  test("should have \'capture\' method", () => {\n    expect(<Name>Analytics.prototype.capture).toBeDefined();\n    expect(typeof <Name>Analytics.prototype.capture).toBe("function");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/analytics/<Name>Analytics.ts tests/analytics/<Name>Analytics.spec.ts\n```\n';
 
-  public async set<T = unknown>(key: string, value: T, ttl?: number): Promise<void> {
-    throw new CacheException(\`Failed to set key "\${key}": Not implemented\`);
-  }
+// src/templates/claude/skills/make.cache.md.txt
+var make_cache_md_default = '---\nname: make:cache\ndescription: Generate a new cache adapter class with its test file, then complete the generated code. Use when creating a new cache adapter that implements the ICache interface from @ooneex/cache.\n---\n\n# Make Cache Class\n\nGenerate a new cache class and its test file using the `make:cache` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the cache class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:cache --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/cache/<Name>Cache.ts` - The cache class file (or `modules/<module>/src/cache/<Name>Cache.ts` with `--module`)\n- `tests/cache/<Name>Cache.spec.ts` - The test file (or `modules/<module>/tests/cache/<Name>Cache.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the cache class\n\nEdit `src/cache/<Name>Cache.ts` to complete the implementation:\n\n- Implement the `get` method to retrieve cached values by key\n- Implement the `set` method to store values with optional TTL\n- Implement the `delete` method to remove cached entries\n- Implement the `has` method to check key existence\n- Replace the `CacheException` throws with actual cache logic\n- Inject any required dependencies (e.g., Redis client) via the constructor\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { CacheException, type ICache, decorator } from "@ooneex/cache";\n\n@decorator.cache()\nexport class <Name>Cache implements ICache {\n  public async get<T = unknown>(key: string): Promise<T | undefined> {\n    throw new CacheException(`Failed to get key "${key}": Not implemented`);\n  }\n\n  public async set<T = unknown>(key: string, value: T, ttl?: number): Promise<void> {\n    throw new CacheException(`Failed to set key "${key}": Not implemented`);\n  }\n\n  public async delete(key: string): Promise<boolean> {\n    throw new CacheException(`Failed to delete key "${key}": Not implemented`);\n  }\n\n  public async has(key: string): Promise<boolean> {\n    throw new CacheException(`Failed to check if key "${key}" exists: Not implemented`);\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/cache/<Name>Cache.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, get, set, delete, has methods)\n- Add tests relevant to the specific cache class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from "bun:test";\nimport { <Name>Cache } from "@/cache/<Name>Cache";\n\ndescribe("<Name>Cache", () => {\n  test("should have class name ending with \'Cache\'", () => {\n    expect(<Name>Cache.name.endsWith("Cache")).toBe(true);\n  });\n\n  test("should have \'get\' method", () => {\n    expect(<Name>Cache.prototype.get).toBeDefined();\n    expect(typeof <Name>Cache.prototype.get).toBe("function");\n  });\n\n  test("should have \'set\' method", () => {\n    expect(<Name>Cache.prototype.set).toBeDefined();\n    expect(typeof <Name>Cache.prototype.set).toBe("function");\n  });\n\n  test("should have \'delete\' method", () => {\n    expect(<Name>Cache.prototype.delete).toBeDefined();\n    expect(typeof <Name>Cache.prototype.delete).toBe("function");\n  });\n\n  test("should have \'has\' method", () => {\n    expect(<Name>Cache.prototype.has).toBeDefined();\n    expect(typeof <Name>Cache.prototype.has).toBe("function");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/cache/<Name>Cache.ts tests/cache/<Name>Cache.spec.ts\n```\n';
 
-  public async delete(key: string): Promise<boolean> {
-    throw new CacheException(\`Failed to delete key "\${key}": Not implemented\`);
-  }
+// src/templates/claude/skills/make.controller.md.txt
+var make_controller_md_default = "---\nname: make:controller\ndescription: Generate a new controller class with route type and test file, then complete the generated code. Use when creating a new HTTP or WebSocket controller with routing, validation, and role-based access.\n---\n\n# Make Controller Class\n\nGenerate a new controller class, its route type, and test file using the `make:controller` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from \"@ooneex/container\";\nimport { decorator, type ISeed } from \"@ooneex/seeds\";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the controller class and related files:\n\n```bash\nbunx @ooneex/cli@latest make:controller --name=<name> --module=<module> --is-socket=<true|false> --route-name=<route.name> --route-path=<route.path> --route-method=<route.method>\n```\n\nWhere:\n- `<name>` is the controller name provided by the user\n- `--module` is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root\n- `--is-socket` determines HTTP vs WebSocket controller (defaults to `false`)\n- `--route-name` is the route name using dot notation: `<resource>.<action>` (e.g., `user.create`, `book.list`, `flashcard.delete`)\n- `--route-path` is the route path (e.g., `/api/users`)\n- `--route-method` is the HTTP method (e.g., `get`, `post`, `put`, `patch`, `delete`) \u2014 only for HTTP controllers\n\nThe command will generate (paths prefixed with `modules/<module>/` when `--module` is provided):\n- `src/controllers/<Name>Controller.ts` - The controller class file\n- `src/types/routes/<route.name>.ts` - The route type file (will be moved into the controller file \u2014 see step 3)\n- `tests/controllers/<Name>Controller.spec.ts` - The test file\n\n### 2. Read the generated files\n\nRead all three generated files to understand the scaffolded code.\n\n### 3. Complete the route type\n\n**IMPORTANT: Keep the route type inside the controller file**, not in a separate type file. Define the type directly in `src/controllers/<Name>Controller.ts` above the class definition. Delete the generated `src/types/routes/<route.name>.ts` file if it was created.\n\n**Remove unnecessary `params`, `payload`, and `queries` \u2014 only include what the route actually needs:**\n\n- **`params`** \u2014 Include only when the route path contains dynamic segments (e.g., `/api/users/:id`). Remove entirely for routes with no URL parameters (e.g., `/api/users`).\n- **`payload`** \u2014 Include only for methods that accept a request body (`post`, `put`, `patch`). Remove entirely for `get` and `delete` routes.\n- **`queries`** \u2014 Include only when the route supports query string filtering, pagination, or sorting (e.g., list/search endpoints). Remove entirely when not needed.\n- **`response`** \u2014 Always include.\n\nThe route type structure follows this pattern (remove unused sections):\n\n```typescript\n// Example: GET /api/users (list) \u2014 no params, no payload, has queries\ntype <TypeName>RouteType = {\n  queries: {\n\n  },\n  response: {\n\n  },\n};\n\n// Example: POST /api/users (create) \u2014 no params, has payload, no queries\ntype <TypeName>RouteType = {\n  payload: {\n\n  },\n  response: {\n\n  },\n};\n\n// Example: GET /api/users/:id (detail) \u2014 has params, no payload, no queries\ntype <TypeName>RouteType = {\n  params: {\n\n  },\n  response: {\n\n  },\n};\n\n// Example: PUT /api/users/:id (update) \u2014 has params, has payload, no queries\ntype <TypeName>RouteType = {\n  params: {\n\n  },\n  payload: {\n\n  },\n  response: {\n\n  },\n};\n```\n\n### 4. Complete the controller class\n\nEdit `src/controllers/<Name>Controller.ts` to complete the implementation:\n\n- Set appropriate `roles` for access control\n- Add a meaningful `description` for the route that explains what the endpoint does (e.g., `\"Create a new user account\"`, `\"List all books with pagination\"`)\n- **Keep the controller thin** \u2014 do NOT put business logic in the controller. Put all logic in the corresponding service and inject the service into the controller via the constructor. The controller's `index` method should only delegate to the service.\n- **Remove unnecessary `params`, `payload`, and `queries`** from both the route type and the `@Route` decorator \u2014 only include what the route actually needs (see step 3 rules).\n\n**Add or remove `params`, `payload`, and `queries` in the `@Route` decorator to match the route type (step 3):**\n\n- **`params`** \u2014 Include with `Assert()` validators only when the route has URL parameters. Remove the `params` key entirely otherwise.\n- **`payload`** \u2014 Include with `Assert({...})` only for `post`, `put`, `patch` methods. Remove the `payload` key entirely for `get` and `delete`.\n- **`queries`** \u2014 Include with `Assert({...})` only when query parameters are expected. Remove the `queries` key entirely otherwise.\n- **`response`** \u2014 Always include with `Assert({...})`.\n\n**HTTP controller** generated structure (remove `params`, `payload`, `queries` as needed \u2014 see rules above):\n\n```typescript\nimport type { ContextType } from \"@ooneex/controller\";\nimport { ERole } from \"@ooneex/role\";\nimport { Route } from \"@ooneex/routing\";\nimport { Assert } from \"@ooneex/validation\";\n\ntype <TypeName>RouteType = {\n  // Only include params, payload, queries as needed (see step 3)\n  response: {\n\n  },\n};\n\n@Route.<method>(\"<route.path>\", {\n  name: \"<route.name>\",\n  version: 1,\n  description: \"\",\n  // Only include params, payload, queries as needed (see step 3)\n  response: Assert({\n\n  }),\n  roles: [ERole.USER],\n})\nexport class <Name>Controller {\n  public async index(context: ContextType<<TypeName>RouteType>) {\n    return context.response.json({\n\n    });\n  }\n}\n```\n\n**Socket controller** generated structure (remove `params`, `payload`, `queries` as needed \u2014 see rules above):\n\n```typescript\nimport type { ContextType } from \"@ooneex/socket\";\nimport { ERole } from \"@ooneex/role\";\nimport { Route } from \"@ooneex/routing\";\nimport { Assert } from \"@ooneex/validation\";\n\ntype <TypeName>RouteType = {\n  // Only include params, payload, queries as needed (see step 3)\n  response: {\n\n  },\n};\n\n@Route.socket(\"<route.path>\", {\n  name: \"<route.name>\",\n  version: 1,\n  description: \"\",\n  // Only include params, payload, queries as needed (see step 3)\n  response: Assert({\n\n  }),\n  roles: [ERole.USER],\n})\nexport class <Name>Controller {\n  public async index(context: ContextType<<TypeName>RouteType>) {\n    return context.response.json({\n\n    });\n  }\n}\n```\n\n### 5. Complete the test file\n\nEdit `tests/controllers/<Name>Controller.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, index method)\n- Add tests relevant to the specific controller behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>Controller } from \"@/controllers/<Name>Controller\";\n\ndescribe(\"<Name>Controller\", () => {\n  test(\"should have class name ending with 'Controller'\", () => {\n    expect(<Name>Controller.name.endsWith(\"Controller\")).toBe(true);\n  });\n\n  test(\"should have 'index' method\", () => {\n    expect(<Name>Controller.prototype.index).toBeDefined();\n    expect(typeof <Name>Controller.prototype.index).toBe(\"function\");\n  });\n});\n```\n\n### 6. Register the controller in the module\n\nAdd the new controller to the module's `controllers` array in `src/<PascalModuleName>Module.ts` (e.g., `src/BookModule.ts` for the `book` module):\n\n```typescript\nimport type { ModuleType } from \"@ooneex/module\";\nimport { <Name>Controller } from \"./controllers/<Name>Controller\";\n\nexport const <PascalModuleName>Module: ModuleType = {\n  controllers: [<Name>Controller],\n  entities: [],\n  middlewares: [],\n  cronJobs: [],\n  events: [],\n};\n```\n\nThe module file uses PascalCase naming: `<PascalModuleName>Module.ts` with export `<PascalModuleName>Module`.\n\nIf the module already has other controllers registered, append the new controller to the existing `controllers` array and add the import alongside existing imports.\n\n### 7. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/controllers/<Name>Controller.ts tests/controllers/<Name>Controller.spec.ts\n```\n\n### 8. Create the service\n\nAfter the controller is created, generate a service class for the controller's business logic using the `make:service` skill:\n\n```\n/make:service --name=<Name>\n```\n\nWhere `<Name>` matches the controller name (e.g., if the controller is `CreateUserController`, the service is `CreateUserService`).\n\n### 9. Create the pubsub event\n\nAfter the service is created, generate a pubsub event class for the controller's domain events using the `make:pubsub` skill:\n\n```\n/make:pubsub --name=<Name> --channel=<resource>.<action>\n```\n\nWhere:\n- `<Name>` matches the controller name (e.g., if the controller is `CreateUserController`, the event is `CreateUserEvent`)\n- `<resource>.<action>` follows the same dot notation as the route name (e.g., `user.create`, `book.delete`)\n\nOnce the event is created:\n- Inject the **service** into the **event** via the constructor, and call the service's `execute` method from the event's `handler` method.\n- Inject the **event** into the **controller** via the constructor, and publish the event from the controller's `index` method.\n";
 
-  public async has(key: string): Promise<boolean> {
-    throw new CacheException(\`Failed to check if key "\${key}" exists: Not implemented\`);
+// src/templates/claude/skills/make.cron.md.txt
+var make_cron_md_default = '---\nname: make:cron\ndescription: Generate a new cron job class with its test file, then complete the generated code. Use when creating a new scheduled task that extends the Cron base class from @ooneex/cron.\n---\n\n# Make Cron Class\n\nGenerate a new cron class and its test file using the `make:cron` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the cron class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:cron --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/cron/<Name>Cron.ts` - The cron class file (or `modules/<module>/src/cron/<Name>Cron.ts` with `--module`)\n- `tests/cron/<Name>Cron.spec.ts` - The test file (or `modules/<module>/tests/cron/<Name>Cron.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the cron class\n\nEdit `src/cron/<Name>Cron.ts` to complete the implementation:\n\n- Set the appropriate cron schedule in `getTime()` (e.g., `"every 5 minutes"`, `"every 1 hours"`, `"every 30 seconds"`)\n- Set the timezone in `getTimeZone()` if needed, or keep `null` for server timezone\n- Implement the `handler()` method with the actual cron job logic\n- Inject any required dependencies via the constructor\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport type { TimeZoneType } from "@ooneex/country";\nimport { Cron, type CronTimeType, decorator } from "@ooneex/cron";\n\n@decorator.cron()\nexport class <Name>Cron extends Cron {\n  public getTime(): CronTimeType {\n    // Examples: "every 5 minutes", "every 1 hours", "every 30 seconds"\n    return "every 1 hours";\n  }\n\n  public getTimeZone(): TimeZoneType | null {\n    // Return null to use server timezone, or specify a timezone like "Europe/Paris"\n    return null;\n  }\n\n  public async handler(): Promise<void> {\n    // Implement your cron handler logic here\n    // console.log("<Name>Cron handler executed");\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/cron/<Name>Cron.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, getTime, getTimeZone, handler methods)\n- Add tests relevant to the specific cron class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from "bun:test";\nimport { <Name>Cron } from "@/cron/<Name>Cron";\n\ndescribe("<Name>Cron", () => {\n  test("should have class name ending with \'Cron\'", () => {\n    expect(<Name>Cron.name.endsWith("Cron")).toBe(true);\n  });\n\n  test("should have \'getTime\' method", () => {\n    expect(<Name>Cron.prototype.getTime).toBeDefined();\n    expect(typeof <Name>Cron.prototype.getTime).toBe("function");\n  });\n\n  test("should have \'getTimeZone\' method", () => {\n    expect(<Name>Cron.prototype.getTimeZone).toBeDefined();\n    expect(typeof <Name>Cron.prototype.getTimeZone).toBe("function");\n  });\n\n  test("should have \'handler\' method", () => {\n    expect(<Name>Cron.prototype.handler).toBeDefined();\n    expect(typeof <Name>Cron.prototype.handler).toBe("function");\n  });\n});\n```\n\n### 5. Register the cron job in the module\n\nAdd the new cron job to the module\'s `cronJobs` array in `src/<PascalModuleName>Module.ts` (e.g., `src/BookModule.ts` for the `book` module):\n\n```typescript\nimport type { ModuleType } from "@ooneex/module";\nimport { <Name>Cron } from "./cron/<Name>Cron";\n\nexport const <PascalModuleName>Module: ModuleType = {\n  controllers: [],\n  entities: [],\n  middlewares: [],\n  cronJobs: [<Name>Cron],\n  events: [],\n};\n```\n\nThe module file uses PascalCase naming: `<PascalModuleName>Module.ts` with export `<PascalModuleName>Module`.\n\nIf the module already has other cron jobs registered, append the new cron job to the existing `cronJobs` array and add the import alongside existing imports.\n\n### 6. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/cron/<Name>Cron.ts tests/cron/<Name>Cron.spec.ts\n```\n';
+
+// src/templates/claude/skills/make.database.md.txt
+var make_database_md_default = '---\nname: make:database\ndescription: Generate a new database class with its test file, then complete the generated code. Use when creating a new database adapter that extends TypeormDatabase from @ooneex/database.\n---\n\n# Make Database Class\n\nGenerate a new database class and its test file using the `make:database` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the database class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:database --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/databases/<Name>Database.ts` - The database class file (or `modules/<module>/src/databases/<Name>Database.ts` with `--module`)\n- `tests/databases/<Name>Database.spec.ts` - The test file (or `modules/<module>/tests/databases/<Name>Database.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the database class\n\nEdit `src/databases/<Name>Database.ts` to complete the implementation:\n\n- Add entity imports and register them in the `entities` array\n- Adjust the database path if needed (default is `"var/db"`)\n- Configure DataSource options as appropriate (type, synchronize, etc.)\n- Inject any required dependencies via the constructor\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { DataSource } from "typeorm";\nimport { TypeormDatabase, DatabaseException, decorator } from "@ooneex/database";\n\n@decorator.database()\nexport class <Name>Database extends TypeormDatabase {\n  public getSource(database?: string): DataSource {\n    database = database || "var/db";\n\n    this.source = new DataSource({\n      synchronize: false,\n      entities: [\n        // TODO: Load your entities here\n      ],\n      enableWAL: true,\n      busyErrorRetry: 2000,\n      busyTimeout: 30_000,\n      database,\n      type: "sqlite",\n    });\n\n    return this.source;\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/databases/<Name>Database.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, getSource method)\n- Add tests relevant to the specific database class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from "bun:test";\nimport { <Name>Database } from "@/databases/<Name>Database";\n\ndescribe("<Name>Database", () => {\n  test("should have class name ending with \'Database\'", () => {\n    expect(<Name>Database.name.endsWith("Database")).toBe(true);\n  });\n\n  test("should have \'getSource\' method", () => {\n    expect(<Name>Database.prototype.getSource).toBeDefined();\n    expect(typeof <Name>Database.prototype.getSource).toBe("function");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/databases/<Name>Database.ts tests/databases/<Name>Database.spec.ts\n```\n';
+
+// src/templates/claude/skills/make.entity.md.txt
+var make_entity_md_default = "---\nname: make:entity\ndescription: Generate a new TypeORM entity class with its test file, then complete the generated code. Use when creating a new database entity with columns, relations, and table mapping.\n---\n\n# Make Entity Class\n\nGenerate a new entity class and its test file using the `make:entity` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- Avoid non-null assertions (`!`). For example, `public name!: string;` should be `public name: string;`\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from \"@ooneex/container\";\nimport { decorator, type ISeed } from \"@ooneex/seeds\";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the entity class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:entity --name=<name> --module=<module> --table-name=<table_name>\n```\n\nWhere `<name>` is the name provided by the user. The `--table-name` option is optional \u2014 if omitted, it defaults to the snake_case pluralized form of the name (e.g., `UserProfile` becomes `user_profiles`). The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/entities/<Name>Entity.ts` - The entity class file (or `modules/<module>/src/entities/<Name>Entity.ts` with `--module`)\n- `tests/entities/<Name>Entity.spec.ts` - The test file (or `modules/<module>/tests/entities/<Name>Entity.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the entity class\n\nEdit `src/entities/<Name>Entity.ts` to complete the implementation:\n\n- Add entity-specific columns with appropriate TypeORM decorators (`@Column`)\n- Add relations if needed (`@ManyToOne`, `@OneToMany`, `@ManyToMany`, etc.)\n- Remove any scaffolded columns that are not relevant to the entity\n- Adjust column types, lengths, and constraints as needed\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport type { LocaleType } from \"@ooneex/translation\";\nimport { random } from \"@ooneex/utils\";\nimport { Column, CreateDateColumn, DeleteDateColumn, PrimaryColumn, UpdateDateColumn } from \"typeorm\";\n\n@Entity({\n  name: \"<table_name>\",\n})\nexport class <Name>Entity extends BaseEntity {\n  @PrimaryColumn({ name: \"id\", type: \"varchar\", length: 25 })\n  id: string = random.nanoid(25);\n\n  @Column({\n    name: \"is_locked\",\n    type: \"boolean\",\n    default: false,\n    nullable: true,\n  })\n  isLocked?: boolean;\n\n  @Column({ name: \"locked_at\", type: \"timestamptz\", nullable: true })\n  lockedAt?: Date;\n\n  @Column({\n    name: \"is_blocked\",\n    type: \"boolean\",\n    default: false,\n    nullable: true,\n  })\n  isBlocked?: boolean;\n\n  @Column({ name: \"blocked_at\", type: \"timestamptz\", nullable: true })\n  blockedAt?: Date;\n\n  @Column({ name: \"block_reason\", type: \"text\", nullable: true })\n  blockReason?: string;\n\n  @Column({ name: \"is_public\", type: \"boolean\", default: true, nullable: true })\n  isPublic?: boolean;\n\n  @Column({ name: \"lang\", type: \"varchar\", length: 10, nullable: true })\n  lang?: LocaleType;\n\n  @CreateDateColumn({ name: \"created_at\" })\n  createdAt?: Date;\n\n  @UpdateDateColumn({ name: \"updated_at\" })\n  updatedAt?: Date;\n\n  @DeleteDateColumn({ name: \"deleted_at\" })\n  deletedAt?: Date;\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/entities/<Name>Entity.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, id, default columns)\n- Add tests for any new entity-specific columns and relations\n- Update tests if scaffolded columns were removed\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>Entity } from \"@/entities/<Name>Entity\";\n\ndescribe(\"<Name>Entity\", () => {\n  test(\"should have class name ending with 'Entity'\", () => {\n    expect(<Name>Entity.name.endsWith(\"Entity\")).toBe(true);\n  });\n\n  test(\"should have 'id' property with default nanoid\", () => {\n    const entity = new <Name>Entity();\n    expect(entity.id).toBeDefined();\n    expect(typeof entity.id).toBe(\"string\");\n    expect(entity.id.length).toBe(25);\n  });\n\n  test(\"should have 'isLocked' property\", () => {\n    const entity = new <Name>Entity();\n    expect(\"isLocked\" in entity).toBe(true);\n  });\n\n  // ... additional property tests\n});\n```\n\n### 5. Register the entity in the module\n\nAdd the new entity to the module's `entities` array in `src/<PascalModuleName>Module.ts` (e.g., `src/BookModule.ts` for the `book` module):\n\n```typescript\nimport type { ModuleType } from \"@ooneex/module\";\nimport { <Name>Entity } from \"./entities/<Name>Entity\";\n\nexport const <PascalModuleName>Module: ModuleType = {\n  controllers: [],\n  entities: [<Name>Entity],\n  middlewares: [],\n  cronJobs: [],\n  events: [],\n};\n```\n\nThe module file uses PascalCase naming: `<PascalModuleName>Module.ts` with export `<PascalModuleName>Module`.\n\nIf the module already has other entities registered, append the new entity to the existing `entities` array and add the import alongside existing imports.\n\n### 6. Create a migration for the entity\n\nAfter creating or updating an entity, generate a migration to apply the corresponding schema changes to the database.\n\nRun the generator:\n\n```bash\nbunx @ooneex/cli@latest make:migration\n```\n\nThen read the generated migration file in `src/migrations/` and complete it:\n\n- In the `up` method, write the SQL to create the table (or alter it if updating an existing entity). Include all columns, types, constraints, defaults, and indexes matching the entity definition.\n- In the `down` method, write the reverse SQL to undo the changes (e.g., `DROP TABLE` or `ALTER TABLE DROP COLUMN`).\n- If the migration depends on another migration (e.g., a foreign key referencing another table), add that migration class to the `getDependencies()` return array.\n\nExample `up` method for a new entity:\n\n```typescript\npublic async up(tx: TransactionSQL): Promise<void> {\n  await tx`\n    CREATE TABLE IF NOT EXISTS <table_name> (\n      id VARCHAR(25) PRIMARY KEY,\n      is_locked BOOLEAN DEFAULT false,\n      locked_at TIMESTAMPTZ,\n      is_blocked BOOLEAN DEFAULT false,\n      blocked_at TIMESTAMPTZ,\n      block_reason TEXT,\n      is_public BOOLEAN DEFAULT true,\n      lang VARCHAR(10),\n      created_at TIMESTAMPTZ DEFAULT NOW(),\n      updated_at TIMESTAMPTZ DEFAULT NOW(),\n      deleted_at TIMESTAMPTZ\n    )\n  `;\n}\n```\n\n### 7. Create a repository for the entity\n\nAfter creating the entity, generate a repository to handle database operations for it.\n\nRun the generator:\n\n```bash\nbunx @ooneex/cli@latest make:repository --name=<name>\n```\n\nWhere `<name>` is the same name used for the entity. The command will generate:\n- `src/repositories/<Name>Repository.ts` - The repository class\n- `tests/repositories/<Name>Repository.spec.ts` - The test file\n\nThen read the generated files and complete the repository implementation:\n\n- Adjust search fields in the `find()` method to match the entity's searchable columns\n- Customize relations loading in `findOne`/`findOneBy` if the entity has relations\n- Add any domain-specific methods relevant to the entity\n- Remove methods that don't apply to the entity\n- Update tests to match the final repository methods\n\n### 8. Lint and format\n\nRun linting and formatting on all generated files:\n\n```bash\nbunx biome check --fix src/entities/<Name>Entity.ts tests/entities/<Name>Entity.spec.ts src/repositories/<Name>Repository.ts tests/repositories/<Name>Repository.spec.ts src/migrations/\n```\n";
+
+// src/templates/claude/skills/make.logger.md.txt
+var make_logger_md_default = '---\nname: make:logger\ndescription: Generate a new logger class with its test file, then complete the generated code. Use when creating a new logger that implements the ILogger interface from @ooneex/logger.\n---\n\n# Make Logger Class\n\nGenerate a new logger class and its test file using the `make:logger` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the logger class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:logger --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/loggers/<Name>Logger.ts` - The logger class file (or `modules/<module>/src/loggers/<Name>Logger.ts` with `--module`)\n- `tests/loggers/<Name>Logger.spec.ts` - The test file (or `modules/<module>/tests/loggers/<Name>Logger.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the logger class\n\nEdit `src/loggers/<Name>Logger.ts` to complete the implementation:\n\n- Implement the `init()` method to set up the logger (e.g., open file handles, configure transports)\n- Implement `log`, `debug`, `info`, `success`, `warn`, and `error` methods with actual logging logic\n- Inject any required dependencies via the constructor\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport type { IException } from "@ooneex/exception";\nimport { type ILogger, decorator } from "@ooneex/logger";\nimport type { ScalarType } from "@ooneex/types";\n\n@decorator.logger()\nexport class <Name>Logger implements ILogger {\n  public async init(): Promise<void> {\n    // Initialize your logger here\n  }\n\n  public log(message: string, data?: Record<string, ScalarType>): void {\n    // Handle general logging\n  }\n\n  public debug(message: string, data?: Record<string, ScalarType>): void {\n    // Handle debug logging\n  }\n\n  public info(message: string, data?: Record<string, ScalarType>): void {\n    // Handle info logging\n  }\n\n  public success(message: string, data?: Record<string, ScalarType>): void {\n    // Handle success logging\n  }\n\n  public warn(message: string, data?: Record<string, ScalarType>): void {\n    // Handle warning logging\n  }\n\n  public error(message: string | IException, data?: Record<string, ScalarType>): void {\n    // Handle error logging\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/loggers/<Name>Logger.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, init, log, debug, info, success, warn, error methods)\n- Add tests relevant to the specific logger class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from "bun:test";\nimport { <Name>Logger } from "@/loggers/<Name>Logger";\n\ndescribe("<Name>Logger", () => {\n  test("should have class name ending with \'Logger\'", () => {\n    expect(<Name>Logger.name.endsWith("Logger")).toBe(true);\n  });\n\n  test("should have \'init\' method", () => {\n    expect(<Name>Logger.prototype.init).toBeDefined();\n    expect(typeof <Name>Logger.prototype.init).toBe("function");\n  });\n\n  test("should have \'log\' method", () => {\n    expect(<Name>Logger.prototype.log).toBeDefined();\n    expect(typeof <Name>Logger.prototype.log).toBe("function");\n  });\n\n  test("should have \'debug\' method", () => {\n    expect(<Name>Logger.prototype.debug).toBeDefined();\n    expect(typeof <Name>Logger.prototype.debug).toBe("function");\n  });\n\n  test("should have \'info\' method", () => {\n    expect(<Name>Logger.prototype.info).toBeDefined();\n    expect(typeof <Name>Logger.prototype.info).toBe("function");\n  });\n\n  test("should have \'success\' method", () => {\n    expect(<Name>Logger.prototype.success).toBeDefined();\n    expect(typeof <Name>Logger.prototype.success).toBe("function");\n  });\n\n  test("should have \'warn\' method", () => {\n    expect(<Name>Logger.prototype.warn).toBeDefined();\n    expect(typeof <Name>Logger.prototype.warn).toBe("function");\n  });\n\n  test("should have \'error\' method", () => {\n    expect(<Name>Logger.prototype.error).toBeDefined();\n    expect(typeof <Name>Logger.prototype.error).toBe("function");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/loggers/<Name>Logger.ts tests/loggers/<Name>Logger.spec.ts\n```\n';
+
+// src/templates/claude/skills/make.mailer.md.txt
+var make_mailer_md_default = '---\nname: make:mailer\ndescription: Generate a new mailer class with its template and test files, then complete the generated code. Use when creating a new email sender with JSX template using @ooneex/mailer.\n---\n\n# Make Mailer Class\n\nGenerate a new mailer class, its JSX template, and test files using the `make:mailer` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the mailer class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:mailer --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate (paths prefixed with `modules/<module>/` when `--module` is provided):\n- `src/mailers/<Name>Mailer.ts` - The mailer class file\n- `src/mailers/<Name>MailerTemplate.tsx` - The JSX email template\n- `tests/mailers/<Name>Mailer.spec.ts` - The mailer test file\n- `tests/mailers/<Name>MailerTemplate.spec.ts` - The template test file\n\n### 2. Read the generated files\n\nRead all four generated files to understand the scaffolded code.\n\n### 3. Complete the mailer class\n\nEdit `src/mailers/<Name>Mailer.ts` to complete the implementation:\n\n- Adjust the `send` method config type if additional parameters are needed\n- Add any pre-send logic (validation, data transformation, etc.)\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport type { IMailer } from "@ooneex/mailer";\nimport { type <Name>MailerPropsType, <Name>MailerTemplate } from "./<Name>MailerTemplate";\n\nexport class <Name>Mailer implements IMailer {\n  constructor(\n    @inject("mailer")\n    private readonly mailer: IMailer,\n  ) {}\n\n  public send = async (config: {\n    to: string[];\n    subject: string;\n    from?: { name: string; address: string };\n    data?: <Name>MailerPropsType;\n  }): Promise<void> => {\n    const { data, ...rest } = config;\n\n    await this.mailer.send({\n      ...rest,\n      content: <Name>MailerTemplate(data),\n    });\n  };\n}\n```\n\n### 4. Complete the mailer template\n\nEdit `src/mailers/<Name>MailerTemplate.tsx` to complete the implementation:\n\n- Update `<Name>MailerPropsType` with the actual props needed for the email\n- Build the email body using `MailerLayout` components (Header, Body, Footer)\n- Add email content, styling, and dynamic data rendering\n\nThe generated template structure follows this pattern:\n\n```tsx\nimport { MailerLayout } from "@ooneex/mailer";\n\nexport type <Name>MailerPropsType = {\n  link: string;\n};\n\nexport const <Name>MailerTemplate = (props?: <Name>MailerPropsType) => (\n  <MailerLayout>\n    <MailerLayout.Header />\n    <MailerLayout.Body>\n      <a href={props?.link}>Login</a>\n    </MailerLayout.Body>\n    <MailerLayout.Footer />\n  </MailerLayout>\n);\n```\n\n### 5. Complete the test files\n\nEdit `tests/mailers/<Name>Mailer.spec.ts` and `tests/mailers/<Name>MailerTemplate.spec.ts` to add meaningful tests beyond the scaffolded ones.\n\n### 6. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/mailers/<Name>Mailer.ts src/mailers/<Name>MailerTemplate.tsx tests/mailers/<Name>Mailer.spec.ts tests/mailers/<Name>MailerTemplate.spec.ts\n```\n';
+
+// src/templates/claude/skills/make.middleware.md.txt
+var make_middleware_md_default = '---\nname: make:middleware\ndescription: Generate a new middleware class with its test file, then complete the generated code. Use when creating a new HTTP or WebSocket middleware that implements IMiddleware from @ooneex/middleware.\n---\n\n# Make Middleware Class\n\nGenerate a new middleware class and its test file using the `make:middleware` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the middleware class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:middleware --name=<name> --module=<module> --is-socket=<true|false>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The `--is-socket` option determines whether to generate an HTTP middleware or a WebSocket middleware (defaults to `false` if omitted). The command will generate:\n- `src/middlewares/<Name>Middleware.ts` - The middleware class file (or `modules/<module>/src/middlewares/<Name>Middleware.ts` with `--module`)\n- `tests/middlewares/<Name>Middleware.spec.ts` - The test file (or `modules/<module>/tests/middlewares/<Name>Middleware.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the middleware class\n\nEdit `src/middlewares/<Name>Middleware.ts` to complete the implementation:\n\n- Implement the `handler` method with actual middleware logic\n- Add request/response transformations, authentication checks, logging, etc.\n- Inject any required dependencies via the constructor\n\n**HTTP middleware** generated structure:\n\n```typescript\nimport type { ContextType } from "@ooneex/controller";\nimport { decorator, type IMiddleware } from "@ooneex/middleware";\n\n@decorator.middleware()\nexport class <Name>Middleware implements IMiddleware {\n  public async handler(context: ContextType): Promise<ContextType> {\n    // Example: Add custom header\n    // context.response.header("X-Custom-Header", "value");\n\n    return context\n  }\n}\n```\n\n**Socket middleware** generated structure:\n\n```typescript\nimport type { ContextType } from "@ooneex/socket";\nimport { decorator, type IMiddleware } from "@ooneex/middleware";\n\n@decorator.middleware()\nexport class <Name>Middleware implements IMiddleware {\n  public async handler(context: ContextType): Promise<ContextType> {\n    // Example: Add custom header\n    // context.response.header("X-Custom-Header", "value");\n\n    return context\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/middlewares/<Name>Middleware.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, handler method)\n- Add tests relevant to the specific middleware behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from "bun:test";\nimport { <Name>Middleware } from "@/middlewares/<Name>Middleware";\n\ndescribe("<Name>Middleware", () => {\n  test("should have class name ending with \'Middleware\'", () => {\n    expect(<Name>Middleware.name.endsWith("Middleware")).toBe(true);\n  });\n\n  test("should have \'handler\' method", () => {\n    expect(<Name>Middleware.prototype.handler).toBeDefined();\n    expect(typeof <Name>Middleware.prototype.handler).toBe("function");\n  });\n});\n```\n\n### 5. Register the middleware in the module\n\nAdd the new middleware to the module\'s `middlewares` array in `src/<PascalModuleName>Module.ts` (e.g., `src/BookModule.ts` for the `book` module):\n\n```typescript\nimport type { ModuleType } from "@ooneex/module";\nimport { <Name>Middleware } from "./middlewares/<Name>Middleware";\n\nexport const <PascalModuleName>Module: ModuleType = {\n  controllers: [],\n  entities: [],\n  middlewares: [<Name>Middleware],\n  cronJobs: [],\n  events: [],\n};\n```\n\nThe module file uses PascalCase naming: `<PascalModuleName>Module.ts` with export `<PascalModuleName>Module`.\n\nIf the module already has other middlewares registered, append the new middleware to the existing `middlewares` array and add the import alongside existing imports.\n\n### 6. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/middlewares/<Name>Middleware.ts tests/middlewares/<Name>Middleware.spec.ts\n```\n';
+
+// src/templates/claude/skills/make.migration.md.txt
+var make_migration_md_default = '---\nname: make:migration\ndescription: Generate a new database migration file with its test file, then complete the generated code. Use when creating a new database migration for schema changes using @ooneex/migrations.\n---\n\n# Make Migration\n\nGenerate a new migration file and its test file using the `make:migration` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the migration file and test files:\n\n```bash\nbunx @ooneex/cli@latest make:migration --module=<module>\n```\n\nThe `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/migrations/Migration<version>.ts` - The migration class file (or `modules/<module>/src/migrations/Migration<version>.ts` with `--module`)\n- `tests/migrations/Migration<version>.spec.ts` - The test file (or `modules/<module>/tests/migrations/Migration<version>.spec.ts` with `--module`)\n\nIt will also:\n- Generate a `migrations.ts` root export file in the migrations directory\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the migration\n\nEdit `src/migrations/Migration<version>.ts` to implement:\n\n- The `up` method with the schema changes (create tables, add columns, create indexes, etc.)\n- The `down` method with the reverse operations to undo the migration\n\n### 4. Complete the test file\n\nEdit `tests/migrations/Migration<version>.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, up, down, getVersion, getDependencies methods)\n- Add tests relevant to the specific migration behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from "bun:test";\nimport { Migration<version> } from "@/migrations/Migration<version>";\n\ndescribe("Migration<version>", () => {\n  test("should have class name starting with \'Migration\'", () => {\n    expect(Migration<version>.name.startsWith("Migration")).toBe(true);\n  });\n\n  test("should have \'up\' method", () => {\n    expect(Migration<version>.prototype.up).toBeDefined();\n    expect(typeof Migration<version>.prototype.up).toBe("function");\n  });\n\n  test("should have \'down\' method", () => {\n    expect(Migration<version>.prototype.down).toBeDefined();\n    expect(typeof Migration<version>.prototype.down).toBe("function");\n  });\n\n  test("should have \'getVersion\' method", () => {\n    expect(Migration<version>.prototype.getVersion).toBeDefined();\n    expect(typeof Migration<version>.prototype.getVersion).toBe("function");\n  });\n\n  test("should have \'getDependencies\' method", () => {\n    expect(Migration<version>.prototype.getDependencies).toBeDefined();\n    expect(typeof Migration<version>.prototype.getDependencies).toBe("function");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/migrations/Migration<version>.ts tests/migrations/Migration<version>.spec.ts\n```\n';
+
+// src/templates/claude/skills/make.permission.md.txt
+var make_permission_md_default = '---\nname: make:permission\ndescription: Generate a new permission class with its test file, then complete the generated code. Use when creating a new permission that extends Permission from @ooneex/permission.\n---\n\n# Make Permission Class\n\nGenerate a new permission class and its test file using the `make:permission` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the permission class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:permission --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/permissions/<Name>Permission.ts` - The permission class file (or `modules/<module>/src/permissions/<Name>Permission.ts` with `--module`)\n- `tests/permissions/<Name>Permission.spec.ts` - The test file (or `modules/<module>/tests/permissions/<Name>Permission.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the permission class\n\nEdit `src/permissions/<Name>Permission.ts` to complete the implementation:\n\n- Implement the `allow()` method with permission rules using `this.ability.can()`\n- Implement the `setUserPermissions()` method with role-based permission logic\n- Define which actions (read, create, update, delete, manage) are allowed on which entities\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { decorator, Permission } from "@ooneex/permission";\nimport type { IUser } from "@ooneex/user";\n\n@decorator.permission()\nexport class <Name>Permission extends Permission {\n  public allow(): this {\n    // Example: Add permissions using this.ability.can()\n    // this.ability.can("read", "YourEntity");\n    // this.ability.can(["read", "update"], "YourEntity", { userId: user.id });\n\n    return this;\n  }\n\n  public setUserPermissions(user: IUser | null): this {\n    if (!user) {\n      return this;\n    }\n\n    // Example: Grant full access to admins\n    // const { roles } = user;\n    // if (roles.includes(ERole.ADMIN)) {\n    //   this.ability.can("manage", "all");\n    //   return this;\n    // }\n\n    // Example: Grant specific permissions based on roles\n    // for (const role of roles) {\n    //   if (role === ERole.USER) {\n    //     this.ability.can(["read", "update"], "YourEntity", { userId: user.id });\n    //   }\n    //\n    //   if (role === ERole.GUEST) {\n    //     this.ability.can("read", "YourEntity", { public: true });\n    //   }\n    // }\n\n    return this;\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/permissions/<Name>Permission.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, extends Permission, allow, setUserPermissions methods)\n- Add tests relevant to the specific permission rules\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from "bun:test";\nimport { Permission } from "@ooneex/permission";\nimport { <Name>Permission } from "@/permissions/<Name>Permission";\n\ndescribe("<Name>Permission", () => {\n  test("should have class name ending with \'Permission\'", () => {\n    expect(<Name>Permission.name.endsWith("Permission")).toBe(true);\n  });\n\n  test("should extend Permission", () => {\n    const permission = new <Name>Permission();\n    expect(permission).toBeInstanceOf(Permission);\n  });\n\n  test("should have \'allow\' method", () => {\n    expect(<Name>Permission.prototype.allow).toBeDefined();\n    expect(typeof <Name>Permission.prototype.allow).toBe("function");\n  });\n\n  test("should have \'setUserPermissions\' method", () => {\n    expect(<Name>Permission.prototype.setUserPermissions).toBeDefined();\n    expect(typeof <Name>Permission.prototype.setUserPermissions).toBe("function");\n  });\n});\n```\n\n### 5. Register the permission in the module\n\nThe permission class is standalone and does not need to be registered in a module.\n\n### 6. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/permissions/<Name>Permission.ts tests/permissions/<Name>Permission.spec.ts\n```\n';
+
+// src/templates/claude/skills/make.pubsub.md.txt
+var make_pubsub_md_default = '---\nname: make:pubsub\ndescription: Generate a new PubSub event class with its test file, then complete the generated code. Use when creating a new publish/subscribe event that extends PubSub from @ooneex/pub-sub.\n---\n\n# Make PubSub Event Class\n\nGenerate a new PubSub event class and its test file using the `make:pubsub` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the PubSub event class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:pubsub --name=<name> --module=<module> --channel=<channel>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The `--channel` option is optional \u2014 if omitted, it defaults to the kebab-case form of the name (e.g., `UserCreated` becomes `user-created`). The command will generate:\n- `src/events/<Name>Event.ts` - The event class file (or `modules/<module>/src/events/<Name>Event.ts` with `--module`)\n- `tests/events/<Name>Event.spec.ts` - The test file (or `modules/<module>/tests/events/<Name>Event.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the PubSub event class\n\nEdit `src/events/<Name>Event.ts` to complete the implementation:\n\n- Define a proper data type instead of `Record<string, ScalarType>` for the event payload\n- Implement the `handler()` method with actual event handling logic\n- Set the appropriate channel name in `getChannel()`\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport type { ScalarType } from "@ooneex/types";\nimport { decorator, PubSub, RedisPubSub } from "@ooneex/pub-sub";\n\n@decorator.pubSub()\nexport class <Name>Event<Data extends Record<string, ScalarType> = Record<string, ScalarType>> extends PubSub<Data> {\n  constructor(\n    @inject(RedisPubSub)\n    client: RedisPubSub<Data>,\n  ) {\n    super(client);\n  }\n\n  public getChannel(): string {\n    return "<channel>";\n  }\n\n  public async handler(context: { data: Data; channel: string }): Promise<void> {\n    console.log(context);\n    // TODO: Implement handler logic here\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/events/<Name>Event.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, getChannel, handler, publish, subscribe, unsubscribe, unsubscribeAll methods)\n- Add tests relevant to the specific event behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from "bun:test";\nimport { <Name>PubSub } from "@/pubsub/<Name>PubSub";\n\ndescribe("<Name>PubSub", () => {\n  test("should have class name ending with \'PubSub\'", () => {\n    expect(<Name>PubSub.name.endsWith("PubSub")).toBe(true);\n  });\n\n  test("should have \'getChannel\' method", () => {\n    expect(<Name>PubSub.prototype.getChannel).toBeDefined();\n    expect(typeof <Name>PubSub.prototype.getChannel).toBe("function");\n  });\n\n  test("should have \'handler\' method", () => {\n    expect(<Name>PubSub.prototype.handler).toBeDefined();\n    expect(typeof <Name>PubSub.prototype.handler).toBe("function");\n  });\n\n  test("should have \'publish\' method", () => {\n    expect(<Name>PubSub.prototype.publish).toBeDefined();\n    expect(typeof <Name>PubSub.prototype.publish).toBe("function");\n  });\n\n  test("should have \'subscribe\' method", () => {\n    expect(<Name>PubSub.prototype.subscribe).toBeDefined();\n    expect(typeof <Name>PubSub.prototype.subscribe).toBe("function");\n  });\n\n  test("should have \'unsubscribe\' method", () => {\n    expect(<Name>PubSub.prototype.unsubscribe).toBeDefined();\n    expect(typeof <Name>PubSub.prototype.unsubscribe).toBe("function");\n  });\n\n  test("should have \'unsubscribeAll\' method", () => {\n    expect(<Name>PubSub.prototype.unsubscribeAll).toBeDefined();\n    expect(typeof <Name>PubSub.prototype.unsubscribeAll).toBe("function");\n  });\n});\n```\n\n### 5. Register the event in the module\n\nAdd the new event to the module\'s `events` array in `src/<PascalModuleName>Module.ts` (e.g., `src/BookModule.ts` for the `book` module):\n\n```typescript\nimport type { ModuleType } from "@ooneex/module";\nimport { <Name>Event } from "./events/<Name>Event";\n\nexport const <PascalModuleName>Module: ModuleType = {\n  controllers: [],\n  entities: [],\n  middlewares: [],\n  cronJobs: [],\n  events: [<Name>Event],\n};\n```\n\nThe module file uses PascalCase naming: `<PascalModuleName>Module.ts` with export `<PascalModuleName>Module`.\n\nIf the module already has other events registered, append the new event to the existing `events` array and add the import alongside existing imports.\n\n### 6. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/events/<Name>Event.ts tests/events/<Name>Event.spec.ts\n```\n';
+
+// src/templates/claude/skills/make.repository.md.txt
+var make_repository_md_default = '---\nname: make:repository\ndescription: Generate a new repository class with its test file, then complete the generated code. Use when creating a new TypeORM repository for database operations on an entity.\n---\n\n# Make Repository Class\n\nGenerate a new repository class and its test file using the `make:repository` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the repository class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:repository --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/repositories/<Name>Repository.ts` - The repository class file (or `modules/<module>/src/repositories/<Name>Repository.ts` with `--module`)\n- `tests/repositories/<Name>Repository.spec.ts` - The test file (or `modules/<module>/tests/repositories/<Name>Repository.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the repository class\n\nEdit `src/repositories/<Name>Repository.ts` to complete the implementation:\n\n- Verify the entity import path matches the actual entity location\n- Adjust the `find` method\'s search fields (default searches `name` with `ILike`)\n- Customize relations loading in `findOne`/`findOneBy` if needed\n\n#### Adding methods\n\nLook at the entity\'s fields, relations, and business context to determine if custom domain-specific methods are needed. For example:\n- A `SessionRepository` might need `revokeSession(sessionId: string)` and `revokeAllUserSessions(userId: string)`\n- A `NotificationRepository` might need `markAsRead(id: string)` and `markAllAsRead(userId: string)`\n- Entities with status fields may need methods like `archive(id: string)` or `activate(id: string)`\n\nRead related entities, services, or actions in the module to understand what operations the repository should support, then add the appropriate methods.\n\n#### Removing methods\n\nRemove scaffolded methods that don\'t make sense for the entity\'s context:\n- Remove `createMany`/`updateMany` if the entity is always managed individually (e.g., user profiles, settings)\n- Remove `delete` if the entity uses soft deletes only (use a custom `softDelete` or `archive` method instead)\n- Remove `find` if the entity is only ever accessed by ID or specific criteria (e.g., singleton config entities)\n- Remove `count` if there\'s no use case for counting records of this entity\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport type { ITypeormDatabase } from "@ooneex/database";\nimport { decorator } from "@ooneex/repository";\nimport type { FilterResultType } from "@ooneex/types";\nimport type { FindManyOptions, FindOptionsWhere, Repository, SaveOptions, UpdateResult } from "typeorm";\nimport { ILike } from "typeorm";\nimport { <Name>Entity } from "../entities/<Name>Entity";\n\n@decorator.repository()\nexport class <Name>Repository {\n  constructor(\n    @inject("database")\n    private readonly database: ITypeormDatabase,\n  ) {}\n\n  public async open(): Promise<Repository<<Name>Entity>> {\n    return await this.database.open(<Name>Entity);\n  }\n\n  public async close(): Promise<void> {\n    await this.database.close();\n  }\n\n  public async find(\n    criteria: FindManyOptions<<Name>Entity> & { page?: number; limit?: number; q?: string },\n  ): Promise<FilterResultType<<Name>Entity>> {\n    // ... pagination and search logic\n  }\n\n  public async findOne(id: string): Promise<<Name>Entity | null> { ... }\n  public async findOneBy(criteria: FindOptionsWhere<<Name>Entity>): Promise<<Name>Entity | null> { ... }\n  public async create(entity: <Name>Entity, options?: SaveOptions): Promise<<Name>Entity> { ... }\n  public async createMany(entities: <Name>Entity[], options?: SaveOptions): Promise<<Name>Entity[]> { ... }\n  public async update(entity: <Name>Entity, options?: SaveOptions): Promise<<Name>Entity> { ... }\n  public async updateMany(entities: <Name>Entity[], options?: SaveOptions): Promise<<Name>Entity[]> { ... }\n  public async delete(criteria: FindOptionsWhere<<Name>Entity> | FindOptionsWhere<<Name>Entity>[]): Promise<UpdateResult> { ... }\n  public async count(criteria?: FindOptionsWhere<<Name>Entity> | FindOptionsWhere<<Name>Entity>[]): Promise<number> { ... }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/repositories/<Name>Repository.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep scaffolded tests for methods that remain in the repository (remove tests for methods that were removed)\n- Add tests for any custom domain-specific methods added to the repository\n- Add tests relevant to the specific repository behavior\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/repositories/<Name>Repository.ts tests/repositories/<Name>Repository.spec.ts\n```\n';
+
+// src/templates/claude/skills/make.seed.md.txt
+var make_seed_md_default = '---\nname: make:seed\ndescription: Generate a new database seed file with its test file, then complete the generated code. Use when creating seed data for populating the database using @ooneex/seeds.\n---\n\n# Make Seed\n\nGenerate a new seed file and its test file using the `make:seed` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the seed file and test files:\n\n```bash\nbunx @ooneex/cli@latest make:seed --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/seeds/<Name>Seed.ts` - The seed class file (or `modules/<module>/src/seeds/<Name>Seed.ts` with `--module`)\n- `src/seeds/<name-seed>.yml` - The seed data file in kebab-case (or `modules/<module>/src/seeds/<name-seed>.yml` with `--module`)\n- `tests/seeds/<Name>Seed.spec.ts` - The test file (or `modules/<module>/tests/seeds/<Name>Seed.spec.ts` with `--module`)\n\nIt will also:\n- Generate a `seeds.ts` root export file in the seeds directory\n\n### 2. Read the generated files\n\nRead all generated files to understand the scaffolded code.\n\n### 3. Complete the seed data\n\nEdit `src/seeds/<name-seed>.yml` to add the seed data entries. Each entry should have hardcoded nanoid values for `id` fields (generate via `bun -e "import { random } from \'@ooneex/utils\'; console.log(random.nanoid())"`)\n\n- Do NOT use sequential IDs like `"item-1"`, `"item-2"`\n- Ensure the same entity uses the same ID everywhere it appears\n\n### 4. Complete the seed class\n\nEdit `src/seeds/<Name>Seed.ts` to implement:\n\n- Import the relevant entity classes and repository\n- Use `resolve()` from `@ooneex/container` to get the repository instance\n- Map the imported YAML data to entity instances\n- Use the repository to persist the entities\n\n### 5. Complete the test file\n\nEdit `tests/seeds/<Name>Seed.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, run, isActive, getDependencies, data yml file)\n- Add tests relevant to the specific seed behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { existsSync } from "node:fs";\nimport { join } from "node:path";\nimport { describe, expect, test } from "bun:test";\nimport { <Name>Seed } from "@/seeds/<Name>Seed";\n\ndescribe("<Name>Seed", () => {\n  test("should have class name ending with \'Seed\'", () => {\n    expect(<Name>Seed.name.endsWith("Seed")).toBe(true);\n  });\n\n  test("should have \'run\' method", () => {\n    expect(<Name>Seed.prototype.run).toBeDefined();\n    expect(typeof <Name>Seed.prototype.run).toBe("function");\n  });\n\n  test("should have \'isActive\' method", () => {\n    expect(<Name>Seed.prototype.isActive).toBeDefined();\n    expect(typeof <Name>Seed.prototype.isActive).toBe("function");\n  });\n\n  test("should have \'getDependencies\' method", () => {\n    expect(<Name>Seed.prototype.getDependencies).toBeDefined();\n    expect(typeof <Name>Seed.prototype.getDependencies).toBe("function");\n  });\n\n  test("should have a data yml file", () => {\n    const dataFile = join(__dirname, "..", "src", "seeds", "<name-seed>.yml");\n    expect(existsSync(dataFile)).toBe(true);\n  });\n});\n```\n\n### 6. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/seeds/<Name>Seed.ts src/seeds/<name-seed>.yml tests/seeds/<Name>Seed.spec.ts\n```\n';
+
+// src/templates/claude/skills/make.service.md.txt
+var make_service_md_default = '---\nname: make:service\ndescription: Generate a new service class with its test file, then complete the generated code. Use when creating a new business logic service that implements IService from @ooneex/service.\n---\n\n# Make Service Class\n\nGenerate a new service class and its test file using the `make:service` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the service class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:service --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/services/<Name>Service.ts` - The service class file (or `modules/<module>/src/services/<Name>Service.ts` with `--module`)\n- `tests/services/<Name>Service.spec.ts` - The test file (or `modules/<module>/tests/services/<Name>Service.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the service class\n\nEdit `src/services/<Name>Service.ts` to complete the implementation:\n\n- Define a proper type for `ServiceDataType` instead of `Record<string, unknown>`\n- Implement the `execute()` method with actual business logic\n- Inject any required dependencies (repositories, other services, etc.) via the constructor\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { type IService, decorator } from "@ooneex/service";\n\ntype ServiceDataType = Record<string, unknown>;\n\n@decorator.service()\nexport class <Name>Service implements IService {\n  public async execute(data?: ServiceDataType): Promise<void> {\n    // TODO: Implement service logic\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/services/<Name>Service.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, execute method)\n- Add tests relevant to the specific service behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from "bun:test";\nimport { <Name>Service } from "@/services/<Name>Service";\n\ndescribe("<Name>Service", () => {\n  test("should have class name ending with \'Service\'", () => {\n    expect(<Name>Service.name.endsWith("Service")).toBe(true);\n  });\n\n  test("should have \'execute\' method", () => {\n    expect(<Name>Service.prototype.execute).toBeDefined();\n    expect(typeof <Name>Service.prototype.execute).toBe("function");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/services/<Name>Service.ts tests/services/<Name>Service.spec.ts\n```\n';
+
+// src/templates/claude/skills/make.storage.md.txt
+var make_storage_md_default = '---\nname: make:storage\ndescription: Generate a new storage class with its test file, then complete the generated code. Use when creating a new S3-compatible storage adapter that extends Storage from @ooneex/storage.\n---\n\n# Make Storage Class\n\nGenerate a new storage class and its test file using the `make:storage` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the storage class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:storage --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/storage/<Name>Storage.ts` - The storage class file (or `modules/<module>/src/storage/<Name>Storage.ts` with `--module`)\n- `tests/storage/<Name>Storage.spec.ts` - The test file (or `modules/<module>/tests/storage/<Name>Storage.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the storage class\n\nEdit `src/storage/<Name>Storage.ts` to complete the implementation:\n\n- Set the `bucket` property to the appropriate bucket name\n- Verify the environment variable names match the project configuration (`STORAGE_<NAME_UPPER>_ACCESS_KEY`, `STORAGE_<NAME_UPPER>_SECRET_KEY`, `STORAGE_<NAME_UPPER>_ENDPOINT`, `STORAGE_<NAME_UPPER>_REGION`)\n- Add any additional storage-specific methods if needed\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { Storage, decorator, StorageException } from "@ooneex/storage";\nimport type { S3Options } from "bun";\n\n@decorator.storage()\nexport class <Name>Storage extends Storage {\n  protected bucket: string;\n  private readonly accessKey: string;\n  private readonly secretKey: string;\n  private readonly endpoint: string;\n  private readonly region: string;\n\n  constructor(options?: {\n    accessKey?: string;\n    secretKey?: string;\n    endpoint?: string;\n    region?: string;\n  }) {\n    super();\n\n    const accessKey = options?.accessKey || Bun.env.STORAGE_<NAME_UPPER>_ACCESS_KEY;\n    const secretKey = options?.secretKey || Bun.env.STORAGE_<NAME_UPPER>_SECRET_KEY;\n    const endpoint = options?.endpoint || Bun.env.STORAGE_<NAME_UPPER>_ENDPOINT;\n\n    // ... validation throws StorageException if missing ...\n\n    this.accessKey = accessKey;\n    this.secretKey = secretKey;\n    this.endpoint = endpoint;\n    this.region = options?.region || Bun.env.STORAGE_<NAME_UPPER>_REGION || "auto";\n  }\n\n  public getOptions(): S3Options {\n    return {\n      accessKeyId: this.accessKey,\n      secretAccessKey: this.secretKey,\n      endpoint: this.endpoint,\n      bucket: this.bucket,\n      region: this.region,\n    };\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/storage/<Name>Storage.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, bucket field, getOptions method)\n- Add tests relevant to the specific storage class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from "bun:test";\nimport { <Name>StorageAdapter } from "@/storage/<Name>StorageAdapter";\n\ndescribe("<Name>StorageAdapter", () => {\n  test("should have class name ending with \'StorageAdapter\'", () => {\n    expect(<Name>StorageAdapter.name.endsWith("StorageAdapter")).toBe(true);\n  });\n\n  test("should have \'bucket\' field", () => {\n    expect("bucket" in <Name>StorageAdapter.prototype || "bucket" in Object.getOwnPropertyNames(<Name>StorageAdapter.prototype)).toBe(true);\n  });\n\n  test("should have \'getOptions\' method", () => {\n    expect(<Name>StorageAdapter.prototype.getOptions).toBeDefined();\n    expect(typeof <Name>StorageAdapter.prototype.getOptions).toBe("function");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/storage/<Name>Storage.ts tests/storage/<Name>Storage.spec.ts\n```\n';
+
+// src/templates/claude/skills/make.vector-database.md.txt
+var make_vector_database_md_default = '---\nname: make:vector-database\ndescription: Generate a new vector database class with its test file, then complete the generated code. Use when creating a new vector database that extends VectorDatabase from @ooneex/rag.\n---\n\n# Make Vector Database Class\n\nGenerate a new vector database class and its test file using the `make:vector-database` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from "@ooneex/container";\nimport { decorator, type ISeed } from "@ooneex/seeds";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the vector database class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:vector-database --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/databases/<Name>VectorDatabase.ts` - The vector database class file (or `modules/<module>/src/databases/<Name>VectorDatabase.ts` with `--module`)\n- `tests/databases/<Name>VectorDatabase.spec.ts` - The test file (or `modules/<module>/tests/databases/<Name>VectorDatabase.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the vector database class\n\nEdit `src/databases/<Name>VectorDatabase.ts` to complete the implementation:\n\n- Set the `getDatabaseUri()` return value to the actual LanceDB database path\n- Configure the embedding provider and model in `getEmbeddingModel()`\n- Define the custom data fields in `DataType` and map them in `getSchema()`\n- Import the appropriate Apache Arrow types for your schema fields\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { type EmbeddingModelType, type EmbeddingProviderType, type FieldValueType, VectorDatabase, decorator } from "@ooneex/rag";\nimport { Utf8 } from "apache-arrow";\n\ntype DataType = {\n  name: string;\n};\n\n@decorator.vectorDatabase()\nexport class <Name>VectorDatabase extends VectorDatabase<DataType> {\n  public getDatabaseUri(): string {\n    return "";\n  }\n\n  public getEmbeddingModel(): { provider: EmbeddingProviderType; model: EmbeddingModelType["model"] } {\n    return { provider: "openai", model: "text-embedding-ada-002" };\n  }\n\n  public getSchema(): { [K in keyof DataType]: FieldValueType } {\n    return {\n      name: new Utf8(),\n    };\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/databases/<Name>VectorDatabase.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, getDatabaseUri, getEmbeddingModel, getSchema methods)\n- Add tests relevant to the specific vector database class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from "bun:test";\nimport { <Name>VectorDatabase } from "@/databases/<Name>VectorDatabase";\n\ndescribe("<Name>VectorDatabase", () => {\n  test("should have class name ending with \'VectorDatabase\'", () => {\n    expect(<Name>VectorDatabase.name.endsWith("VectorDatabase")).toBe(true);\n  });\n\n  test("should have \'getDatabaseUri\' method", () => {\n    expect(<Name>VectorDatabase.prototype.getDatabaseUri).toBeDefined();\n    expect(typeof <Name>VectorDatabase.prototype.getDatabaseUri).toBe("function");\n  });\n\n  test("should have \'getEmbeddingModel\' method", () => {\n    expect(<Name>VectorDatabase.prototype.getEmbeddingModel).toBeDefined();\n    expect(typeof <Name>VectorDatabase.prototype.getEmbeddingModel).toBe("function");\n  });\n\n  test("should have \'getSchema\' method", () => {\n    expect(<Name>VectorDatabase.prototype.getSchema).toBeDefined();\n    expect(typeof <Name>VectorDatabase.prototype.getSchema).toBe("function");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/databases/<Name>VectorDatabase.ts tests/databases/<Name>VectorDatabase.spec.ts\n```\n';
+
+// src/templates/claude/skills/optimize.md.txt
+var optimize_md_default = "---\nname: optimize\ndescription: Optimize a module's codebase for quality, performance, and clean conventions. Enforces arrow functions (except class methods), type/interface naming, removes duplication, and ensures only important tests remain.\n---\n\n# Optimize Codebase\n\nOptimize a module's codebase for quality, performance, and clean conventions.\n\n## Coding Conventions\n\nApply these conventions across all files in the target module:\n\n- **Arrow functions everywhere** \u2014 use arrow functions for all function expressions, callbacks, standalone functions, and variable declarations. The ONLY exception is class methods, which must use regular method syntax.\n- **Type naming** \u2014 all type aliases must end with the `Type` suffix (e.g., `UserDataType`, `ConfigOptionsType`). Rename any that don't comply.\n- **Interface naming** \u2014 all interface names must start with the `I` prefix (e.g., `IUser`, `IService`, `IRepository`). Rename any that don't comply.\n- **No definite assignment assertions** \u2014 never use `!` on class properties (e.g., `email!: string`). Use a default value or make the property optional (`?`) instead.\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`).\n- For Entity class, if property is optional, add `null` to its type.\n- For dependencies, use `inject` from `@ooneex/container`. For example:\n\n```typescript\nimport { inject } from \"@ooneex/container\";\nimport { decorator, type ISeed } from \"@ooneex/seeds\";\n\n@decorator.seed()\nexport class BookSeed implements ISeed {\n  constructor(\n    @inject(BookRepository)\n    private readonly repository: BookRepository,\n  ) {}\n}\n```\n\n## Steps\n\n### 1. Identify the target\n\nDetermine the module to optimize. If the user specifies a module name, work in `modules/<module>/`. If no module is specified, ask the user which module to optimize.\n\n### 2. Read and analyze the module\n\nRead all source files (`src/**/*.ts`) and test files (`tests/**/*.ts`) in the target module. Build a full picture of:\n\n- All types, interfaces, classes, and functions\n- Dependencies between files\n- Existing test coverage\n\n### 3. Enforce naming conventions\n\nScan every file and fix:\n\n- **Types not ending with `Type`** \u2014 rename the type and update all references across the module\n- **Interfaces not starting with `I`** \u2014 rename the interface and update all references across the module\n- **Non-arrow functions** \u2014 convert all function expressions, callbacks, and standalone functions to arrow functions. Do NOT convert class methods.\n- **Missing visibility modifiers** \u2014 add explicit `public`, `private`, or `protected` to all class methods and properties\n\n### 4. Remove code duplication\n\nIdentify duplicated or near-duplicated code within the module:\n\n- Extract shared logic into well-named helper arrow functions or base classes\n- Consolidate repeated type definitions\n- Merge similar utility functions\n- Remove dead code (unused imports, unreachable branches, unused variables)\n\n### 5. Optimize for performance\n\nReview and improve:\n\n- Replace inefficient loops or repeated iterations with single-pass approaches where possible\n- Use `Map`/`Set` instead of arrays for lookups when appropriate\n- Avoid unnecessary object spreads or deep clones\n- Prefer early returns to reduce nesting\n- Remove unnecessary `async`/`await` where a direct return suffices\n- Eliminate redundant null/undefined checks when the type system already guarantees the value\n\n### 6. Optimize tests\n\nReview all test files and restructure:\n\n- **Remove trivial tests** \u2014 delete tests that only check obvious things (e.g., \"class name ends with X\", \"method exists\") unless they serve as smoke tests for generated code\n- **Keep and improve important tests** \u2014 focus on tests that verify actual business logic, edge cases, error handling, and integration behavior\n- **Write fewer but more meaningful tests** \u2014 each test should validate a real scenario or invariant, not just existence checks\n- **Consolidate redundant test cases** \u2014 merge tests that cover the same code path with slightly different inputs into parameterized patterns\n- **Ensure critical paths are covered** \u2014 every public method with logic should have at least one test covering its happy path and one covering its error/edge case\n\n### 7. Final cleanup\n\n- Remove all unused imports\n- Remove empty files or files with no exports\n- Ensure consistent formatting\n\n### 8. Lint and format\n\nRun linting and formatting on all modified files:\n\n```bash\nbunx biome check --fix <list of modified files>\n```\n\n### 9. Run tests\n\nRun the module's tests to verify nothing is broken:\n\n```bash\nbun test <module test directory>\n```\n\nIf any test fails, fix the issue and re-run until all tests pass.\n";
+
+// src/commands/MakeClaudeSkillCommand.ts
+var skills = {
+  "make.ai": make_ai_md_default,
+  "make.analytics": make_analytics_md_default,
+  "make.cache": make_cache_md_default,
+  "make.controller": make_controller_md_default,
+  "make.cron": make_cron_md_default,
+  "make.database": make_database_md_default,
+  "make.entity": make_entity_md_default,
+  "make.logger": make_logger_md_default,
+  "make.mailer": make_mailer_md_default,
+  "make.middleware": make_middleware_md_default,
+  "make.migration": make_migration_md_default,
+  "make.permission": make_permission_md_default,
+  "make.pubsub": make_pubsub_md_default,
+  "make.repository": make_repository_md_default,
+  "make.seed": make_seed_md_default,
+  "make.service": make_service_md_default,
+  "make.storage": make_storage_md_default,
+  "make.vector-database": make_vector_database_md_default,
+  commit: commit_md_default,
+  optimize: optimize_md_default
+};
+
+class MakeClaudeSkillCommand {
+  getName() {
+    return "make:claude:skill";
+  }
+  getDescription() {
+    return "Generate Claude skills from templates";
+  }
+  async run() {
+    const skillsLocalDir = join11(".claude", "skills");
+    const skillsDir = join11(process.cwd(), skillsLocalDir);
+    const logger = new TerminalLogger10;
+    for (const [skillName, content] of Object.entries(skills)) {
+      const dirName = skillName.replace(/\./g, "-");
+      const filePath = join11(skillsDir, dirName, "SKILL.md");
+      await Bun.write(filePath, content);
+      logger.success(`${join11(skillsLocalDir, dirName, "SKILL.md")} created successfully`, undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+    }
   }
 }
-`;
-
-// src/commands/MakeCacheCommand.ts
-class MakeCacheCommand {
+MakeClaudeSkillCommand = __legacyDecorateClassTS([
+  decorator11.command()
+], MakeClaudeSkillCommand);
+// src/commands/MakeCommandCommand.ts
+import { join as join12 } from "path";
+import { commandCreate, decorator as decorator12 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger11 } from "@ooneex/logger";
+class MakeCommandCommand {
   getName() {
-    return "make:cache";
+    return "make:command";
   }
   getDescription() {
-    return "Generate a new cache class";
+    return "Generate a new command class";
   }
   async run(options) {
     let { name, module } = options;
     if (!name) {
-      name = await askName({ message: "Enter cache name" });
+      name = await askName({ message: "Enter name" });
+    }
+    if (module) {
+      await ensureModule(module);
+    }
+    const base = module ? join12("modules", module) : ".";
+    const { commandPath, testPath } = await commandCreate({
+      name,
+      commandDir: join12(base, "src", "commands"),
+      testsDir: join12(base, "tests", "commands")
+    });
+    if (module && module !== "app") {
+      const appCommandsRootPath = join12(process.cwd(), "modules", "app", "src", "commands", "commands.ts");
+      const appCommandsRootFile = Bun.file(appCommandsRootPath);
+      const importLine = `import "@${module}/commands/commands";`;
+      if (await appCommandsRootFile.exists()) {
+        const appCommandsContent = await appCommandsRootFile.text();
+        if (!appCommandsContent.includes(importLine)) {
+          await Bun.write(appCommandsRootPath, `${appCommandsContent.trimEnd()}
+${importLine}
+`);
+        }
+      } else {
+        await Bun.write(appCommandsRootPath, `${importLine}
+`);
+      }
     }
-    name = toPascalCase5(name).replace(/Cache$/, "");
-    const content = cache_default.replace(/{{NAME}}/g, name);
-    if (module) {
-      await ensureModule(module);
+    const binCommandRunPath = join12(process.cwd(), "modules", "app", "bin", "command", "run.ts");
+    const binCommandRunFile = Bun.file(binCommandRunPath);
+    if (!await binCommandRunFile.exists()) {
+      await Bun.write(binCommandRunPath, command_run_default);
     }
-    const base = module ? join8("modules", module) : ".";
-    const cacheLocalDir = join8(base, "src", "cache");
-    const cacheDir = join8(process.cwd(), cacheLocalDir);
-    const filePath = join8(cacheDir, `${name}Cache.ts`);
-    await Bun.write(filePath, content);
-    const testContent = cache_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join8(base, "tests", "cache");
-    const testsDir = join8(process.cwd(), testsLocalDir);
-    const testFilePath = join8(testsDir, `${name}Cache.spec.ts`);
-    await Bun.write(testFilePath, testContent);
-    const logger = new TerminalLogger7;
-    logger.success(`${join8(cacheLocalDir, name)}Cache.ts created successfully`, undefined, {
+    const packageJsonPath = join12(process.cwd(), "modules", "app", "package.json");
+    const packageJsonFile = Bun.file(packageJsonPath);
+    if (await packageJsonFile.exists()) {
+      const packageJson = await packageJsonFile.json();
+      packageJson.scripts = packageJson.scripts || {};
+      packageJson.scripts.command = "bun ./bin/command/run.ts";
+      await Bun.write(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    }
+    const logger = new TerminalLogger11;
+    logger.success(`${commandPath} created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join8(testsLocalDir, name)}Cache.spec.ts created successfully`, undefined, {
+    logger.success(`${testPath} created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    const packageJsonPath = join8(process.cwd(), "package.json");
-    const packageJson = await Bun.file(packageJsonPath).json();
-    const deps = packageJson.dependencies ?? {};
-    const devDeps = packageJson.devDependencies ?? {};
-    if (!deps["@ooneex/cache"] && !devDeps["@ooneex/cache"]) {
-      const install = Bun.spawn(["bun", "add", "@ooneex/cache"], {
-        cwd: process.cwd(),
-        stdout: "ignore",
-        stderr: "inherit"
-      });
-      await install.exited;
-    }
+    logger.info("Run 'bun run command' to execute commands", undefined, {
+      showTimestamp: false,
+      showArrow: true,
+      showLevel: false
+    });
   }
 }
-MakeCacheCommand = __legacyDecorateClassTS([
-  decorator7.command()
-], MakeCacheCommand);
-// src/commands/MakeClaudeSkillCommand.ts
-import { join as join9 } from "path";
-import { decorator as decorator8 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger8 } from "@ooneex/logger";
-
-// src/templates/claude/skills/commit.md.txt
-var commit_md_default = `---
-name: commit
-description: Create commit messages grouped by module. Analyzes git changes, groups files under modules/ by module name, and creates separate commits following commitlint conventions. Uses common scope for non-module changes.
----
-
-# Commit by Module
-
-Create separate commits for each modified module, following the project's commitlint conventions.
-
-## Workflow
-
-1. **Analyze staged/unstaged changes**
-   - Run \`git status --porcelain\` to get all modified files
-   - Group changes by module (files under \`modules/<module-name>/\`)
-   - Identify non-module changes (files not in \`modules/\`) as scope \`common\`
-
-2. **For each module with changes**
-   - Stage only that module's files: \`git add modules/<module-name>/\`
-   - Determine the appropriate commit type based on changes
-   - Create a commit with proper format: \`type(scope): Subject\`
-   - The scope is the module name in lower-case
-   - Repeat for next module
-
-3. **Handle non-module changes**
-   - Files outside \`modules/\` (e.g., \`bun.lock\`, \`package.json\`, config files, \`packages/\` changes) use scope \`common\`
-   - Stage and commit separately from module changes
-
-## Commit Message Format
-
-\`\`\`
-type(scope): Subject line
-\`\`\`
-
-### Valid Types
-- \`feat\`: New feature
-- \`fix\`: Bug fix
-- \`refactor\`: Code refactoring (no new feature, no bug fix)
-- \`test\`: Adding/updating tests
-- \`chore\`: Maintenance tasks (dependencies, configs)
-- \`docs\`: Documentation changes
-- \`style\`: Code style changes (formatting, whitespace)
-- \`perf\`: Performance improvements
-- \`build\`: Build system changes
-- \`ci\`: CI configuration changes
-- \`revert\`: Revert previous commit
-
-### Scope Rules
-- For files under \`modules/<name>/\`: use the module name as scope (e.g., \`module\` scope matches the commitlint config)
-- For all other files: use \`common\`
-- Scope must be lower-case
-- Scope must never be empty
-- If the module name matches a valid commitlint scope, use it directly
-- If it does not match, use \`module\` as the scope
-
-### Subject Rules
-- Use sentence-case, start-case, pascal-case, or upper-case
-- No period at the end
-- Maximum 100 characters for entire header
-- Use imperative mood ("Add feature" not "Added feature")
-
-## Determining Commit Type
-
-Analyze the changes to determine the appropriate type:
-
-| Change Pattern | Type |
-|---------------|------|
-| New files with functionality | \`feat\` |
-| Bug fixes, error corrections | \`fix\` |
-| Code restructuring, renaming | \`refactor\` |
-| New/updated test files (\`*.spec.ts\`) | \`test\` |
-| Documentation files (\`*.md\`) | \`docs\` |
-| Dependency updates, lock files | \`chore\` |
-| Build configs, scripts | \`build\` |
-| CI/CD files | \`ci\` |
-| Formatting only | \`style\` |
-| Performance optimizations | \`perf\` |
-
-## Examples
-
-### Example 1: Multiple Module Changes
-
-Git status shows:
-\`\`\`
-M modules/user/src/services/UserService.ts
-A modules/user/src/services/AuthService.ts
-M modules/user/tests/UserService.spec.ts
-M modules/product/src/entities/Product.ts
-M modules/product/src/repositories/ProductRepository.ts
-M bun.lock
-M packages/cache/src/index.ts
-\`\`\`
-
-Commands to execute:
-\`\`\`bash
-# Commit user module
-git add modules/user/
-git commit -m "feat(user): Add AuthService and update UserService"
+MakeCommandCommand = __legacyDecorateClassTS([
+  decorator12.command()
+], MakeCommandCommand);
+// src/commands/MakeControllerCommand.ts
+import { basename, join as join13 } from "path";
+import { decorator as decorator13 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger12 } from "@ooneex/logger";
+import { toKebabCase as toKebabCase3, toPascalCase as toPascalCase5, trim } from "@ooneex/utils";
 
-# Commit product module
-git add modules/product/
-git commit -m "refactor(product): Update Product entity and repository"
+// src/prompts/askConfirm.ts
+var import_enquirer3 = __toESM(require_enquirer(), 1);
+var askConfirm = async (config) => {
+  const response = await import_enquirer3.prompt({
+    type: "confirm",
+    name: "confirm",
+    message: config.message,
+    initial: config.initial
+  });
+  return response.confirm;
+};
 
-# Commit non-module changes
-git add bun.lock packages/cache/
-git commit -m "chore(common): Update dependencies and cache package"
-\`\`\`
+// ../types/dist/index.js
+var HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"];
 
-### Example 2: Single Module with Tests
+// src/prompts/askRouteMethod.ts
+var import_enquirer4 = __toESM(require_enquirer(), 1);
 
-Git status shows:
-\`\`\`
-A modules/payment/src/services/StripeService.ts
-A modules/payment/tests/StripeService.spec.ts
-\`\`\`
+// src/constraints/AssertRouteMethod.ts
+import { Assert as Assert2, Validation as Validation2 } from "@ooneex/validation";
 
-Command:
-\`\`\`bash
-git add modules/payment/
-git commit -m "feat(payment): Add StripeService with tests"
-\`\`\`
+class AssertRouteMethod extends Validation2 {
+  getConstraint() {
+    return Assert2("string >= 3");
+  }
+  getErrorMessage() {
+    return `Route method must be one of: ${HTTP_METHODS.join(", ")}`;
+  }
+  validate(data, constraint) {
+    const basicValidation = super.validate(data, constraint);
+    if (!basicValidation.isValid) {
+      return basicValidation;
+    }
+    const method = data;
+    if (method.trim() !== method) {
+      return {
+        isValid: false,
+        message: this.getErrorMessage() || "Invalid route method format"
+      };
+    }
+    const upperMethod = method.toUpperCase();
+    if (!HTTP_METHODS.includes(upperMethod)) {
+      return {
+        isValid: false,
+        message: this.getErrorMessage() || "Invalid route method"
+      };
+    }
+    return {
+      isValid: true
+    };
+  }
+}
 
-### Example 3: Only Non-module Changes
+// src/prompts/askRouteMethod.ts
+var askRouteMethod = async (config) => {
+  const response = await import_enquirer4.prompt({
+    type: "select",
+    name: "method",
+    message: config.message,
+    initial: config.initial ?? 0,
+    choices: HTTP_METHODS.map((method) => method),
+    validate: (value) => {
+      const constraint = new AssertRouteMethod;
+      const result = constraint.validate(value);
+      if (!result.isValid) {
+        return result.message || "Route method is invalid";
+      }
+      return true;
+    }
+  });
+  return response.method;
+};
 
-Git status shows:
-\`\`\`
-M package.json
-M bun.lock
-M packages/logger/src/Logger.ts
-\`\`\`
+// src/prompts/askRouteName.ts
+var import_enquirer5 = __toESM(require_enquirer(), 1);
 
-Command:
-\`\`\`bash
-git add package.json bun.lock packages/logger/
-git commit -m "chore(common): Update dependencies and logger package"
-\`\`\`
+// src/constraints/AssertRouteName.ts
+import { Assert as Assert3, Validation as Validation3 } from "@ooneex/validation";
+var ROUTE_NAME_REGEX = /^[a-zA-Z0-9]+\.[a-zA-Z0-9]+\.[a-zA-Z0-9]+$/;
 
-### Example 4: Module Refactoring with Deletions
+class AssertRouteName extends Validation3 {
+  getConstraint() {
+    return Assert3("string >= 7");
+  }
+  getErrorMessage() {
+    return "Route name must follow format: namespace.resource.action (e.g., 'api.users.list')";
+  }
+  validate(data, constraint) {
+    const basicValidation = super.validate(data, constraint);
+    if (!basicValidation.isValid) {
+      return basicValidation;
+    }
+    const routeName = data;
+    if (routeName.trim() !== routeName) {
+      return {
+        isValid: false,
+        message: this.getErrorMessage() || "Invalid route name format"
+      };
+    }
+    if (!ROUTE_NAME_REGEX.test(routeName)) {
+      return {
+        isValid: false,
+        message: this.getErrorMessage() || "Invalid route name format"
+      };
+    }
+    const segments = routeName.split(".");
+    if (segments.length !== 3) {
+      return {
+        isValid: false,
+        message: this.getErrorMessage() || "Invalid route name format"
+      };
+    }
+    const [namespace, resource, action] = segments;
+    if (!namespace || !resource || !action) {
+      return {
+        isValid: false,
+        message: this.getErrorMessage() || "Invalid route name format"
+      };
+    }
+    return {
+      isValid: true
+    };
+  }
+}
 
-Git status shows:
-\`\`\`
-D modules/order/src/services/OldOrderService.ts
-A modules/order/src/services/OrderService.ts
-M modules/order/src/index.ts
-\`\`\`
+// src/prompts/askRouteName.ts
+var askRouteName = async (config) => {
+  const response = await import_enquirer5.prompt({
+    type: "input",
+    name: "routeName",
+    message: config.message,
+    validate: (value) => {
+      const constraint = new AssertRouteName;
+      const result = constraint.validate(value);
+      if (!result.isValid) {
+        return result.message || "Route name is invalid";
+      }
+      return true;
+    }
+  });
+  return response.routeName;
+};
 
-Command:
-\`\`\`bash
-git add modules/order/
-git commit -m "refactor(order): Replace OldOrderService with OrderService"
-\`\`\`
+// src/prompts/askRoutePath.ts
+var import_enquirer6 = __toESM(require_enquirer(), 1);
 
-## Subject Line Guidelines
+// src/constraints/AssertRoutePath.ts
+import { Assert as Assert4, Validation as Validation4 } from "@ooneex/validation";
+var ROUTE_PATH_MIN_LENGTH = 1;
+var ROUTE_PATH_REGEX = /^\/[\w\-/:]*$/;
+var VALID_SEGMENT_REGEX = /^[a-zA-Z0-9\-_]+$/;
+var PARAM_SEGMENT_REGEX = /^:[a-zA-Z][a-zA-Z0-9]*$/;
 
-Write clear, descriptive subjects:
+class AssertRoutePath extends Validation4 {
+  getConstraint() {
+    return Assert4(`string >= ${ROUTE_PATH_MIN_LENGTH}`);
+  }
+  getErrorMessage() {
+    return "Route path must start with '/' and contain only valid segments (e.g., '/users', '/api/users/:id')";
+  }
+  validate(data, constraint) {
+    const basicValidation = super.validate(data, constraint);
+    if (!basicValidation.isValid) {
+      return basicValidation;
+    }
+    const path = data;
+    if (path.trim() !== path) {
+      return {
+        isValid: false,
+        message: this.getErrorMessage() || "Invalid route path format"
+      };
+    }
+    if (!path.startsWith("/")) {
+      return {
+        isValid: false,
+        message: "Route path must start with '/'"
+      };
+    }
+    if (path.length > 1 && path.endsWith("/")) {
+      return {
+        isValid: false,
+        message: "Route path cannot end with '/' (except for root path)"
+      };
+    }
+    if (!ROUTE_PATH_REGEX.test(path)) {
+      return {
+        isValid: false,
+        message: this.getErrorMessage() || "Invalid route path format"
+      };
+    }
+    if (path === "/") {
+      return {
+        isValid: true
+      };
+    }
+    const segments = path.slice(1).split("/");
+    for (const segment of segments) {
+      if (!segment) {
+        return {
+          isValid: false,
+          message: "Route path cannot contain empty segments (double slashes)"
+        };
+      }
+      if (segment.startsWith(":")) {
+        if (!PARAM_SEGMENT_REGEX.test(segment)) {
+          return {
+            isValid: false,
+            message: `Invalid parameter segment '${segment}'. Parameters must follow format ':paramName' with alphanumeric characters only`
+          };
+        }
+      } else {
+        if (!VALID_SEGMENT_REGEX.test(segment)) {
+          return {
+            isValid: false,
+            message: `Invalid path segment '${segment}'. Segments must contain only letters, numbers, hyphens, and underscores`
+          };
+        }
+      }
+    }
+    return {
+      isValid: true
+    };
+  }
+}
 
-| Good | Bad |
-|------|-----|
-| \`Add Stripe payment integration\` | \`stripe\` |
-| \`Fix null check in user validation\` | \`fix bug\` |
-| \`Update order processing flow\` | \`changes\` |
-| \`Remove deprecated auth methods\` | \`cleanup\` |
-| \`Rename UserAdapter to UserService\` | \`rename\` |
+// src/prompts/askRoutePath.ts
+var askRoutePath = async (config) => {
+  const response = await import_enquirer6.prompt({
+    type: "input",
+    name: "path",
+    message: config.message,
+    initial: config.initial ?? "/",
+    validate: (value) => {
+      const constraint = new AssertRoutePath;
+      const result = constraint.validate(value);
+      if (!result.isValid) {
+        return result.message || "Route path is invalid";
+      }
+      return true;
+    }
+  });
+  return response.path;
+};
 
-## Pre-commit Checklist
+// src/templates/controller.socket.txt
+var controller_socket_default = `import type { ContextType } from "@ooneex/socket";
+import { ERole } from "@ooneex/role";
+import { Route } from "@ooneex/routing";
+import { Assert } from "@ooneex/validation";
 
-Before committing, verify:
-1. Changes are logically grouped by module
-2. Tests pass for modified modules
-3. No debug code or console.logs left in
-4. Commit message follows the format exactly
-5. For Entity class, if property is optional, add \`null\` to its type.
+export type {{TYPE_NAME}}RouteType = {
+  params: {
 
-## Handling Special Cases
+  },
+  payload: {
 
-### Mixed Changes in One Module
-If a module has both new features and bug fixes, prioritize:
-1. \`feat\` if primary change is new functionality
-2. \`fix\` if primary change is a bug fix
-3. Split into multiple commits if changes are truly independent
+  },
+  queries: {
 
-### Deleted Files Only
-Use \`refactor\` for removing deprecated code:
-\`\`\`bash
-git add modules/user/
-git commit -m "refactor(user): Remove deprecated UserAdapter"
-\`\`\`
+  },
+  response: {
 
-### Renamed/Moved Files
-Use \`refactor\` for file reorganization:
-\`\`\`bash
-git add modules/product/
-git commit -m "refactor(product): Reorganize service file structure"
-\`\`\`
-`;
+  },
+};
 
-// src/templates/claude/skills/make.ai.md.txt
-var make_ai_md_default = "---\nname: make:ai\ndescription: Generate a new AI class with its test file, then complete the generated code. Use when creating a new AI chat class that uses OpenAI via the @ooneex/ai package.\n---\n\n# Make AI Class\n\nGenerate a new AI class and its test file using the `make:ai` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the AI class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:ai --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/ai/<Name>Ai.ts` - The AI class file (or `modules/<module>/src/ai/<Name>Ai.ts` with `--module`)\n- `tests/ai/<Name>Ai.spec.ts` - The test file (or `modules/<module>/tests/ai/<Name>Ai.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the AI class\n\nEdit `src/ai/<Name>Ai.ts` to complete the implementation:\n\n- Update the prompt in the `run` method from `\"My prompt\"` to a meaningful prompt based on the class purpose\n- Update the prompt in the `runStream` method from `\"My prompt\"` to a meaningful prompt based on the class purpose\n- Add any additional configuration or methods relevant to the AI class purpose\n- Ensure proper typing for the `run<T>()` generic return type\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { decorator, type IAiChat, OpenAi, type OpenAiConfigType } from \"@ooneex/ai\";\nimport { inject } from \"@ooneex/container\";\n\n@decorator.ai()\nexport class <Name>Ai implements IAiChat<OpenAiConfigType> {\n  constructor(@inject(OpenAi) private readonly ai: OpenAi) {}\n\n  public async run<T>(prompt?: string, config?: Omit<OpenAiConfigType, \"prompt\">): Promise<T> {\n    return this.ai.run<T>(prompt || \"My prompt\", config);\n  }\n\n  public async *runStream(\n    prompt?: string,\n    config?: Omit<OpenAiConfigType, \"prompt\" | \"output\">,\n  ): AsyncGenerator<string, void, unknown> {\n    yield* this.ai.runStream(prompt || \"My prompt\", config);\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/ai/<Name>Ai.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, run method, runStream method)\n- Add tests relevant to the specific AI class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>Ai } from \"@/ai/<Name>Ai\";\n\ndescribe(\"<Name>Ai\", () => {\n  test(\"should have class name ending with 'Ai'\", () => {\n    expect(<Name>Ai.name.endsWith(\"Ai\")).toBe(true);\n  });\n\n  test(\"should have 'run' method\", () => {\n    expect(<Name>Ai.prototype.run).toBeDefined();\n    expect(typeof <Name>Ai.prototype.run).toBe(\"function\");\n  });\n\n  test(\"should have 'runStream' method\", () => {\n    expect(<Name>Ai.prototype.runStream).toBeDefined();\n    expect(typeof <Name>Ai.prototype.runStream).toBe(\"function\");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/ai/<Name>Ai.ts tests/ai/<Name>Ai.spec.ts\n```\n";
+@Route.socket("{{ROUTE_PATH}}", {
+  name: "{{ROUTE_NAME}}",
+  version: 1,
+  description: "",
+  params: {
+    // id: Assert("string"),
+  },
+  payload: Assert({
 
-// src/templates/claude/skills/make.analytics.md.txt
-var make_analytics_md_default = "---\nname: make:analytics\ndescription: Generate a new analytics class with its test file, then complete the generated code. Use when creating a new analytics tracking class that uses the @ooneex/analytics package.\n---\n\n# Make Analytics Class\n\nGenerate a new analytics class and its test file using the `make:analytics` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the analytics class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:analytics --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/analytics/<Name>Analytics.ts` - The analytics class file (or `modules/<module>/src/analytics/<Name>Analytics.ts` with `--module`)\n- `tests/analytics/<Name>Analytics.spec.ts` - The test file (or `modules/<module>/tests/analytics/<Name>Analytics.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the analytics class\n\nEdit `src/analytics/<Name>Analytics.ts` to complete the implementation:\n\n- Implement the `capture` method with actual analytics tracking logic\n- Define a proper type for `CaptureOptionsType` instead of `Record<string, unknown>` based on the analytics purpose\n- Add any additional methods or properties relevant to the analytics class purpose\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { type IAnalytics, decorator } from \"@ooneex/analytics\";\n\ntype CaptureOptionsType = Record<string, unknown>;\n\n@decorator.analytics()\nexport class <Name>Analytics<T extends CaptureOptionsType = CaptureOptionsType> implements IAnalytics<T> {\n  public capture(options: T): void {\n    // console.log(\"Analytics captured:\", options);\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/analytics/<Name>Analytics.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, capture method)\n- Add tests relevant to the specific analytics class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>Analytics } from \"@/analytics/<Name>Analytics\";\n\ndescribe(\"<Name>Analytics\", () => {\n  test(\"should have class name ending with 'Analytics'\", () => {\n    expect(<Name>Analytics.name.endsWith(\"Analytics\")).toBe(true);\n  });\n\n  test(\"should have 'capture' method\", () => {\n    expect(<Name>Analytics.prototype.capture).toBeDefined();\n    expect(typeof <Name>Analytics.prototype.capture).toBe(\"function\");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/analytics/<Name>Analytics.ts tests/analytics/<Name>Analytics.spec.ts\n```\n";
+  }),
+  queries: Assert({
 
-// src/templates/claude/skills/make.cache.md.txt
-var make_cache_md_default = "---\nname: make:cache\ndescription: Generate a new cache adapter class with its test file, then complete the generated code. Use when creating a new cache adapter that implements the ICache interface from @ooneex/cache.\n---\n\n# Make Cache Class\n\nGenerate a new cache class and its test file using the `make:cache` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the cache class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:cache --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/cache/<Name>Cache.ts` - The cache class file (or `modules/<module>/src/cache/<Name>Cache.ts` with `--module`)\n- `tests/cache/<Name>Cache.spec.ts` - The test file (or `modules/<module>/tests/cache/<Name>Cache.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the cache class\n\nEdit `src/cache/<Name>Cache.ts` to complete the implementation:\n\n- Implement the `get` method to retrieve cached values by key\n- Implement the `set` method to store values with optional TTL\n- Implement the `delete` method to remove cached entries\n- Implement the `has` method to check key existence\n- Replace the `CacheException` throws with actual cache logic\n- Inject any required dependencies (e.g., Redis client) via the constructor\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { CacheException, type ICache, decorator } from \"@ooneex/cache\";\n\n@decorator.cache()\nexport class <Name>Cache implements ICache {\n  public async get<T = unknown>(key: string): Promise<T | undefined> {\n    throw new CacheException(`Failed to get key \"${key}\": Not implemented`);\n  }\n\n  public async set<T = unknown>(key: string, value: T, ttl?: number): Promise<void> {\n    throw new CacheException(`Failed to set key \"${key}\": Not implemented`);\n  }\n\n  public async delete(key: string): Promise<boolean> {\n    throw new CacheException(`Failed to delete key \"${key}\": Not implemented`);\n  }\n\n  public async has(key: string): Promise<boolean> {\n    throw new CacheException(`Failed to check if key \"${key}\" exists: Not implemented`);\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/cache/<Name>Cache.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, get, set, delete, has methods)\n- Add tests relevant to the specific cache class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>Cache } from \"@/cache/<Name>Cache\";\n\ndescribe(\"<Name>Cache\", () => {\n  test(\"should have class name ending with 'Cache'\", () => {\n    expect(<Name>Cache.name.endsWith(\"Cache\")).toBe(true);\n  });\n\n  test(\"should have 'get' method\", () => {\n    expect(<Name>Cache.prototype.get).toBeDefined();\n    expect(typeof <Name>Cache.prototype.get).toBe(\"function\");\n  });\n\n  test(\"should have 'set' method\", () => {\n    expect(<Name>Cache.prototype.set).toBeDefined();\n    expect(typeof <Name>Cache.prototype.set).toBe(\"function\");\n  });\n\n  test(\"should have 'delete' method\", () => {\n    expect(<Name>Cache.prototype.delete).toBeDefined();\n    expect(typeof <Name>Cache.prototype.delete).toBe(\"function\");\n  });\n\n  test(\"should have 'has' method\", () => {\n    expect(<Name>Cache.prototype.has).toBeDefined();\n    expect(typeof <Name>Cache.prototype.has).toBe(\"function\");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/cache/<Name>Cache.ts tests/cache/<Name>Cache.spec.ts\n```\n";
+  }),
+  response: Assert({
 
-// src/templates/claude/skills/make.controller.md.txt
-var make_controller_md_default = "---\nname: make:controller\ndescription: Generate a new controller class with route type and test file, then complete the generated code. Use when creating a new HTTP or WebSocket controller with routing, validation, and role-based access.\n---\n\n# Make Controller Class\n\nGenerate a new controller class, its route type, and test file using the `make:controller` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the controller class and related files:\n\n```bash\nbunx @ooneex/cli@latest make:controller --name=<name> --module=<module> --is-socket=<true|false> --route-name=<route.name> --route-path=<route.path> --route-method=<route.method>\n```\n\nWhere:\n- `<name>` is the controller name provided by the user\n- `--module` is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root\n- `--is-socket` determines HTTP vs WebSocket controller (defaults to `false`)\n- `--route-name` is the route name using dot notation: `<resource>.<action>` (e.g., `user.create`, `book.list`, `flashcard.delete`)\n- `--route-path` is the route path (e.g., `/api/users`)\n- `--route-method` is the HTTP method (e.g., `get`, `post`, `put`, `patch`, `delete`) \u2014 only for HTTP controllers\n\nThe command will generate (paths prefixed with `modules/<module>/` when `--module` is provided):\n- `src/controllers/<Name>Controller.ts` - The controller class file\n- `src/types/routes/<route.name>.ts` - The route type file (will be moved into the controller file \u2014 see step 3)\n- `tests/controllers/<Name>Controller.spec.ts` - The test file\n\n### 2. Read the generated files\n\nRead all three generated files to understand the scaffolded code.\n\n### 3. Complete the route type\n\n**IMPORTANT: Keep the route type inside the controller file**, not in a separate type file. Define the type directly in `src/controllers/<Name>Controller.ts` above the class definition. Delete the generated `src/types/routes/<route.name>.ts` file if it was created.\n\n**Remove unnecessary `params`, `payload`, and `queries` \u2014 only include what the route actually needs:**\n\n- **`params`** \u2014 Include only when the route path contains dynamic segments (e.g., `/api/users/:id`). Remove entirely for routes with no URL parameters (e.g., `/api/users`).\n- **`payload`** \u2014 Include only for methods that accept a request body (`post`, `put`, `patch`). Remove entirely for `get` and `delete` routes.\n- **`queries`** \u2014 Include only when the route supports query string filtering, pagination, or sorting (e.g., list/search endpoints). Remove entirely when not needed.\n- **`response`** \u2014 Always include.\n\nThe route type structure follows this pattern (remove unused sections):\n\n```typescript\n// Example: GET /api/users (list) \u2014 no params, no payload, has queries\ntype <TypeName>RouteType = {\n  queries: {\n\n  },\n  response: {\n\n  },\n};\n\n// Example: POST /api/users (create) \u2014 no params, has payload, no queries\ntype <TypeName>RouteType = {\n  payload: {\n\n  },\n  response: {\n\n  },\n};\n\n// Example: GET /api/users/:id (detail) \u2014 has params, no payload, no queries\ntype <TypeName>RouteType = {\n  params: {\n\n  },\n  response: {\n\n  },\n};\n\n// Example: PUT /api/users/:id (update) \u2014 has params, has payload, no queries\ntype <TypeName>RouteType = {\n  params: {\n\n  },\n  payload: {\n\n  },\n  response: {\n\n  },\n};\n```\n\n### 4. Complete the controller class\n\nEdit `src/controllers/<Name>Controller.ts` to complete the implementation:\n\n- Set appropriate `roles` for access control\n- Add a meaningful `description` for the route that explains what the endpoint does (e.g., `\"Create a new user account\"`, `\"List all books with pagination\"`)\n- **Keep the controller thin** \u2014 do NOT put business logic in the controller. Put all logic in the corresponding service and inject the service into the controller via the constructor. The controller's `index` method should only delegate to the service.\n- **Remove unnecessary `params`, `payload`, and `queries`** from both the route type and the `@Route` decorator \u2014 only include what the route actually needs (see step 3 rules).\n\n**Add or remove `params`, `payload`, and `queries` in the `@Route` decorator to match the route type (step 3):**\n\n- **`params`** \u2014 Include with `Assert()` validators only when the route has URL parameters. Remove the `params` key entirely otherwise.\n- **`payload`** \u2014 Include with `Assert({...})` only for `post`, `put`, `patch` methods. Remove the `payload` key entirely for `get` and `delete`.\n- **`queries`** \u2014 Include with `Assert({...})` only when query parameters are expected. Remove the `queries` key entirely otherwise.\n- **`response`** \u2014 Always include with `Assert({...})`.\n\n**HTTP controller** generated structure (remove `params`, `payload`, `queries` as needed \u2014 see rules above):\n\n```typescript\nimport type { ContextType } from \"@ooneex/controller\";\nimport { ERole } from \"@ooneex/role\";\nimport { Route } from \"@ooneex/routing\";\nimport { Assert } from \"@ooneex/validation\";\n\ntype <TypeName>RouteType = {\n  // Only include params, payload, queries as needed (see step 3)\n  response: {\n\n  },\n};\n\n@Route.<method>(\"<route.path>\", {\n  name: \"<route.name>\",\n  version: 1,\n  description: \"\",\n  // Only include params, payload, queries as needed (see step 3)\n  response: Assert({\n\n  }),\n  roles: [ERole.USER],\n})\nexport class <Name>Controller {\n  public async index(context: ContextType<<TypeName>RouteType>) {\n    return context.response.json({\n\n    });\n  }\n}\n```\n\n**Socket controller** generated structure (remove `params`, `payload`, `queries` as needed \u2014 see rules above):\n\n```typescript\nimport type { ContextType } from \"@ooneex/socket\";\nimport { ERole } from \"@ooneex/role\";\nimport { Route } from \"@ooneex/routing\";\nimport { Assert } from \"@ooneex/validation\";\n\ntype <TypeName>RouteType = {\n  // Only include params, payload, queries as needed (see step 3)\n  response: {\n\n  },\n};\n\n@Route.socket(\"<route.path>\", {\n  name: \"<route.name>\",\n  version: 1,\n  description: \"\",\n  // Only include params, payload, queries as needed (see step 3)\n  response: Assert({\n\n  }),\n  roles: [ERole.USER],\n})\nexport class <Name>Controller {\n  public async index(context: ContextType<<TypeName>RouteType>) {\n    return context.response.json({\n\n    });\n  }\n}\n```\n\n### 5. Complete the test file\n\nEdit `tests/controllers/<Name>Controller.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, index method)\n- Add tests relevant to the specific controller behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>Controller } from \"@/controllers/<Name>Controller\";\n\ndescribe(\"<Name>Controller\", () => {\n  test(\"should have class name ending with 'Controller'\", () => {\n    expect(<Name>Controller.name.endsWith(\"Controller\")).toBe(true);\n  });\n\n  test(\"should have 'index' method\", () => {\n    expect(<Name>Controller.prototype.index).toBeDefined();\n    expect(typeof <Name>Controller.prototype.index).toBe(\"function\");\n  });\n});\n```\n\n### 6. Register the controller in the module\n\nAdd the new controller to the module's `controllers` array in `src/<PascalModuleName>Module.ts` (e.g., `src/BookModule.ts` for the `book` module):\n\n```typescript\nimport type { ModuleType } from \"@ooneex/module\";\nimport { <Name>Controller } from \"./controllers/<Name>Controller\";\n\nexport const <PascalModuleName>Module: ModuleType = {\n  controllers: [<Name>Controller],\n  entities: [],\n  middlewares: [],\n  cronJobs: [],\n  events: [],\n};\n```\n\nThe module file uses PascalCase naming: `<PascalModuleName>Module.ts` with export `<PascalModuleName>Module`.\n\nIf the module already has other controllers registered, append the new controller to the existing `controllers` array and add the import alongside existing imports.\n\n### 7. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/controllers/<Name>Controller.ts tests/controllers/<Name>Controller.spec.ts\n```\n\n### 8. Create the service\n\nAfter the controller is created, generate a service class for the controller's business logic using the `make:service` skill:\n\n```\n/make:service --name=<Name>\n```\n\nWhere `<Name>` matches the controller name (e.g., if the controller is `CreateUserController`, the service is `CreateUserService`).\n\n### 9. Create the pubsub event\n\nAfter the service is created, generate a pubsub event class for the controller's domain events using the `make:pubsub` skill:\n\n```\n/make:pubsub --name=<Name> --channel=<resource>.<action>\n```\n\nWhere:\n- `<Name>` matches the controller name (e.g., if the controller is `CreateUserController`, the event is `CreateUserEvent`)\n- `<resource>.<action>` follows the same dot notation as the route name (e.g., `user.create`, `book.delete`)\n\nOnce the event is created:\n- Inject the **service** into the **event** via the constructor, and call the service's `execute` method from the event's `handler` method.\n- Inject the **event** into the **controller** via the constructor, and publish the event from the controller's `index` method.\n";
+  }),
+  roles: [ERole.USER],
+})
+export class {{NAME}}Controller {
+  public async index(context: ContextType<{{TYPE_NAME}}RouteType>) {
+    // const { id } = context.params;
 
-// src/templates/claude/skills/make.cron.md.txt
-var make_cron_md_default = "---\nname: make:cron\ndescription: Generate a new cron job class with its test file, then complete the generated code. Use when creating a new scheduled task that extends the Cron base class from @ooneex/cron.\n---\n\n# Make Cron Class\n\nGenerate a new cron class and its test file using the `make:cron` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the cron class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:cron --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/cron/<Name>Cron.ts` - The cron class file (or `modules/<module>/src/cron/<Name>Cron.ts` with `--module`)\n- `tests/cron/<Name>Cron.spec.ts` - The test file (or `modules/<module>/tests/cron/<Name>Cron.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the cron class\n\nEdit `src/cron/<Name>Cron.ts` to complete the implementation:\n\n- Set the appropriate cron schedule in `getTime()` (e.g., `\"every 5 minutes\"`, `\"every 1 hours\"`, `\"every 30 seconds\"`)\n- Set the timezone in `getTimeZone()` if needed, or keep `null` for server timezone\n- Implement the `handler()` method with the actual cron job logic\n- Inject any required dependencies via the constructor\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport type { TimeZoneType } from \"@ooneex/country\";\nimport { Cron, type CronTimeType, decorator } from \"@ooneex/cron\";\n\n@decorator.cron()\nexport class <Name>Cron extends Cron {\n  public getTime(): CronTimeType {\n    // Examples: \"every 5 minutes\", \"every 1 hours\", \"every 30 seconds\"\n    return \"every 1 hours\";\n  }\n\n  public getTimeZone(): TimeZoneType | null {\n    // Return null to use server timezone, or specify a timezone like \"Europe/Paris\"\n    return null;\n  }\n\n  public async handler(): Promise<void> {\n    // Implement your cron handler logic here\n    // console.log(\"<Name>Cron handler executed\");\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/cron/<Name>Cron.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, getTime, getTimeZone, handler methods)\n- Add tests relevant to the specific cron class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>Cron } from \"@/cron/<Name>Cron\";\n\ndescribe(\"<Name>Cron\", () => {\n  test(\"should have class name ending with 'Cron'\", () => {\n    expect(<Name>Cron.name.endsWith(\"Cron\")).toBe(true);\n  });\n\n  test(\"should have 'getTime' method\", () => {\n    expect(<Name>Cron.prototype.getTime).toBeDefined();\n    expect(typeof <Name>Cron.prototype.getTime).toBe(\"function\");\n  });\n\n  test(\"should have 'getTimeZone' method\", () => {\n    expect(<Name>Cron.prototype.getTimeZone).toBeDefined();\n    expect(typeof <Name>Cron.prototype.getTimeZone).toBe(\"function\");\n  });\n\n  test(\"should have 'handler' method\", () => {\n    expect(<Name>Cron.prototype.handler).toBeDefined();\n    expect(typeof <Name>Cron.prototype.handler).toBe(\"function\");\n  });\n});\n```\n\n### 5. Register the cron job in the module\n\nAdd the new cron job to the module's `cronJobs` array in `src/<PascalModuleName>Module.ts` (e.g., `src/BookModule.ts` for the `book` module):\n\n```typescript\nimport type { ModuleType } from \"@ooneex/module\";\nimport { <Name>Cron } from \"./cron/<Name>Cron\";\n\nexport const <PascalModuleName>Module: ModuleType = {\n  controllers: [],\n  entities: [],\n  middlewares: [],\n  cronJobs: [<Name>Cron],\n  events: [],\n};\n```\n\nThe module file uses PascalCase naming: `<PascalModuleName>Module.ts` with export `<PascalModuleName>Module`.\n\nIf the module already has other cron jobs registered, append the new cron job to the existing `cronJobs` array and add the import alongside existing imports.\n\n### 6. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/cron/<Name>Cron.ts tests/cron/<Name>Cron.spec.ts\n```\n";
+    return context.response.json({
+
+    });
+  }
+}
+`;
 
-// src/templates/claude/skills/make.database.md.txt
-var make_database_md_default = "---\nname: make:database\ndescription: Generate a new database class with its test file, then complete the generated code. Use when creating a new database adapter that extends TypeormDatabase from @ooneex/database.\n---\n\n# Make Database Class\n\nGenerate a new database class and its test file using the `make:database` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the database class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:database --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/databases/<Name>Database.ts` - The database class file (or `modules/<module>/src/databases/<Name>Database.ts` with `--module`)\n- `tests/databases/<Name>Database.spec.ts` - The test file (or `modules/<module>/tests/databases/<Name>Database.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the database class\n\nEdit `src/databases/<Name>Database.ts` to complete the implementation:\n\n- Add entity imports and register them in the `entities` array\n- Adjust the database path if needed (default is `\"var/db\"`)\n- Configure DataSource options as appropriate (type, synchronize, etc.)\n- Inject any required dependencies via the constructor\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { DataSource } from \"typeorm\";\nimport { TypeormDatabase, DatabaseException, decorator } from \"@ooneex/database\";\n\n@decorator.database()\nexport class <Name>Database extends TypeormDatabase {\n  public getSource(database?: string): DataSource {\n    database = database || \"var/db\";\n\n    this.source = new DataSource({\n      synchronize: false,\n      entities: [\n        // TODO: Load your entities here\n      ],\n      enableWAL: true,\n      busyErrorRetry: 2000,\n      busyTimeout: 30_000,\n      database,\n      type: \"sqlite\",\n    });\n\n    return this.source;\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/databases/<Name>Database.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, getSource method)\n- Add tests relevant to the specific database class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>Database } from \"@/databases/<Name>Database\";\n\ndescribe(\"<Name>Database\", () => {\n  test(\"should have class name ending with 'Database'\", () => {\n    expect(<Name>Database.name.endsWith(\"Database\")).toBe(true);\n  });\n\n  test(\"should have 'getSource' method\", () => {\n    expect(<Name>Database.prototype.getSource).toBeDefined();\n    expect(typeof <Name>Database.prototype.getSource).toBe(\"function\");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/databases/<Name>Database.ts tests/databases/<Name>Database.spec.ts\n```\n";
+// src/templates/controller.test.txt
+var controller_test_default = `import { describe, expect, test } from "bun:test";
+import { {{NAME}}Controller } from "@/controllers/{{NAME}}Controller";
 
-// src/templates/claude/skills/make.entity.md.txt
-var make_entity_md_default = "---\nname: make:entity\ndescription: Generate a new TypeORM entity class with its test file, then complete the generated code. Use when creating a new database entity with columns, relations, and table mapping.\n---\n\n# Make Entity Class\n\nGenerate a new entity class and its test file using the `make:entity` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n- Avoid non-null assertions (`!`). For example, `public name!: string;` should be `public name: string;`\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the entity class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:entity --name=<name> --module=<module> --table-name=<table_name>\n```\n\nWhere `<name>` is the name provided by the user. The `--table-name` option is optional \u2014 if omitted, it defaults to the snake_case pluralized form of the name (e.g., `UserProfile` becomes `user_profiles`). The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/entities/<Name>Entity.ts` - The entity class file (or `modules/<module>/src/entities/<Name>Entity.ts` with `--module`)\n- `tests/entities/<Name>Entity.spec.ts` - The test file (or `modules/<module>/tests/entities/<Name>Entity.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the entity class\n\nEdit `src/entities/<Name>Entity.ts` to complete the implementation:\n\n- Add entity-specific columns with appropriate TypeORM decorators (`@Column`)\n- Add relations if needed (`@ManyToOne`, `@OneToMany`, `@ManyToMany`, etc.)\n- Remove any scaffolded columns that are not relevant to the entity\n- Adjust column types, lengths, and constraints as needed\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport type { LocaleType } from \"@ooneex/translation\";\nimport { random } from \"@ooneex/utils\";\nimport { Column, CreateDateColumn, DeleteDateColumn, PrimaryColumn, UpdateDateColumn } from \"typeorm\";\n\n@Entity({\n  name: \"<table_name>\",\n})\nexport class <Name>Entity extends BaseEntity {\n  @PrimaryColumn({ name: \"id\", type: \"varchar\", length: 25 })\n  id: string = random.nanoid(25);\n\n  @Column({\n    name: \"is_locked\",\n    type: \"boolean\",\n    default: false,\n    nullable: true,\n  })\n  isLocked?: boolean;\n\n  @Column({ name: \"locked_at\", type: \"timestamptz\", nullable: true })\n  lockedAt?: Date;\n\n  @Column({\n    name: \"is_blocked\",\n    type: \"boolean\",\n    default: false,\n    nullable: true,\n  })\n  isBlocked?: boolean;\n\n  @Column({ name: \"blocked_at\", type: \"timestamptz\", nullable: true })\n  blockedAt?: Date;\n\n  @Column({ name: \"block_reason\", type: \"text\", nullable: true })\n  blockReason?: string;\n\n  @Column({ name: \"is_public\", type: \"boolean\", default: true, nullable: true })\n  isPublic?: boolean;\n\n  @Column({ name: \"lang\", type: \"varchar\", length: 10, nullable: true })\n  lang?: LocaleType;\n\n  @CreateDateColumn({ name: \"created_at\" })\n  createdAt?: Date;\n\n  @UpdateDateColumn({ name: \"updated_at\" })\n  updatedAt?: Date;\n\n  @DeleteDateColumn({ name: \"deleted_at\" })\n  deletedAt?: Date;\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/entities/<Name>Entity.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, id, default columns)\n- Add tests for any new entity-specific columns and relations\n- Update tests if scaffolded columns were removed\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>Entity } from \"@/entities/<Name>Entity\";\n\ndescribe(\"<Name>Entity\", () => {\n  test(\"should have class name ending with 'Entity'\", () => {\n    expect(<Name>Entity.name.endsWith(\"Entity\")).toBe(true);\n  });\n\n  test(\"should have 'id' property with default nanoid\", () => {\n    const entity = new <Name>Entity();\n    expect(entity.id).toBeDefined();\n    expect(typeof entity.id).toBe(\"string\");\n    expect(entity.id.length).toBe(25);\n  });\n\n  test(\"should have 'isLocked' property\", () => {\n    const entity = new <Name>Entity();\n    expect(\"isLocked\" in entity).toBe(true);\n  });\n\n  // ... additional property tests\n});\n```\n\n### 5. Register the entity in the module\n\nAdd the new entity to the module's `entities` array in `src/<PascalModuleName>Module.ts` (e.g., `src/BookModule.ts` for the `book` module):\n\n```typescript\nimport type { ModuleType } from \"@ooneex/module\";\nimport { <Name>Entity } from \"./entities/<Name>Entity\";\n\nexport const <PascalModuleName>Module: ModuleType = {\n  controllers: [],\n  entities: [<Name>Entity],\n  middlewares: [],\n  cronJobs: [],\n  events: [],\n};\n```\n\nThe module file uses PascalCase naming: `<PascalModuleName>Module.ts` with export `<PascalModuleName>Module`.\n\nIf the module already has other entities registered, append the new entity to the existing `entities` array and add the import alongside existing imports.\n\n### 6. Create a migration for the entity\n\nAfter creating or updating an entity, generate a migration to apply the corresponding schema changes to the database.\n\nRun the generator:\n\n```bash\nbunx @ooneex/cli@latest make:migration\n```\n\nThen read the generated migration file in `src/migrations/` and complete it:\n\n- In the `up` method, write the SQL to create the table (or alter it if updating an existing entity). Include all columns, types, constraints, defaults, and indexes matching the entity definition.\n- In the `down` method, write the reverse SQL to undo the changes (e.g., `DROP TABLE` or `ALTER TABLE DROP COLUMN`).\n- If the migration depends on another migration (e.g., a foreign key referencing another table), add that migration class to the `getDependencies()` return array.\n\nExample `up` method for a new entity:\n\n```typescript\npublic async up(tx: TransactionSQL): Promise<void> {\n  await tx`\n    CREATE TABLE IF NOT EXISTS <table_name> (\n      id VARCHAR(25) PRIMARY KEY,\n      is_locked BOOLEAN DEFAULT false,\n      locked_at TIMESTAMPTZ,\n      is_blocked BOOLEAN DEFAULT false,\n      blocked_at TIMESTAMPTZ,\n      block_reason TEXT,\n      is_public BOOLEAN DEFAULT true,\n      lang VARCHAR(10),\n      created_at TIMESTAMPTZ DEFAULT NOW(),\n      updated_at TIMESTAMPTZ DEFAULT NOW(),\n      deleted_at TIMESTAMPTZ\n    )\n  `;\n}\n```\n\n### 7. Create a repository for the entity\n\nAfter creating the entity, generate a repository to handle database operations for it.\n\nRun the generator:\n\n```bash\nbunx @ooneex/cli@latest make:repository --name=<name>\n```\n\nWhere `<name>` is the same name used for the entity. The command will generate:\n- `src/repositories/<Name>Repository.ts` - The repository class\n- `tests/repositories/<Name>Repository.spec.ts` - The test file\n\nThen read the generated files and complete the repository implementation:\n\n- Adjust search fields in the `find()` method to match the entity's searchable columns\n- Customize relations loading in `findOne`/`findOneBy` if the entity has relations\n- Add any domain-specific methods relevant to the entity\n- Remove methods that don't apply to the entity\n- Update tests to match the final repository methods\n\n### 8. Lint and format\n\nRun linting and formatting on all generated files:\n\n```bash\nbunx biome check --fix src/entities/<Name>Entity.ts tests/entities/<Name>Entity.spec.ts src/repositories/<Name>Repository.ts tests/repositories/<Name>Repository.spec.ts src/migrations/\n```\n";
+describe("{{NAME}}Controller", () => {
+  test("should have class name ending with 'Controller'", () => {
+    expect({{NAME}}Controller.name.endsWith("Controller")).toBe(true);
+  });
 
-// src/templates/claude/skills/make.logger.md.txt
-var make_logger_md_default = "---\nname: make:logger\ndescription: Generate a new logger class with its test file, then complete the generated code. Use when creating a new logger that implements the ILogger interface from @ooneex/logger.\n---\n\n# Make Logger Class\n\nGenerate a new logger class and its test file using the `make:logger` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the logger class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:logger --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/loggers/<Name>Logger.ts` - The logger class file (or `modules/<module>/src/loggers/<Name>Logger.ts` with `--module`)\n- `tests/loggers/<Name>Logger.spec.ts` - The test file (or `modules/<module>/tests/loggers/<Name>Logger.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the logger class\n\nEdit `src/loggers/<Name>Logger.ts` to complete the implementation:\n\n- Implement the `init()` method to set up the logger (e.g., open file handles, configure transports)\n- Implement `log`, `debug`, `info`, `success`, `warn`, and `error` methods with actual logging logic\n- Inject any required dependencies via the constructor\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport type { IException } from \"@ooneex/exception\";\nimport { type ILogger, decorator } from \"@ooneex/logger\";\nimport type { ScalarType } from \"@ooneex/types\";\n\n@decorator.logger()\nexport class <Name>Logger implements ILogger {\n  public async init(): Promise<void> {\n    // Initialize your logger here\n  }\n\n  public log(message: string, data?: Record<string, ScalarType>): void {\n    // Handle general logging\n  }\n\n  public debug(message: string, data?: Record<string, ScalarType>): void {\n    // Handle debug logging\n  }\n\n  public info(message: string, data?: Record<string, ScalarType>): void {\n    // Handle info logging\n  }\n\n  public success(message: string, data?: Record<string, ScalarType>): void {\n    // Handle success logging\n  }\n\n  public warn(message: string, data?: Record<string, ScalarType>): void {\n    // Handle warning logging\n  }\n\n  public error(message: string | IException, data?: Record<string, ScalarType>): void {\n    // Handle error logging\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/loggers/<Name>Logger.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, init, log, debug, info, success, warn, error methods)\n- Add tests relevant to the specific logger class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>Logger } from \"@/loggers/<Name>Logger\";\n\ndescribe(\"<Name>Logger\", () => {\n  test(\"should have class name ending with 'Logger'\", () => {\n    expect(<Name>Logger.name.endsWith(\"Logger\")).toBe(true);\n  });\n\n  test(\"should have 'init' method\", () => {\n    expect(<Name>Logger.prototype.init).toBeDefined();\n    expect(typeof <Name>Logger.prototype.init).toBe(\"function\");\n  });\n\n  test(\"should have 'log' method\", () => {\n    expect(<Name>Logger.prototype.log).toBeDefined();\n    expect(typeof <Name>Logger.prototype.log).toBe(\"function\");\n  });\n\n  test(\"should have 'debug' method\", () => {\n    expect(<Name>Logger.prototype.debug).toBeDefined();\n    expect(typeof <Name>Logger.prototype.debug).toBe(\"function\");\n  });\n\n  test(\"should have 'info' method\", () => {\n    expect(<Name>Logger.prototype.info).toBeDefined();\n    expect(typeof <Name>Logger.prototype.info).toBe(\"function\");\n  });\n\n  test(\"should have 'success' method\", () => {\n    expect(<Name>Logger.prototype.success).toBeDefined();\n    expect(typeof <Name>Logger.prototype.success).toBe(\"function\");\n  });\n\n  test(\"should have 'warn' method\", () => {\n    expect(<Name>Logger.prototype.warn).toBeDefined();\n    expect(typeof <Name>Logger.prototype.warn).toBe(\"function\");\n  });\n\n  test(\"should have 'error' method\", () => {\n    expect(<Name>Logger.prototype.error).toBeDefined();\n    expect(typeof <Name>Logger.prototype.error).toBe(\"function\");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/loggers/<Name>Logger.ts tests/loggers/<Name>Logger.spec.ts\n```\n";
+  test("should have 'index' method", () => {
+    expect({{NAME}}Controller.prototype.index).toBeDefined();
+    expect(typeof {{NAME}}Controller.prototype.index).toBe("function");
+  });
+});
+`;
 
-// src/templates/claude/skills/make.mailer.md.txt
-var make_mailer_md_default = "---\nname: make:mailer\ndescription: Generate a new mailer class with its template and test files, then complete the generated code. Use when creating a new email sender with JSX template using @ooneex/mailer.\n---\n\n# Make Mailer Class\n\nGenerate a new mailer class, its JSX template, and test files using the `make:mailer` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the mailer class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:mailer --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate (paths prefixed with `modules/<module>/` when `--module` is provided):\n- `src/mailers/<Name>Mailer.ts` - The mailer class file\n- `src/mailers/<Name>MailerTemplate.tsx` - The JSX email template\n- `tests/mailers/<Name>Mailer.spec.ts` - The mailer test file\n- `tests/mailers/<Name>MailerTemplate.spec.ts` - The template test file\n\n### 2. Read the generated files\n\nRead all four generated files to understand the scaffolded code.\n\n### 3. Complete the mailer class\n\nEdit `src/mailers/<Name>Mailer.ts` to complete the implementation:\n\n- Adjust the `send` method config type if additional parameters are needed\n- Add any pre-send logic (validation, data transformation, etc.)\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { inject } from \"@ooneex/container\";\nimport type { IMailer } from \"@ooneex/mailer\";\nimport { type <Name>MailerPropsType, <Name>MailerTemplate } from \"./<Name>MailerTemplate\";\n\nexport class <Name>Mailer implements IMailer {\n  constructor(\n    @inject(\"mailer\")\n    private readonly mailer: IMailer,\n  ) {}\n\n  public send = async (config: {\n    to: string[];\n    subject: string;\n    from?: { name: string; address: string };\n    data?: <Name>MailerPropsType;\n  }): Promise<void> => {\n    const { data, ...rest } = config;\n\n    await this.mailer.send({\n      ...rest,\n      content: <Name>MailerTemplate(data),\n    });\n  };\n}\n```\n\n### 4. Complete the mailer template\n\nEdit `src/mailers/<Name>MailerTemplate.tsx` to complete the implementation:\n\n- Update `<Name>MailerPropsType` with the actual props needed for the email\n- Build the email body using `MailerLayout` components (Header, Body, Footer)\n- Add email content, styling, and dynamic data rendering\n\nThe generated template structure follows this pattern:\n\n```tsx\nimport { MailerLayout } from \"@ooneex/mailer\";\n\nexport type <Name>MailerPropsType = {\n  link: string;\n};\n\nexport const <Name>MailerTemplate = (props?: <Name>MailerPropsType) => (\n  <MailerLayout>\n    <MailerLayout.Header />\n    <MailerLayout.Body>\n      <a href={props?.link}>Login</a>\n    </MailerLayout.Body>\n    <MailerLayout.Footer />\n  </MailerLayout>\n);\n```\n\n### 5. Complete the test files\n\nEdit `tests/mailers/<Name>Mailer.spec.ts` and `tests/mailers/<Name>MailerTemplate.spec.ts` to add meaningful tests beyond the scaffolded ones.\n\n### 6. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/mailers/<Name>Mailer.ts src/mailers/<Name>MailerTemplate.tsx tests/mailers/<Name>Mailer.spec.ts tests/mailers/<Name>MailerTemplate.spec.ts\n```\n";
+// src/templates/controller.txt
+var controller_default = `import type { ContextType } from "@ooneex/controller";
+import { ERole } from "@ooneex/role";
+import { Route } from "@ooneex/routing";
+import { Assert } from "@ooneex/validation";
 
-// src/templates/claude/skills/make.middleware.md.txt
-var make_middleware_md_default = "---\nname: make:middleware\ndescription: Generate a new middleware class with its test file, then complete the generated code. Use when creating a new HTTP or WebSocket middleware that implements IMiddleware from @ooneex/middleware.\n---\n\n# Make Middleware Class\n\nGenerate a new middleware class and its test file using the `make:middleware` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the middleware class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:middleware --name=<name> --module=<module> --is-socket=<true|false>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The `--is-socket` option determines whether to generate an HTTP middleware or a WebSocket middleware (defaults to `false` if omitted). The command will generate:\n- `src/middlewares/<Name>Middleware.ts` - The middleware class file (or `modules/<module>/src/middlewares/<Name>Middleware.ts` with `--module`)\n- `tests/middlewares/<Name>Middleware.spec.ts` - The test file (or `modules/<module>/tests/middlewares/<Name>Middleware.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the middleware class\n\nEdit `src/middlewares/<Name>Middleware.ts` to complete the implementation:\n\n- Implement the `handler` method with actual middleware logic\n- Add request/response transformations, authentication checks, logging, etc.\n- Inject any required dependencies via the constructor\n\n**HTTP middleware** generated structure:\n\n```typescript\nimport type { ContextType } from \"@ooneex/controller\";\nimport { decorator, type IMiddleware } from \"@ooneex/middleware\";\n\n@decorator.middleware()\nexport class <Name>Middleware implements IMiddleware {\n  public async handler(context: ContextType): Promise<ContextType> {\n    // Example: Add custom header\n    // context.response.header(\"X-Custom-Header\", \"value\");\n\n    return context\n  }\n}\n```\n\n**Socket middleware** generated structure:\n\n```typescript\nimport type { ContextType } from \"@ooneex/socket\";\nimport { decorator, type IMiddleware } from \"@ooneex/middleware\";\n\n@decorator.middleware()\nexport class <Name>Middleware implements IMiddleware {\n  public async handler(context: ContextType): Promise<ContextType> {\n    // Example: Add custom header\n    // context.response.header(\"X-Custom-Header\", \"value\");\n\n    return context\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/middlewares/<Name>Middleware.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, handler method)\n- Add tests relevant to the specific middleware behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>Middleware } from \"@/middlewares/<Name>Middleware\";\n\ndescribe(\"<Name>Middleware\", () => {\n  test(\"should have class name ending with 'Middleware'\", () => {\n    expect(<Name>Middleware.name.endsWith(\"Middleware\")).toBe(true);\n  });\n\n  test(\"should have 'handler' method\", () => {\n    expect(<Name>Middleware.prototype.handler).toBeDefined();\n    expect(typeof <Name>Middleware.prototype.handler).toBe(\"function\");\n  });\n});\n```\n\n### 5. Register the middleware in the module\n\nAdd the new middleware to the module's `middlewares` array in `src/<PascalModuleName>Module.ts` (e.g., `src/BookModule.ts` for the `book` module):\n\n```typescript\nimport type { ModuleType } from \"@ooneex/module\";\nimport { <Name>Middleware } from \"./middlewares/<Name>Middleware\";\n\nexport const <PascalModuleName>Module: ModuleType = {\n  controllers: [],\n  entities: [],\n  middlewares: [<Name>Middleware],\n  cronJobs: [],\n  events: [],\n};\n```\n\nThe module file uses PascalCase naming: `<PascalModuleName>Module.ts` with export `<PascalModuleName>Module`.\n\nIf the module already has other middlewares registered, append the new middleware to the existing `middlewares` array and add the import alongside existing imports.\n\n### 6. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/middlewares/<Name>Middleware.ts tests/middlewares/<Name>Middleware.spec.ts\n```\n";
+export type {{TYPE_NAME}}RouteType = {
+  params: {
 
-// src/templates/claude/skills/make.migration.md.txt
-var make_migration_md_default = "---\nname: make:migration\ndescription: Generate a new database migration file with its test file, then complete the generated code. Use when creating a new database migration for schema changes using @ooneex/migrations.\n---\n\n# Make Migration\n\nGenerate a new migration file and its test file using the `make:migration` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the migration file and test files:\n\n```bash\nbunx @ooneex/cli@latest make:migration --module=<module>\n```\n\nThe `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/migrations/Migration<version>.ts` - The migration class file (or `modules/<module>/src/migrations/Migration<version>.ts` with `--module`)\n- `tests/migrations/Migration<version>.spec.ts` - The test file (or `modules/<module>/tests/migrations/Migration<version>.spec.ts` with `--module`)\n\nIt will also:\n- Generate a `migrations.ts` root export file in the migrations directory\n- Add a `migration:up` script to `package.json` if not already present\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the migration\n\nEdit `src/migrations/Migration<version>.ts` to implement:\n\n- The `up` method with the schema changes (create tables, add columns, create indexes, etc.)\n- The `down` method with the reverse operations to undo the migration\n\n### 4. Complete the test file\n\nEdit `tests/migrations/Migration<version>.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, up, down, getVersion, getDependencies methods)\n- Add tests relevant to the specific migration behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { Migration<version> } from \"@/migrations/Migration<version>\";\n\ndescribe(\"Migration<version>\", () => {\n  test(\"should have class name starting with 'Migration'\", () => {\n    expect(Migration<version>.name.startsWith(\"Migration\")).toBe(true);\n  });\n\n  test(\"should have 'up' method\", () => {\n    expect(Migration<version>.prototype.up).toBeDefined();\n    expect(typeof Migration<version>.prototype.up).toBe(\"function\");\n  });\n\n  test(\"should have 'down' method\", () => {\n    expect(Migration<version>.prototype.down).toBeDefined();\n    expect(typeof Migration<version>.prototype.down).toBe(\"function\");\n  });\n\n  test(\"should have 'getVersion' method\", () => {\n    expect(Migration<version>.prototype.getVersion).toBeDefined();\n    expect(typeof Migration<version>.prototype.getVersion).toBe(\"function\");\n  });\n\n  test(\"should have 'getDependencies' method\", () => {\n    expect(Migration<version>.prototype.getDependencies).toBeDefined();\n    expect(typeof Migration<version>.prototype.getDependencies).toBe(\"function\");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/migrations/Migration<version>.ts tests/migrations/Migration<version>.spec.ts\n```\n";
+  },
+  payload: {
 
-// src/templates/claude/skills/make.permission.md.txt
-var make_permission_md_default = "---\nname: make:permission\ndescription: Generate a new permission class with its test file, then complete the generated code. Use when creating a new permission that extends Permission from @ooneex/permission.\n---\n\n# Make Permission Class\n\nGenerate a new permission class and its test file using the `make:permission` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the permission class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:permission --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/permissions/<Name>Permission.ts` - The permission class file (or `modules/<module>/src/permissions/<Name>Permission.ts` with `--module`)\n- `tests/permissions/<Name>Permission.spec.ts` - The test file (or `modules/<module>/tests/permissions/<Name>Permission.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the permission class\n\nEdit `src/permissions/<Name>Permission.ts` to complete the implementation:\n\n- Implement the `allow()` method with permission rules using `this.ability.can()`\n- Implement the `setUserPermissions()` method with role-based permission logic\n- Define which actions (read, create, update, delete, manage) are allowed on which entities\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { decorator, Permission } from \"@ooneex/permission\";\nimport type { IUser } from \"@ooneex/user\";\n\n@decorator.permission()\nexport class <Name>Permission extends Permission {\n  public allow(): this {\n    // Example: Add permissions using this.ability.can()\n    // this.ability.can(\"read\", \"YourEntity\");\n    // this.ability.can([\"read\", \"update\"], \"YourEntity\", { userId: user.id });\n\n    return this;\n  }\n\n  public setUserPermissions(user: IUser | null): this {\n    if (!user) {\n      return this;\n    }\n\n    // Example: Grant full access to admins\n    // const { roles } = user;\n    // if (roles.includes(ERole.ADMIN)) {\n    //   this.ability.can(\"manage\", \"all\");\n    //   return this;\n    // }\n\n    // Example: Grant specific permissions based on roles\n    // for (const role of roles) {\n    //   if (role === ERole.USER) {\n    //     this.ability.can([\"read\", \"update\"], \"YourEntity\", { userId: user.id });\n    //   }\n    //\n    //   if (role === ERole.GUEST) {\n    //     this.ability.can(\"read\", \"YourEntity\", { public: true });\n    //   }\n    // }\n\n    return this;\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/permissions/<Name>Permission.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, extends Permission, allow, setUserPermissions methods)\n- Add tests relevant to the specific permission rules\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { Permission } from \"@ooneex/permission\";\nimport { <Name>Permission } from \"@/permissions/<Name>Permission\";\n\ndescribe(\"<Name>Permission\", () => {\n  test(\"should have class name ending with 'Permission'\", () => {\n    expect(<Name>Permission.name.endsWith(\"Permission\")).toBe(true);\n  });\n\n  test(\"should extend Permission\", () => {\n    const permission = new <Name>Permission();\n    expect(permission).toBeInstanceOf(Permission);\n  });\n\n  test(\"should have 'allow' method\", () => {\n    expect(<Name>Permission.prototype.allow).toBeDefined();\n    expect(typeof <Name>Permission.prototype.allow).toBe(\"function\");\n  });\n\n  test(\"should have 'setUserPermissions' method\", () => {\n    expect(<Name>Permission.prototype.setUserPermissions).toBeDefined();\n    expect(typeof <Name>Permission.prototype.setUserPermissions).toBe(\"function\");\n  });\n});\n```\n\n### 5. Register the permission in the module\n\nThe permission class is standalone and does not need to be registered in a module.\n\n### 6. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/permissions/<Name>Permission.ts tests/permissions/<Name>Permission.spec.ts\n```\n";
+  },
+  queries: {
 
-// src/templates/claude/skills/make.pubsub.md.txt
-var make_pubsub_md_default = "---\nname: make:pubsub\ndescription: Generate a new PubSub event class with its test file, then complete the generated code. Use when creating a new publish/subscribe event that extends PubSub from @ooneex/pub-sub.\n---\n\n# Make PubSub Event Class\n\nGenerate a new PubSub event class and its test file using the `make:pubsub` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the PubSub event class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:pubsub --name=<name> --module=<module> --channel=<channel>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The `--channel` option is optional \u2014 if omitted, it defaults to the kebab-case form of the name (e.g., `UserCreated` becomes `user-created`). The command will generate:\n- `src/events/<Name>Event.ts` - The event class file (or `modules/<module>/src/events/<Name>Event.ts` with `--module`)\n- `tests/events/<Name>Event.spec.ts` - The test file (or `modules/<module>/tests/events/<Name>Event.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the PubSub event class\n\nEdit `src/events/<Name>Event.ts` to complete the implementation:\n\n- Define a proper data type instead of `Record<string, ScalarType>` for the event payload\n- Implement the `handler()` method with actual event handling logic\n- Set the appropriate channel name in `getChannel()`\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { inject } from \"@ooneex/container\";\nimport type { ScalarType } from \"@ooneex/types\";\nimport { decorator, PubSub, RedisPubSub } from \"@ooneex/pub-sub\";\n\n@decorator.pubSub()\nexport class <Name>Event<Data extends Record<string, ScalarType> = Record<string, ScalarType>> extends PubSub<Data> {\n  constructor(\n    @inject(RedisPubSub)\n    client: RedisPubSub<Data>,\n  ) {\n    super(client);\n  }\n\n  public getChannel(): string {\n    return \"<channel>\";\n  }\n\n  public async handler(context: { data: Data; channel: string }): Promise<void> {\n    console.log(context);\n    // TODO: Implement handler logic here\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/events/<Name>Event.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, getChannel, handler, publish, subscribe, unsubscribe, unsubscribeAll methods)\n- Add tests relevant to the specific event behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>PubSub } from \"@/pubsub/<Name>PubSub\";\n\ndescribe(\"<Name>PubSub\", () => {\n  test(\"should have class name ending with 'PubSub'\", () => {\n    expect(<Name>PubSub.name.endsWith(\"PubSub\")).toBe(true);\n  });\n\n  test(\"should have 'getChannel' method\", () => {\n    expect(<Name>PubSub.prototype.getChannel).toBeDefined();\n    expect(typeof <Name>PubSub.prototype.getChannel).toBe(\"function\");\n  });\n\n  test(\"should have 'handler' method\", () => {\n    expect(<Name>PubSub.prototype.handler).toBeDefined();\n    expect(typeof <Name>PubSub.prototype.handler).toBe(\"function\");\n  });\n\n  test(\"should have 'publish' method\", () => {\n    expect(<Name>PubSub.prototype.publish).toBeDefined();\n    expect(typeof <Name>PubSub.prototype.publish).toBe(\"function\");\n  });\n\n  test(\"should have 'subscribe' method\", () => {\n    expect(<Name>PubSub.prototype.subscribe).toBeDefined();\n    expect(typeof <Name>PubSub.prototype.subscribe).toBe(\"function\");\n  });\n\n  test(\"should have 'unsubscribe' method\", () => {\n    expect(<Name>PubSub.prototype.unsubscribe).toBeDefined();\n    expect(typeof <Name>PubSub.prototype.unsubscribe).toBe(\"function\");\n  });\n\n  test(\"should have 'unsubscribeAll' method\", () => {\n    expect(<Name>PubSub.prototype.unsubscribeAll).toBeDefined();\n    expect(typeof <Name>PubSub.prototype.unsubscribeAll).toBe(\"function\");\n  });\n});\n```\n\n### 5. Register the event in the module\n\nAdd the new event to the module's `events` array in `src/<PascalModuleName>Module.ts` (e.g., `src/BookModule.ts` for the `book` module):\n\n```typescript\nimport type { ModuleType } from \"@ooneex/module\";\nimport { <Name>Event } from \"./events/<Name>Event\";\n\nexport const <PascalModuleName>Module: ModuleType = {\n  controllers: [],\n  entities: [],\n  middlewares: [],\n  cronJobs: [],\n  events: [<Name>Event],\n};\n```\n\nThe module file uses PascalCase naming: `<PascalModuleName>Module.ts` with export `<PascalModuleName>Module`.\n\nIf the module already has other events registered, append the new event to the existing `events` array and add the import alongside existing imports.\n\n### 6. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/events/<Name>Event.ts tests/events/<Name>Event.spec.ts\n```\n";
+  },
+  response: {
 
-// src/templates/claude/skills/make.repository.md.txt
-var make_repository_md_default = "---\nname: make:repository\ndescription: Generate a new repository class with its test file, then complete the generated code. Use when creating a new TypeORM repository for database operations on an entity.\n---\n\n# Make Repository Class\n\nGenerate a new repository class and its test file using the `make:repository` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the repository class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:repository --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/repositories/<Name>Repository.ts` - The repository class file (or `modules/<module>/src/repositories/<Name>Repository.ts` with `--module`)\n- `tests/repositories/<Name>Repository.spec.ts` - The test file (or `modules/<module>/tests/repositories/<Name>Repository.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the repository class\n\nEdit `src/repositories/<Name>Repository.ts` to complete the implementation:\n\n- Verify the entity import path matches the actual entity location\n- Adjust the `find` method's search fields (default searches `name` with `ILike`)\n- Customize relations loading in `findOne`/`findOneBy` if needed\n\n#### Adding methods\n\nLook at the entity's fields, relations, and business context to determine if custom domain-specific methods are needed. For example:\n- A `SessionRepository` might need `revokeSession(sessionId: string)` and `revokeAllUserSessions(userId: string)`\n- A `NotificationRepository` might need `markAsRead(id: string)` and `markAllAsRead(userId: string)`\n- Entities with status fields may need methods like `archive(id: string)` or `activate(id: string)`\n\nRead related entities, services, or actions in the module to understand what operations the repository should support, then add the appropriate methods.\n\n#### Removing methods\n\nRemove scaffolded methods that don't make sense for the entity's context:\n- Remove `createMany`/`updateMany` if the entity is always managed individually (e.g., user profiles, settings)\n- Remove `delete` if the entity uses soft deletes only (use a custom `softDelete` or `archive` method instead)\n- Remove `find` if the entity is only ever accessed by ID or specific criteria (e.g., singleton config entities)\n- Remove `count` if there's no use case for counting records of this entity\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { inject } from \"@ooneex/container\";\nimport type { ITypeormDatabase } from \"@ooneex/database\";\nimport { decorator } from \"@ooneex/repository\";\nimport type { FilterResultType } from \"@ooneex/types\";\nimport type { FindManyOptions, FindOptionsWhere, Repository, SaveOptions, UpdateResult } from \"typeorm\";\nimport { ILike } from \"typeorm\";\nimport { <Name>Entity } from \"../entities/<Name>Entity\";\n\n@decorator.repository()\nexport class <Name>Repository {\n  constructor(\n    @inject(\"database\")\n    private readonly database: ITypeormDatabase,\n  ) {}\n\n  public async open(): Promise<Repository<<Name>Entity>> {\n    return await this.database.open(<Name>Entity);\n  }\n\n  public async close(): Promise<void> {\n    await this.database.close();\n  }\n\n  public async find(\n    criteria: FindManyOptions<<Name>Entity> & { page?: number; limit?: number; q?: string },\n  ): Promise<FilterResultType<<Name>Entity>> {\n    // ... pagination and search logic\n  }\n\n  public async findOne(id: string): Promise<<Name>Entity | null> { ... }\n  public async findOneBy(criteria: FindOptionsWhere<<Name>Entity>): Promise<<Name>Entity | null> { ... }\n  public async create(entity: <Name>Entity, options?: SaveOptions): Promise<<Name>Entity> { ... }\n  public async createMany(entities: <Name>Entity[], options?: SaveOptions): Promise<<Name>Entity[]> { ... }\n  public async update(entity: <Name>Entity, options?: SaveOptions): Promise<<Name>Entity> { ... }\n  public async updateMany(entities: <Name>Entity[], options?: SaveOptions): Promise<<Name>Entity[]> { ... }\n  public async delete(criteria: FindOptionsWhere<<Name>Entity> | FindOptionsWhere<<Name>Entity>[]): Promise<UpdateResult> { ... }\n  public async count(criteria?: FindOptionsWhere<<Name>Entity> | FindOptionsWhere<<Name>Entity>[]): Promise<number> { ... }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/repositories/<Name>Repository.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep scaffolded tests for methods that remain in the repository (remove tests for methods that were removed)\n- Add tests for any custom domain-specific methods added to the repository\n- Add tests relevant to the specific repository behavior\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/repositories/<Name>Repository.ts tests/repositories/<Name>Repository.spec.ts\n```\n";
+  },
+};
 
-// src/templates/claude/skills/make.seed.md.txt
-var make_seed_md_default = "---\nname: make:seed\ndescription: Generate a new database seed file with its test file, then complete the generated code. Use when creating seed data for populating the database using @ooneex/seeds.\n---\n\n# Make Seed\n\nGenerate a new seed file and its test file using the `make:seed` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the seed file and test files:\n\n```bash\nbunx @ooneex/cli@latest make:seed --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/seeds/<Name>Seed.ts` - The seed class file (or `modules/<module>/src/seeds/<Name>Seed.ts` with `--module`)\n- `src/seeds/<name-seed>.yml` - The seed data file in kebab-case (or `modules/<module>/src/seeds/<name-seed>.yml` with `--module`)\n- `tests/seeds/<Name>Seed.spec.ts` - The test file (or `modules/<module>/tests/seeds/<Name>Seed.spec.ts` with `--module`)\n\nIt will also:\n- Generate a `seeds.ts` root export file in the seeds directory\n- Add a `seed:run` script to `package.json` if not already present\n\n### 2. Read the generated files\n\nRead all generated files to understand the scaffolded code.\n\n### 3. Complete the seed data\n\nEdit `src/seeds/<name-seed>.yml` to add the seed data entries. Each entry should have hardcoded nanoid values for `id` fields (generate via `bun -e \"import { random } from '@ooneex/utils'; console.log(random.nanoid())\"`)\n\n- Do NOT use sequential IDs like `\"item-1\"`, `\"item-2\"`\n- Ensure the same entity uses the same ID everywhere it appears\n\n### 4. Complete the seed class\n\nEdit `src/seeds/<Name>Seed.ts` to implement:\n\n- Import the relevant entity classes and repository\n- Use `resolve()` from `@ooneex/container` to get the repository instance\n- Map the imported YAML data to entity instances\n- Use the repository to persist the entities\n\n### 5. Complete the test file\n\nEdit `tests/seeds/<Name>Seed.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, run, isActive, getDependencies, data yml file)\n- Add tests relevant to the specific seed behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { existsSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>Seed } from \"@/seeds/<Name>Seed\";\n\ndescribe(\"<Name>Seed\", () => {\n  test(\"should have class name ending with 'Seed'\", () => {\n    expect(<Name>Seed.name.endsWith(\"Seed\")).toBe(true);\n  });\n\n  test(\"should have 'run' method\", () => {\n    expect(<Name>Seed.prototype.run).toBeDefined();\n    expect(typeof <Name>Seed.prototype.run).toBe(\"function\");\n  });\n\n  test(\"should have 'isActive' method\", () => {\n    expect(<Name>Seed.prototype.isActive).toBeDefined();\n    expect(typeof <Name>Seed.prototype.isActive).toBe(\"function\");\n  });\n\n  test(\"should have 'getDependencies' method\", () => {\n    expect(<Name>Seed.prototype.getDependencies).toBeDefined();\n    expect(typeof <Name>Seed.prototype.getDependencies).toBe(\"function\");\n  });\n\n  test(\"should have a data yml file\", () => {\n    const dataFile = join(__dirname, \"..\", \"src\", \"seeds\", \"<name-seed>.yml\");\n    expect(existsSync(dataFile)).toBe(true);\n  });\n});\n```\n\n### 6. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/seeds/<Name>Seed.ts src/seeds/<name-seed>.yml tests/seeds/<Name>Seed.spec.ts\n```\n";
+@Route.{{ROUTE_METHOD}}("{{ROUTE_PATH}}", {
+  name: "{{ROUTE_NAME}}",
+  version: 1,
+  description: "",
+  params: {
+    // id: Assert("string"),
+  },
+  payload: Assert({
 
-// src/templates/claude/skills/make.service.md.txt
-var make_service_md_default = "---\nname: make:service\ndescription: Generate a new service class with its test file, then complete the generated code. Use when creating a new business logic service that implements IService from @ooneex/service.\n---\n\n# Make Service Class\n\nGenerate a new service class and its test file using the `make:service` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the service class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:service --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/services/<Name>Service.ts` - The service class file (or `modules/<module>/src/services/<Name>Service.ts` with `--module`)\n- `tests/services/<Name>Service.spec.ts` - The test file (or `modules/<module>/tests/services/<Name>Service.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the service class\n\nEdit `src/services/<Name>Service.ts` to complete the implementation:\n\n- Define a proper type for `ServiceDataType` instead of `Record<string, unknown>`\n- Implement the `execute()` method with actual business logic\n- Inject any required dependencies (repositories, other services, etc.) via the constructor\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { type IService, decorator } from \"@ooneex/service\";\n\ntype ServiceDataType = Record<string, unknown>;\n\n@decorator.service()\nexport class <Name>Service implements IService {\n  public async execute(data?: ServiceDataType): Promise<void> {\n    // TODO: Implement service logic\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/services/<Name>Service.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, execute method)\n- Add tests relevant to the specific service behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>Service } from \"@/services/<Name>Service\";\n\ndescribe(\"<Name>Service\", () => {\n  test(\"should have class name ending with 'Service'\", () => {\n    expect(<Name>Service.name.endsWith(\"Service\")).toBe(true);\n  });\n\n  test(\"should have 'execute' method\", () => {\n    expect(<Name>Service.prototype.execute).toBeDefined();\n    expect(typeof <Name>Service.prototype.execute).toBe(\"function\");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/services/<Name>Service.ts tests/services/<Name>Service.spec.ts\n```\n";
+  }),
+  queries: Assert({
 
-// src/templates/claude/skills/make.storage.md.txt
-var make_storage_md_default = "---\nname: make:storage\ndescription: Generate a new storage class with its test file, then complete the generated code. Use when creating a new S3-compatible storage adapter that extends Storage from @ooneex/storage.\n---\n\n# Make Storage Class\n\nGenerate a new storage class and its test file using the `make:storage` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the storage class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:storage --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/storage/<Name>Storage.ts` - The storage class file (or `modules/<module>/src/storage/<Name>Storage.ts` with `--module`)\n- `tests/storage/<Name>Storage.spec.ts` - The test file (or `modules/<module>/tests/storage/<Name>Storage.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the storage class\n\nEdit `src/storage/<Name>Storage.ts` to complete the implementation:\n\n- Set the `bucket` property to the appropriate bucket name\n- Verify the environment variable names match the project configuration (`STORAGE_<NAME_UPPER>_ACCESS_KEY`, `STORAGE_<NAME_UPPER>_SECRET_KEY`, `STORAGE_<NAME_UPPER>_ENDPOINT`, `STORAGE_<NAME_UPPER>_REGION`)\n- Add any additional storage-specific methods if needed\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { Storage, decorator, StorageException } from \"@ooneex/storage\";\nimport type { S3Options } from \"bun\";\n\n@decorator.storage()\nexport class <Name>Storage extends Storage {\n  protected bucket: string;\n  private readonly accessKey: string;\n  private readonly secretKey: string;\n  private readonly endpoint: string;\n  private readonly region: string;\n\n  constructor(options?: {\n    accessKey?: string;\n    secretKey?: string;\n    endpoint?: string;\n    region?: string;\n  }) {\n    super();\n\n    const accessKey = options?.accessKey || Bun.env.STORAGE_<NAME_UPPER>_ACCESS_KEY;\n    const secretKey = options?.secretKey || Bun.env.STORAGE_<NAME_UPPER>_SECRET_KEY;\n    const endpoint = options?.endpoint || Bun.env.STORAGE_<NAME_UPPER>_ENDPOINT;\n\n    // ... validation throws StorageException if missing ...\n\n    this.accessKey = accessKey;\n    this.secretKey = secretKey;\n    this.endpoint = endpoint;\n    this.region = options?.region || Bun.env.STORAGE_<NAME_UPPER>_REGION || \"auto\";\n  }\n\n  public getOptions(): S3Options {\n    return {\n      accessKeyId: this.accessKey,\n      secretAccessKey: this.secretKey,\n      endpoint: this.endpoint,\n      bucket: this.bucket,\n      region: this.region,\n    };\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/storage/<Name>Storage.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, bucket field, getOptions method)\n- Add tests relevant to the specific storage class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>StorageAdapter } from \"@/storage/<Name>StorageAdapter\";\n\ndescribe(\"<Name>StorageAdapter\", () => {\n  test(\"should have class name ending with 'StorageAdapter'\", () => {\n    expect(<Name>StorageAdapter.name.endsWith(\"StorageAdapter\")).toBe(true);\n  });\n\n  test(\"should have 'bucket' field\", () => {\n    expect(\"bucket\" in <Name>StorageAdapter.prototype || \"bucket\" in Object.getOwnPropertyNames(<Name>StorageAdapter.prototype)).toBe(true);\n  });\n\n  test(\"should have 'getOptions' method\", () => {\n    expect(<Name>StorageAdapter.prototype.getOptions).toBeDefined();\n    expect(typeof <Name>StorageAdapter.prototype.getOptions).toBe(\"function\");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/storage/<Name>Storage.ts tests/storage/<Name>Storage.spec.ts\n```\n";
+  }),
+  response: Assert({
 
-// src/templates/claude/skills/make.vector-database.md.txt
-var make_vector_database_md_default = "---\nname: make:vector-database\ndescription: Generate a new vector database class with its test file, then complete the generated code. Use when creating a new vector database that extends VectorDatabase from @ooneex/rag.\n---\n\n# Make Vector Database Class\n\nGenerate a new vector database class and its test file using the `make:vector-database` CLI command, then complete the generated code with proper implementation.\n\n## Coding Conventions\n\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`)\n- Always use arrow functions when possible, but NOT for class methods (class methods use regular method syntax)\n- End type names with the `Type` suffix (e.g., `ExceptionStackFrameType`, `ServiceDataType`)\n- Start interface names with the `I` prefix (e.g., `IException`, `IService`, `IAiChat`)\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Run the generator\n\nRun the following command to scaffold the vector database class and test files:\n\n```bash\nbunx @ooneex/cli@latest make:vector-database --name=<name> --module=<module>\n```\n\nWhere `<name>` is the name provided by the user. The `--module` option is optional \u2014 if provided, files are generated under `modules/<module>/` instead of the project root. The command will generate:\n- `src/databases/<Name>VectorDatabase.ts` - The vector database class file (or `modules/<module>/src/databases/<Name>VectorDatabase.ts` with `--module`)\n- `tests/databases/<Name>VectorDatabase.spec.ts` - The test file (or `modules/<module>/tests/databases/<Name>VectorDatabase.spec.ts` with `--module`)\n\n### 2. Read the generated files\n\nRead both generated files to understand the scaffolded code.\n\n### 3. Complete the vector database class\n\nEdit `src/databases/<Name>VectorDatabase.ts` to complete the implementation:\n\n- Set the `getDatabaseUri()` return value to the actual LanceDB database path\n- Configure the embedding provider and model in `getEmbeddingModel()`\n- Define the custom data fields in `DataType` and map them in `getSchema()`\n- Import the appropriate Apache Arrow types for your schema fields\n\nThe generated class structure follows this pattern:\n\n```typescript\nimport { type EmbeddingModelType, type EmbeddingProviderType, type FieldValueType, VectorDatabase, decorator } from \"@ooneex/rag\";\nimport { Utf8 } from \"apache-arrow\";\n\ntype DataType = {\n  name: string;\n};\n\n@decorator.vectorDatabase()\nexport class <Name>VectorDatabase extends VectorDatabase<DataType> {\n  public getDatabaseUri(): string {\n    return \"\";\n  }\n\n  public getEmbeddingModel(): { provider: EmbeddingProviderType; model: EmbeddingModelType[\"model\"] } {\n    return { provider: \"openai\", model: \"text-embedding-ada-002\" };\n  }\n\n  public getSchema(): { [K in keyof DataType]: FieldValueType } {\n    return {\n      name: new Utf8(),\n    };\n  }\n}\n```\n\n### 4. Complete the test file\n\nEdit `tests/databases/<Name>VectorDatabase.spec.ts` to add meaningful tests beyond the scaffolded ones:\n\n- Keep the existing scaffolded tests (class name, getDatabaseUri, getEmbeddingModel, getSchema methods)\n- Add tests relevant to the specific vector database class behavior\n\nThe generated test structure follows this pattern:\n\n```typescript\nimport { describe, expect, test } from \"bun:test\";\nimport { <Name>VectorDatabase } from \"@/databases/<Name>VectorDatabase\";\n\ndescribe(\"<Name>VectorDatabase\", () => {\n  test(\"should have class name ending with 'VectorDatabase'\", () => {\n    expect(<Name>VectorDatabase.name.endsWith(\"VectorDatabase\")).toBe(true);\n  });\n\n  test(\"should have 'getDatabaseUri' method\", () => {\n    expect(<Name>VectorDatabase.prototype.getDatabaseUri).toBeDefined();\n    expect(typeof <Name>VectorDatabase.prototype.getDatabaseUri).toBe(\"function\");\n  });\n\n  test(\"should have 'getEmbeddingModel' method\", () => {\n    expect(<Name>VectorDatabase.prototype.getEmbeddingModel).toBeDefined();\n    expect(typeof <Name>VectorDatabase.prototype.getEmbeddingModel).toBe(\"function\");\n  });\n\n  test(\"should have 'getSchema' method\", () => {\n    expect(<Name>VectorDatabase.prototype.getSchema).toBeDefined();\n    expect(typeof <Name>VectorDatabase.prototype.getSchema).toBe(\"function\");\n  });\n});\n```\n\n### 5. Lint and format\n\nRun linting and formatting on the generated files:\n\n```bash\nbunx biome check --fix src/databases/<Name>VectorDatabase.ts tests/databases/<Name>VectorDatabase.spec.ts\n```\n";
+  }),
+  roles: [ERole.USER],
+})
+export class {{NAME}}Controller {
+  public async index(context: ContextType<{{TYPE_NAME}}RouteType>) {
+    // const { id } = context.params;
 
-// src/templates/claude/skills/optimize.md.txt
-var optimize_md_default = "---\nname: optimize\ndescription: Optimize a module's codebase for quality, performance, and clean conventions. Enforces arrow functions (except class methods), type/interface naming, removes duplication, and ensures only important tests remain.\n---\n\n# Optimize Codebase\n\nOptimize a module's codebase for quality, performance, and clean conventions.\n\n## Coding Conventions\n\nApply these conventions across all files in the target module:\n\n- **Arrow functions everywhere** \u2014 use arrow functions for all function expressions, callbacks, standalone functions, and variable declarations. The ONLY exception is class methods, which must use regular method syntax.\n- **Type naming** \u2014 all type aliases must end with the `Type` suffix (e.g., `UserDataType`, `ConfigOptionsType`). Rename any that don't comply.\n- **Interface naming** \u2014 all interface names must start with the `I` prefix (e.g., `IUser`, `IService`, `IRepository`). Rename any that don't comply.\n- **No definite assignment assertions** \u2014 never use `!` on class properties (e.g., `email!: string`). Use a default value or make the property optional (`?`) instead.\n- Always explicitly show visibility on class methods and properties (`private`, `public`, `protected`).\n- For Entity class, if property is optional, add `null` to its type.\n\n## Steps\n\n### 1. Identify the target\n\nDetermine the module to optimize. If the user specifies a module name, work in `modules/<module>/`. If no module is specified, ask the user which module to optimize.\n\n### 2. Read and analyze the module\n\nRead all source files (`src/**/*.ts`) and test files (`tests/**/*.ts`) in the target module. Build a full picture of:\n\n- All types, interfaces, classes, and functions\n- Dependencies between files\n- Existing test coverage\n\n### 3. Enforce naming conventions\n\nScan every file and fix:\n\n- **Types not ending with `Type`** \u2014 rename the type and update all references across the module\n- **Interfaces not starting with `I`** \u2014 rename the interface and update all references across the module\n- **Non-arrow functions** \u2014 convert all function expressions, callbacks, and standalone functions to arrow functions. Do NOT convert class methods.\n- **Missing visibility modifiers** \u2014 add explicit `public`, `private`, or `protected` to all class methods and properties\n\n### 4. Remove code duplication\n\nIdentify duplicated or near-duplicated code within the module:\n\n- Extract shared logic into well-named helper arrow functions or base classes\n- Consolidate repeated type definitions\n- Merge similar utility functions\n- Remove dead code (unused imports, unreachable branches, unused variables)\n\n### 5. Optimize for performance\n\nReview and improve:\n\n- Replace inefficient loops or repeated iterations with single-pass approaches where possible\n- Use `Map`/`Set` instead of arrays for lookups when appropriate\n- Avoid unnecessary object spreads or deep clones\n- Prefer early returns to reduce nesting\n- Remove unnecessary `async`/`await` where a direct return suffices\n- Eliminate redundant null/undefined checks when the type system already guarantees the value\n\n### 6. Optimize tests\n\nReview all test files and restructure:\n\n- **Remove trivial tests** \u2014 delete tests that only check obvious things (e.g., \"class name ends with X\", \"method exists\") unless they serve as smoke tests for generated code\n- **Keep and improve important tests** \u2014 focus on tests that verify actual business logic, edge cases, error handling, and integration behavior\n- **Write fewer but more meaningful tests** \u2014 each test should validate a real scenario or invariant, not just existence checks\n- **Consolidate redundant test cases** \u2014 merge tests that cover the same code path with slightly different inputs into parameterized patterns\n- **Ensure critical paths are covered** \u2014 every public method with logic should have at least one test covering its happy path and one covering its error/edge case\n\n### 7. Final cleanup\n\n- Remove all unused imports\n- Remove empty files or files with no exports\n- Ensure consistent formatting\n\n### 8. Lint and format\n\nRun linting and formatting on all modified files:\n\n```bash\nbunx biome check --fix <list of modified files>\n```\n\n### 9. Run tests\n\nRun the module's tests to verify nothing is broken:\n\n```bash\nbun test <module test directory>\n```\n\nIf any test fails, fix the issue and re-run until all tests pass.\n";
+    return context.response.json({
 
-// src/commands/MakeClaudeSkillCommand.ts
-var skills = {
-  "make.ai": make_ai_md_default,
-  "make.analytics": make_analytics_md_default,
-  "make.cache": make_cache_md_default,
-  "make.controller": make_controller_md_default,
-  "make.cron": make_cron_md_default,
-  "make.database": make_database_md_default,
-  "make.entity": make_entity_md_default,
-  "make.logger": make_logger_md_default,
-  "make.mailer": make_mailer_md_default,
-  "make.middleware": make_middleware_md_default,
-  "make.migration": make_migration_md_default,
-  "make.permission": make_permission_md_default,
-  "make.pubsub": make_pubsub_md_default,
-  "make.repository": make_repository_md_default,
-  "make.seed": make_seed_md_default,
-  "make.service": make_service_md_default,
-  "make.storage": make_storage_md_default,
-  "make.vector-database": make_vector_database_md_default,
-  commit: commit_md_default,
-  optimize: optimize_md_default
-};
+    });
+  }
+}
+`;
 
-class MakeClaudeSkillCommand {
+// src/commands/MakeControllerCommand.ts
+class MakeControllerCommand {
   getName() {
-    return "make:claude:skill";
+    return "make:controller";
   }
   getDescription() {
-    return "Generate Claude skills from templates";
+    return "Generate a new controller class";
   }
-  async run() {
-    const skillsLocalDir = join9(".claude", "skills");
-    const skillsDir = join9(process.cwd(), skillsLocalDir);
-    const logger = new TerminalLogger8;
-    for (const [skillName, content] of Object.entries(skills)) {
-      const dirName = skillName.replace(/\./g, "-");
-      const filePath = join9(skillsDir, dirName, "SKILL.md");
-      await Bun.write(filePath, content);
-      logger.success(`${join9(skillsLocalDir, dirName, "SKILL.md")} created successfully`, undefined, {
-        showTimestamp: false,
-        showArrow: false,
-        useSymbol: true
-      });
+  async addToModule(modulePath, controllerName) {
+    let content = await Bun.file(modulePath).text();
+    const className = `${controllerName}Controller`;
+    const importLine = `import { ${className} } from "./controllers/${className}";
+`;
+    const lastImportIndex = content.lastIndexOf("import ");
+    const lineEnd = content.indexOf(`
+`, lastImportIndex);
+    content = `${content.slice(0, lineEnd + 1)}${importLine}${content.slice(lineEnd + 1)}`;
+    const regex = /(controllers:\s*\[)([^\]]*)/s;
+    const match = content.match(regex);
+    if (match) {
+      const existing = match[2]?.trim();
+      const newValue = existing ? `${existing}, ${className}` : className;
+      content = content.replace(regex, `$1${newValue}`);
     }
-  }
-}
-MakeClaudeSkillCommand = __legacyDecorateClassTS([
-  decorator8.command()
-], MakeClaudeSkillCommand);
-// src/commands/MakeCommandCommand.ts
-import { join as join10 } from "path";
-import { commandCreate, decorator as decorator9 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger9 } from "@ooneex/logger";
-class MakeCommandCommand {
-  getName() {
-    return "make:command";
-  }
-  getDescription() {
-    return "Generate a new command class";
+    await Bun.write(modulePath, content);
   }
   async run(options) {
-    let { name, module } = options;
+    let { name, module, isSocket } = options;
     if (!name) {
-      name = await askName({ message: "Enter name" });
+      name = await askName({ message: "Enter controller name" });
     }
-    if (module) {
-      await ensureModule(module);
+    if (isSocket === undefined) {
+      isSocket = await askConfirm({ message: "Is this a socket controller?" });
     }
-    const base = module ? join10("modules", module) : ".";
-    const { commandPath, testPath } = await commandCreate({
-      name,
-      commandDir: join10(base, "src", "commands"),
-      testsDir: join10(base, "tests", "commands")
-    });
-    if (module && module !== "app") {
-      const appCommandsRootPath = join10(process.cwd(), "modules", "app", "src", "commands", "commands.ts");
-      const appCommandsRootFile = Bun.file(appCommandsRootPath);
-      const importLine = `import "@${module}/commands/commands";`;
-      if (await appCommandsRootFile.exists()) {
-        const appCommandsContent = await appCommandsRootFile.text();
-        if (!appCommandsContent.includes(importLine)) {
-          await Bun.write(appCommandsRootPath, `${appCommandsContent.trimEnd()}
-${importLine}
-`);
-        }
-      } else {
-        await Bun.write(appCommandsRootPath, `${importLine}
-`);
-      }
+    name = toPascalCase5(name).replace(/Controller$/, "");
+    const { route = {} } = options;
+    const selectedTemplate = isSocket ? controller_socket_default : controller_default;
+    let content = selectedTemplate.replaceAll("{{NAME}}", name);
+    if (!route.name) {
+      route.name = await askRouteName({ message: "Enter route name (e.g., api.user.create)" });
     }
-    const binCommandRunPath = join10(process.cwd(), "modules", "app", "bin", "command", "run.ts");
-    const binCommandRunFile = Bun.file(binCommandRunPath);
-    if (!await binCommandRunFile.exists()) {
-      await Bun.write(binCommandRunPath, command_run_default);
+    const routeTypeName = toPascalCase5(route.name);
+    content = content.replaceAll("{{ROUTE_NAME}}", route.name).replaceAll("{{TYPE_NAME}}", routeTypeName);
+    if (!route.path) {
+      route.path = await askRoutePath({ message: "Enter route path", initial: "/" });
     }
-    const packageJsonPath = join10(process.cwd(), "modules", "app", "package.json");
-    const packageJsonFile = Bun.file(packageJsonPath);
-    if (await packageJsonFile.exists()) {
-      const packageJson = await packageJsonFile.json();
-      packageJson.scripts = packageJson.scripts || {};
-      packageJson.scripts.command = "bun ./bin/command/run.ts";
-      await Bun.write(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    const routePath = `/${toKebabCase3(trim(route.path, "/"))}`;
+    content = content.replaceAll("{{ROUTE_PATH}}", routePath);
+    if (!isSocket && !route.method) {
+      route.method = await askRouteMethod({ message: "Enter route method" });
     }
-    const logger = new TerminalLogger9;
-    logger.success(`${commandPath} created successfully`, undefined, {
+    if (!isSocket && route.method) {
+      content = content.replaceAll("{{ROUTE_METHOD}}", route.method.toLowerCase());
+    }
+    if (module) {
+      await ensureModule(module);
+    }
+    const base = module ? join13("modules", module) : ".";
+    const controllersLocalDir = join13(base, "src", "controllers");
+    const controllersDir = join13(process.cwd(), controllersLocalDir);
+    const filePath = join13(controllersDir, `${name}Controller.ts`);
+    await Bun.write(filePath, content);
+    const testContent = controller_test_default.replace(/{{NAME}}/g, name);
+    const testsLocalDir = join13(base, "tests", "controllers");
+    const testsDir = join13(process.cwd(), testsLocalDir);
+    const testFilePath = join13(testsDir, `${name}Controller.spec.ts`);
+    await Bun.write(testFilePath, testContent);
+    const modulePascalName = module ? toPascalCase5(module) : toPascalCase5(basename(process.cwd()));
+    const modulePath = join13(process.cwd(), base, "src", `${modulePascalName}Module.ts`);
+    if (await Bun.file(modulePath).exists()) {
+      await this.addToModule(modulePath, name);
+    }
+    const logger = new TerminalLogger12;
+    logger.success(`${join13(controllersLocalDir, name)}Controller.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${testPath} created successfully`, undefined, {
+    logger.success(`${join13(testsLocalDir, name)}Controller.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.info("Run 'bun run command' to execute commands", undefined, {
-      showTimestamp: false,
-      showArrow: true,
-      showLevel: false
-    });
+    const packageJsonPath = join13(process.cwd(), "package.json");
+    const packageJson = await Bun.file(packageJsonPath).json();
+    const deps = packageJson.dependencies ?? {};
+    const devDeps = packageJson.devDependencies ?? {};
+    if (!deps["@ooneex/controller"] && !devDeps["@ooneex/controller"]) {
+      const install = Bun.spawn(["bun", "add", "@ooneex/controller"], {
+        cwd: process.cwd(),
+        stdout: "ignore",
+        stderr: "inherit"
+      });
+      await install.exited;
+    }
   }
 }
-MakeCommandCommand = __legacyDecorateClassTS([
-  decorator9.command()
-], MakeCommandCommand);
+MakeControllerCommand = __legacyDecorateClassTS([
+  decorator13.command()
+], MakeControllerCommand);
 // src/commands/MakeCronCommand.ts
-import { basename as basename2, join as join11 } from "path";
-import { decorator as decorator10 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger10 } from "@ooneex/logger";
+import { basename as basename2, join as join14 } from "path";
+import { decorator as decorator14 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger13 } from "@ooneex/logger";
 import { toPascalCase as toPascalCase6 } from "@ooneex/utils";
 
 // src/templates/cron.test.txt
@@ -7984,33 +8185,33 @@ class MakeCronCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join11("modules", module) : ".";
-    const cronLocalDir = join11(base, "src", "crons");
-    const cronDir = join11(process.cwd(), cronLocalDir);
-    const filePath = join11(cronDir, `${name}Cron.ts`);
+    const base = module ? join14("modules", module) : ".";
+    const cronLocalDir = join14(base, "src", "crons");
+    const cronDir = join14(process.cwd(), cronLocalDir);
+    const filePath = join14(cronDir, `${name}Cron.ts`);
     await Bun.write(filePath, content);
     const testContent = cron_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join11(base, "tests", "crons");
-    const testsDir = join11(process.cwd(), testsLocalDir);
-    const testFilePath = join11(testsDir, `${name}Cron.spec.ts`);
+    const testsLocalDir = join14(base, "tests", "crons");
+    const testsDir = join14(process.cwd(), testsLocalDir);
+    const testFilePath = join14(testsDir, `${name}Cron.spec.ts`);
     await Bun.write(testFilePath, testContent);
     const modulePascalName = module ? toPascalCase6(module) : toPascalCase6(basename2(process.cwd()));
-    const modulePath = join11(process.cwd(), base, "src", `${modulePascalName}Module.ts`);
+    const modulePath = join14(process.cwd(), base, "src", `${modulePascalName}Module.ts`);
     if (await Bun.file(modulePath).exists()) {
       await this.addToModule(modulePath, name);
     }
-    const logger = new TerminalLogger10;
-    logger.success(`${join11(cronLocalDir, name)}Cron.ts created successfully`, undefined, {
+    const logger = new TerminalLogger13;
+    logger.success(`${join14(cronLocalDir, name)}Cron.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join11(testsLocalDir, name)}Cron.spec.ts created successfully`, undefined, {
+    logger.success(`${join14(testsLocalDir, name)}Cron.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    const packageJsonPath = join11(process.cwd(), "package.json");
+    const packageJsonPath = join14(process.cwd(), "package.json");
     const packageJson = await Bun.file(packageJsonPath).json();
     const deps = packageJson.dependencies ?? {};
     const devDeps = packageJson.devDependencies ?? {};
@@ -8025,12 +8226,12 @@ class MakeCronCommand {
   }
 }
 MakeCronCommand = __legacyDecorateClassTS([
-  decorator10.command()
+  decorator14.command()
 ], MakeCronCommand);
 // src/commands/MakeDatabaseCommand.ts
-import { join as join12 } from "path";
-import { decorator as decorator11 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger11 } from "@ooneex/logger";
+import { join as join15 } from "path";
+import { decorator as decorator15 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger14 } from "@ooneex/logger";
 import { toPascalCase as toPascalCase7 } from "@ooneex/utils";
 
 // src/templates/database.test.txt
@@ -8093,28 +8294,28 @@ class MakeDatabaseCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join12("modules", module) : ".";
-    const databaseLocalDir = join12(base, "src", "databases");
-    const databaseDir = join12(process.cwd(), databaseLocalDir);
-    const filePath = join12(databaseDir, `${name}Database.ts`);
+    const base = module ? join15("modules", module) : ".";
+    const databaseLocalDir = join15(base, "src", "databases");
+    const databaseDir = join15(process.cwd(), databaseLocalDir);
+    const filePath = join15(databaseDir, `${name}Database.ts`);
     await Bun.write(filePath, content);
     const testContent = database_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join12(base, "tests", "databases");
-    const testsDir = join12(process.cwd(), testsLocalDir);
-    const testFilePath = join12(testsDir, `${name}Database.spec.ts`);
+    const testsLocalDir = join15(base, "tests", "databases");
+    const testsDir = join15(process.cwd(), testsLocalDir);
+    const testFilePath = join15(testsDir, `${name}Database.spec.ts`);
     await Bun.write(testFilePath, testContent);
-    const logger = new TerminalLogger11;
-    logger.success(`${join12(databaseLocalDir, name)}Database.ts created successfully`, undefined, {
+    const logger = new TerminalLogger14;
+    logger.success(`${join15(databaseLocalDir, name)}Database.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join12(testsLocalDir, name)}Database.spec.ts created successfully`, undefined, {
+    logger.success(`${join15(testsLocalDir, name)}Database.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    const packageJsonPath = join12(process.cwd(), "package.json");
+    const packageJsonPath = join15(process.cwd(), "package.json");
     const packageJson = await Bun.file(packageJsonPath).json();
     const deps = packageJson.dependencies ?? {};
     const devDeps = packageJson.devDependencies ?? {};
@@ -8129,12 +8330,12 @@ class MakeDatabaseCommand {
   }
 }
 MakeDatabaseCommand = __legacyDecorateClassTS([
-  decorator11.command()
+  decorator15.command()
 ], MakeDatabaseCommand);
 // src/commands/MakeDockerCommand.ts
-import { join as join13 } from "path";
-import { decorator as decorator12 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger12 } from "@ooneex/logger";
+import { join as join16 } from "path";
+import { decorator as decorator16 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger15 } from "@ooneex/logger";
 var {YAML } = globalThis.Bun;
 
 // src/prompts/askDockerService.ts
@@ -8627,9 +8828,9 @@ class MakeDockerCommand {
       name = await askDockerService({ message: "Select docker service" });
     }
     const templateContent = templates[name];
-    const base = join13("modules", "app");
-    const composePath = join13(process.cwd(), base, "docker-compose.yml");
-    const logger = new TerminalLogger12;
+    const base = join16("modules", "app");
+    const composePath = join16(process.cwd(), base, "docker-compose.yml");
+    const logger = new TerminalLogger15;
     const composeFile = Bun.file(composePath);
     if (await composeFile.exists()) {
       const existingContent = await composeFile.text();
@@ -8688,7 +8889,7 @@ volumes:
     } else {
       await Bun.write(composePath, templateContent);
     }
-    const packageJsonPath = join13(process.cwd(), base, "package.json");
+    const packageJsonPath = join16(process.cwd(), base, "package.json");
     const packageJsonFile = Bun.file(packageJsonPath);
     if (await packageJsonFile.exists()) {
       const packageJson = await packageJsonFile.json();
@@ -8709,13 +8910,13 @@ volumes:
   }
 }
 MakeDockerCommand = __legacyDecorateClassTS([
-  decorator12.command()
+  decorator16.command()
 ], MakeDockerCommand);
 // src/commands/MakeEntityCommand.ts
-var import_pluralize = __toESM(require_pluralize(), 1);
-import { basename as basename3, join as join14 } from "path";
-import { decorator as decorator13 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger13 } from "@ooneex/logger";
+var import_pluralize = __toESM(require_pluralize(), 1);
+import { basename as basename3, join as join17 } from "path";
+import { decorator as decorator17 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger16 } from "@ooneex/logger";
 import { toPascalCase as toPascalCase8, toSnakeCase as toSnakeCase2 } from "@ooneex/utils";
 
 // src/templates/entity.test.txt
@@ -8879,28 +9080,28 @@ class MakeEntityCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join14("modules", module) : ".";
-    const entitiesLocalDir = join14(base, "src", "entities");
-    const entitiesDir = join14(process.cwd(), entitiesLocalDir);
-    const filePath = join14(entitiesDir, `${name}Entity.ts`);
+    const base = module ? join17("modules", module) : ".";
+    const entitiesLocalDir = join17(base, "src", "entities");
+    const entitiesDir = join17(process.cwd(), entitiesLocalDir);
+    const filePath = join17(entitiesDir, `${name}Entity.ts`);
     await Bun.write(filePath, content);
     const testContent = entity_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join14(base, "tests", "entities");
-    const testsDir = join14(process.cwd(), testsLocalDir);
-    const testFilePath = join14(testsDir, `${name}Entity.spec.ts`);
+    const testsLocalDir = join17(base, "tests", "entities");
+    const testsDir = join17(process.cwd(), testsLocalDir);
+    const testFilePath = join17(testsDir, `${name}Entity.spec.ts`);
     await Bun.write(testFilePath, testContent);
     const modulePascalName = module ? toPascalCase8(module) : toPascalCase8(basename3(process.cwd()));
-    const modulePath = join14(process.cwd(), base, "src", `${modulePascalName}Module.ts`);
+    const modulePath = join17(process.cwd(), base, "src", `${modulePascalName}Module.ts`);
     if (await Bun.file(modulePath).exists()) {
       await this.addToModule(modulePath, name);
     }
-    const logger = new TerminalLogger13;
-    logger.success(`${join14(entitiesLocalDir, name)}Entity.ts created successfully`, undefined, {
+    const logger = new TerminalLogger16;
+    logger.success(`${join17(entitiesLocalDir, name)}Entity.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join14(testsLocalDir, name)}Entity.spec.ts created successfully`, undefined, {
+    logger.success(`${join17(testsLocalDir, name)}Entity.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
@@ -8908,12 +9109,12 @@ class MakeEntityCommand {
   }
 }
 MakeEntityCommand = __legacyDecorateClassTS([
-  decorator13.command()
+  decorator17.command()
 ], MakeEntityCommand);
 // src/commands/MakeLoggerCommand.ts
-import { join as join15 } from "path";
-import { decorator as decorator14 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger14 } from "@ooneex/logger";
+import { join as join18 } from "path";
+import { decorator as decorator18 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger17 } from "@ooneex/logger";
 import { toPascalCase as toPascalCase9 } from "@ooneex/utils";
 
 // src/templates/logger.test.txt
@@ -9018,28 +9219,28 @@ class MakeLoggerCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join15("modules", module) : ".";
-    const loggerLocalDir = join15(base, "src", "loggers");
-    const loggerDir = join15(process.cwd(), loggerLocalDir);
-    const filePath = join15(loggerDir, `${name}Logger.ts`);
+    const base = module ? join18("modules", module) : ".";
+    const loggerLocalDir = join18(base, "src", "loggers");
+    const loggerDir = join18(process.cwd(), loggerLocalDir);
+    const filePath = join18(loggerDir, `${name}Logger.ts`);
     await Bun.write(filePath, content);
     const testContent = logger_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join15(base, "tests", "loggers");
-    const testsDir = join15(process.cwd(), testsLocalDir);
-    const testFilePath = join15(testsDir, `${name}Logger.spec.ts`);
+    const testsLocalDir = join18(base, "tests", "loggers");
+    const testsDir = join18(process.cwd(), testsLocalDir);
+    const testFilePath = join18(testsDir, `${name}Logger.spec.ts`);
     await Bun.write(testFilePath, testContent);
-    const logger = new TerminalLogger14;
-    logger.success(`${join15(loggerLocalDir, name)}Logger.ts created successfully`, undefined, {
+    const logger = new TerminalLogger17;
+    logger.success(`${join18(loggerLocalDir, name)}Logger.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join15(testsLocalDir, name)}Logger.spec.ts created successfully`, undefined, {
+    logger.success(`${join18(testsLocalDir, name)}Logger.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    const packageJsonPath = join15(process.cwd(), "package.json");
+    const packageJsonPath = join18(process.cwd(), "package.json");
     const packageJson = await Bun.file(packageJsonPath).json();
     const deps = packageJson.dependencies ?? {};
     const devDeps = packageJson.devDependencies ?? {};
@@ -9054,12 +9255,12 @@ class MakeLoggerCommand {
   }
 }
 MakeLoggerCommand = __legacyDecorateClassTS([
-  decorator14.command()
+  decorator18.command()
 ], MakeLoggerCommand);
 // src/commands/MakeMailerCommand.ts
-import { join as join16 } from "path";
-import { decorator as decorator15 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger15 } from "@ooneex/logger";
+import { join as join19 } from "path";
+import { decorator as decorator19 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger18 } from "@ooneex/logger";
 import { toPascalCase as toPascalCase10 } from "@ooneex/utils";
 
 // src/templates/mailer/mailer.test.txt
@@ -9157,43 +9358,43 @@ class MakeMailerCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join16("modules", module) : ".";
-    const mailerLocalDir = join16(base, "src", "mailers");
-    const mailerDir = join16(process.cwd(), mailerLocalDir);
-    const mailerFilePath = join16(mailerDir, `${name}Mailer.ts`);
-    const templateFilePath = join16(mailerDir, `${name}MailerTemplate.tsx`);
+    const base = module ? join19("modules", module) : ".";
+    const mailerLocalDir = join19(base, "src", "mailers");
+    const mailerDir = join19(process.cwd(), mailerLocalDir);
+    const mailerFilePath = join19(mailerDir, `${name}Mailer.ts`);
+    const templateFilePath = join19(mailerDir, `${name}MailerTemplate.tsx`);
     await Bun.write(mailerFilePath, mailerContent);
     await Bun.write(templateFilePath, templateContent);
     const mailerTestContent = mailer_test_default.replace(/{{NAME}}/g, name);
     const templateTestContent = mailer_template_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join16(base, "tests", "mailers");
-    const testsDir = join16(process.cwd(), testsLocalDir);
-    const mailerTestFilePath = join16(testsDir, `${name}Mailer.spec.ts`);
-    const templateTestFilePath = join16(testsDir, `${name}MailerTemplate.spec.ts`);
+    const testsLocalDir = join19(base, "tests", "mailers");
+    const testsDir = join19(process.cwd(), testsLocalDir);
+    const mailerTestFilePath = join19(testsDir, `${name}Mailer.spec.ts`);
+    const templateTestFilePath = join19(testsDir, `${name}MailerTemplate.spec.ts`);
     await Bun.write(mailerTestFilePath, mailerTestContent);
     await Bun.write(templateTestFilePath, templateTestContent);
-    const logger = new TerminalLogger15;
-    logger.success(`${join16(mailerLocalDir, name)}Mailer.ts created successfully`, undefined, {
+    const logger = new TerminalLogger18;
+    logger.success(`${join19(mailerLocalDir, name)}Mailer.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join16(mailerLocalDir, name)}MailerTemplate.tsx created successfully`, undefined, {
+    logger.success(`${join19(mailerLocalDir, name)}MailerTemplate.tsx created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join16(testsLocalDir, name)}Mailer.spec.ts created successfully`, undefined, {
+    logger.success(`${join19(testsLocalDir, name)}Mailer.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join16(testsLocalDir, name)}MailerTemplate.spec.ts created successfully`, undefined, {
+    logger.success(`${join19(testsLocalDir, name)}MailerTemplate.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    const packageJsonPath = join16(process.cwd(), "package.json");
+    const packageJsonPath = join19(process.cwd(), "package.json");
     const packageJson = await Bun.file(packageJsonPath).json();
     const deps = packageJson.dependencies ?? {};
     const devDeps = packageJson.devDependencies ?? {};
@@ -9208,12 +9409,12 @@ class MakeMailerCommand {
   }
 }
 MakeMailerCommand = __legacyDecorateClassTS([
-  decorator15.command()
+  decorator19.command()
 ], MakeMailerCommand);
 // src/commands/MakeMiddlewareCommand.ts
-import { basename as basename4, join as join17 } from "path";
-import { decorator as decorator16 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger16 } from "@ooneex/logger";
+import { basename as basename4, join as join20 } from "path";
+import { decorator as decorator20 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger19 } from "@ooneex/logger";
 import { toPascalCase as toPascalCase11 } from "@ooneex/utils";
 
 // src/templates/middleware.socket.txt
@@ -9302,33 +9503,33 @@ class MakeMiddlewareCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join17("modules", module) : ".";
-    const middlewareLocalDir = join17(base, "src", "middlewares");
-    const middlewareDir = join17(process.cwd(), middlewareLocalDir);
-    const filePath = join17(middlewareDir, `${name}Middleware.ts`);
+    const base = module ? join20("modules", module) : ".";
+    const middlewareLocalDir = join20(base, "src", "middlewares");
+    const middlewareDir = join20(process.cwd(), middlewareLocalDir);
+    const filePath = join20(middlewareDir, `${name}Middleware.ts`);
     await Bun.write(filePath, content);
     const testContent = middleware_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join17(base, "tests", "middlewares");
-    const testsDir = join17(process.cwd(), testsLocalDir);
-    const testFilePath = join17(testsDir, `${name}Middleware.spec.ts`);
+    const testsLocalDir = join20(base, "tests", "middlewares");
+    const testsDir = join20(process.cwd(), testsLocalDir);
+    const testFilePath = join20(testsDir, `${name}Middleware.spec.ts`);
     await Bun.write(testFilePath, testContent);
     const modulePascalName = module ? toPascalCase11(module) : toPascalCase11(basename4(process.cwd()));
-    const modulePath = join17(process.cwd(), base, "src", `${modulePascalName}Module.ts`);
+    const modulePath = join20(process.cwd(), base, "src", `${modulePascalName}Module.ts`);
     if (await Bun.file(modulePath).exists()) {
       await this.addToModule(modulePath, name);
     }
-    const logger = new TerminalLogger16;
-    logger.success(`${join17(middlewareLocalDir, name)}Middleware.ts created successfully`, undefined, {
+    const logger = new TerminalLogger19;
+    logger.success(`${join20(middlewareLocalDir, name)}Middleware.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join17(testsLocalDir, name)}Middleware.spec.ts created successfully`, undefined, {
+    logger.success(`${join20(testsLocalDir, name)}Middleware.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    const packageJsonPath = join17(process.cwd(), "package.json");
+    const packageJsonPath = join20(process.cwd(), "package.json");
     const packageJson = await Bun.file(packageJsonPath).json();
     const deps = packageJson.dependencies ?? {};
     const devDeps = packageJson.devDependencies ?? {};
@@ -9343,21 +9544,21 @@ class MakeMiddlewareCommand {
   }
 }
 MakeMiddlewareCommand = __legacyDecorateClassTS([
-  decorator16.command()
+  decorator20.command()
 ], MakeMiddlewareCommand);
 // src/commands/MakeMigrationCommand.ts
-import { join as join18 } from "path";
-import { decorator as decorator17 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger17 } from "@ooneex/logger";
+import { join as join21 } from "path";
+import { decorator as decorator21 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger20 } from "@ooneex/logger";
 import { migrationCreate } from "@ooneex/migrations";
 
 // src/templates/module/migration.up.txt
 var migration_up_default = `#!/usr/bin/env bun
 
-import { migrationUp } from "@ooneex/migrations";
+import { up } from "@ooneex/migrations";
 import "@/migrations/migrations";
 
-await migrationUp({
+await up({
   databaseUrl: Bun.env.DATABASE_URL,
   tableName: "migrations",
 });
@@ -9376,41 +9577,29 @@ class MakeMigrationCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join18("modules", module) : ".";
+    const base = module ? join21("modules", module) : ".";
     const { migrationPath: filePath } = await migrationCreate({
-      migrationsDir: join18(base, "src", "migrations"),
-      testsDir: join18(base, "tests", "migrations")
+      migrationsDir: join21(base, "src", "migrations"),
+      testsDir: join21(base, "tests", "migrations")
     });
-    const binMigrationUpPath = join18(process.cwd(), base, "bin", "migration", "up.ts");
+    const binMigrationUpPath = join21(process.cwd(), base, "bin", "migration", "up.ts");
     const binMigrationUpFile = Bun.file(binMigrationUpPath);
     if (!await binMigrationUpFile.exists()) {
       await Bun.write(binMigrationUpPath, migration_up_default);
     }
-    const packageJsonPath = join18(process.cwd(), base, "package.json");
-    const packageJsonFile = Bun.file(packageJsonPath);
-    if (await packageJsonFile.exists()) {
-      const packageJson = await packageJsonFile.json();
-      packageJson.scripts = packageJson.scripts || {};
-      packageJson.scripts["migration:up"] = "bun ./bin/migration/up.ts";
-      await Bun.write(packageJsonPath, JSON.stringify(packageJson, null, 2));
-    }
-    const logger = new TerminalLogger17;
+    const packageJsonPath = join21(process.cwd(), base, "package.json");
+    const logger = new TerminalLogger20;
     logger.success(`${filePath} created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.info("Run 'bun run migration:up' to execute migrations", undefined, {
-      showTimestamp: false,
-      showArrow: true,
-      showLevel: false
-    });
     const pkgJson = await Bun.file(packageJsonPath).json();
     const deps = pkgJson.dependencies ?? {};
     const devDeps = pkgJson.devDependencies ?? {};
     if (!deps["@ooneex/migrations"] && !devDeps["@ooneex/migrations"]) {
       const install = Bun.spawn(["bun", "add", "--dev", "@ooneex/migrations"], {
-        cwd: join18(process.cwd(), base),
+        cwd: join21(process.cwd(), base),
         stdout: "ignore",
         stderr: "inherit"
       });
@@ -9419,12 +9608,12 @@ class MakeMigrationCommand {
   }
 }
 MakeMigrationCommand = __legacyDecorateClassTS([
-  decorator17.command()
+  decorator21.command()
 ], MakeMigrationCommand);
 // src/commands/MakePermissionCommand.ts
-import { join as join19 } from "path";
-import { decorator as decorator18 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger18 } from "@ooneex/logger";
+import { join as join22 } from "path";
+import { decorator as decorator22 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger21 } from "@ooneex/logger";
 import { toPascalCase as toPascalCase12 } from "@ooneex/utils";
 
 // src/templates/permission.test.txt
@@ -9515,28 +9704,28 @@ class MakePermissionCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join19("modules", module) : ".";
-    const permissionLocalDir = join19(base, "src", "permissions");
-    const permissionDir = join19(process.cwd(), permissionLocalDir);
-    const filePath = join19(permissionDir, `${name}Permission.ts`);
+    const base = module ? join22("modules", module) : ".";
+    const permissionLocalDir = join22(base, "src", "permissions");
+    const permissionDir = join22(process.cwd(), permissionLocalDir);
+    const filePath = join22(permissionDir, `${name}Permission.ts`);
     await Bun.write(filePath, content);
     const testContent = permission_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join19(base, "tests", "permissions");
-    const testsDir = join19(process.cwd(), testsLocalDir);
-    const testFilePath = join19(testsDir, `${name}Permission.spec.ts`);
+    const testsLocalDir = join22(base, "tests", "permissions");
+    const testsDir = join22(process.cwd(), testsLocalDir);
+    const testFilePath = join22(testsDir, `${name}Permission.spec.ts`);
     await Bun.write(testFilePath, testContent);
-    const logger = new TerminalLogger18;
-    logger.success(`${join19(permissionLocalDir, name)}Permission.ts created successfully`, undefined, {
+    const logger = new TerminalLogger21;
+    logger.success(`${join22(permissionLocalDir, name)}Permission.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join19(testsLocalDir, name)}Permission.spec.ts created successfully`, undefined, {
+    logger.success(`${join22(testsLocalDir, name)}Permission.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    const packageJsonPath = join19(process.cwd(), "package.json");
+    const packageJsonPath = join22(process.cwd(), "package.json");
     const packageJson = await Bun.file(packageJsonPath).json();
     const deps = packageJson.dependencies ?? {};
     const devDeps = packageJson.devDependencies ?? {};
@@ -9551,12 +9740,12 @@ class MakePermissionCommand {
   }
 }
 MakePermissionCommand = __legacyDecorateClassTS([
-  decorator18.command()
+  decorator22.command()
 ], MakePermissionCommand);
 // src/commands/MakePubSubCommand.ts
-import { basename as basename5, join as join20 } from "path";
-import { decorator as decorator19 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger19 } from "@ooneex/logger";
+import { basename as basename5, join as join23 } from "path";
+import { decorator as decorator23 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger22 } from "@ooneex/logger";
 import { toKebabCase as toKebabCase4, toPascalCase as toPascalCase13 } from "@ooneex/utils";
 
 // src/templates/pubsub.test.txt
@@ -9664,33 +9853,33 @@ class MakePubSubCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join20("modules", module) : ".";
-    const pubSubLocalDir = join20(base, "src", "events");
-    const pubSubDir = join20(process.cwd(), pubSubLocalDir);
-    const filePath = join20(pubSubDir, `${name}Event.ts`);
+    const base = module ? join23("modules", module) : ".";
+    const pubSubLocalDir = join23(base, "src", "events");
+    const pubSubDir = join23(process.cwd(), pubSubLocalDir);
+    const filePath = join23(pubSubDir, `${name}Event.ts`);
     await Bun.write(filePath, content);
     const testContent = pubsub_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join20(base, "tests", "events");
-    const testsDir = join20(process.cwd(), testsLocalDir);
-    const testFilePath = join20(testsDir, `${name}Event.spec.ts`);
+    const testsLocalDir = join23(base, "tests", "events");
+    const testsDir = join23(process.cwd(), testsLocalDir);
+    const testFilePath = join23(testsDir, `${name}Event.spec.ts`);
     await Bun.write(testFilePath, testContent);
     const modulePascalName = module ? toPascalCase13(module) : toPascalCase13(basename5(process.cwd()));
-    const modulePath = join20(process.cwd(), base, "src", `${modulePascalName}Module.ts`);
+    const modulePath = join23(process.cwd(), base, "src", `${modulePascalName}Module.ts`);
     if (await Bun.file(modulePath).exists()) {
       await this.addToModule(modulePath, name);
     }
-    const logger = new TerminalLogger19;
-    logger.success(`${join20(pubSubLocalDir, name)}Event.ts created successfully`, undefined, {
+    const logger = new TerminalLogger22;
+    logger.success(`${join23(pubSubLocalDir, name)}Event.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join20(testsLocalDir, name)}Event.spec.ts created successfully`, undefined, {
+    logger.success(`${join23(testsLocalDir, name)}Event.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    const packageJsonPath = join20(process.cwd(), "package.json");
+    const packageJsonPath = join23(process.cwd(), "package.json");
     const packageJson = await Bun.file(packageJsonPath).json();
     const deps = packageJson.dependencies ?? {};
     const devDeps = packageJson.devDependencies ?? {};
@@ -9705,13 +9894,13 @@ class MakePubSubCommand {
   }
 }
 MakePubSubCommand = __legacyDecorateClassTS([
-  decorator19.command()
+  decorator23.command()
 ], MakePubSubCommand);
 // src/commands/MakeReleaseCommand.ts
 import { readdir } from "fs/promises";
-import { join as join21 } from "path";
-import { decorator as decorator20 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger20 } from "@ooneex/logger";
+import { join as join24 } from "path";
+import { decorator as decorator24 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger23 } from "@ooneex/logger";
 var {$ } = globalThis.Bun;
 var COMMIT_TYPE_TO_CATEGORY = {
   feat: "Added",
@@ -9734,7 +9923,7 @@ class MakeReleaseCommand {
     return "Release packages with version bump, changelog, and git tag";
   }
   async run() {
-    const logger = new TerminalLogger20;
+    const logger = new TerminalLogger23;
     const cwd = process.cwd();
     const dirs = [];
     for (const { name, type } of [
@@ -9742,8 +9931,8 @@ class MakeReleaseCommand {
       { name: "modules", type: "module" }
     ]) {
       try {
-        const entries = await readdir(join21(cwd, name), { withFileTypes: true });
-        dirs.push(...entries.filter((d) => d.isDirectory()).map((d) => ({ base: join21(name, d.name), type })));
+        const entries = await readdir(join24(cwd, name), { withFileTypes: true });
+        dirs.push(...entries.filter((d) => d.isDirectory()).map((d) => ({ base: join24(name, d.name), type })));
       } catch {}
     }
     const logOptions = { showTimestamp: false, showArrow: false, useSymbol: true };
@@ -9753,8 +9942,8 @@ class MakeReleaseCommand {
     }
     let releasedCount = 0;
     for (const dir of dirs) {
-      const fullDir = join21(cwd, dir.base);
-      const pkgJsonPath = join21(fullDir, "package.json");
+      const fullDir = join24(cwd, dir.base);
+      const pkgJsonPath = join24(fullDir, "package.json");
       const pkgJsonFile = Bun.file(pkgJsonPath);
       if (!await pkgJsonFile.exists()) {
         continue;
@@ -9772,7 +9961,7 @@ class MakeReleaseCommand {
       await Bun.write(pkgJsonPath, `${JSON.stringify(pkgJson, null, 2)}
 `);
       await this.updateChangelog(fullDir, newVersion, tag, commits);
-      await this.gitAdd(join21(dir.base, "package.json"), join21(dir.base, "CHANGELOG.md"));
+      await this.gitAdd(join24(dir.base, "package.json"), join24(dir.base, "CHANGELOG.md"));
       await this.gitCommit(`chore(release): ${pkgJson.name}@${newVersion}`);
       await this.gitTag(tag, `chore(release): ${pkgJson.name}@${newVersion}`);
       logger.success(`${pkgJson.name}@${newVersion} released (${bumpType} bump, ${commits.length} commit(s))`, undefined, logOptions);
@@ -9869,7 +10058,7 @@ class MakeReleaseCommand {
     }
   }
   async updateChangelog(dir, version, tag, commits) {
-    const changelogPath = join21(dir, "CHANGELOG.md");
+    const changelogPath = join24(dir, "CHANGELOG.md");
     const today = new Date().toISOString().split("T")[0];
     const repoUrl = await this.getRepoUrl();
     const grouped = new Map;
@@ -9940,12 +10129,12 @@ ${section}
   }
 }
 MakeReleaseCommand = __legacyDecorateClassTS([
-  decorator20.command()
+  decorator24.command()
 ], MakeReleaseCommand);
 // src/commands/MakeRepositoryCommand.ts
-import { join as join22 } from "path";
-import { decorator as decorator21 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger21 } from "@ooneex/logger";
+import { join as join25 } from "path";
+import { decorator as decorator25 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger24 } from "@ooneex/logger";
 import { toPascalCase as toPascalCase14 } from "@ooneex/utils";
 
 // src/templates/repository.test.txt
@@ -10159,28 +10348,28 @@ class MakeRepositoryCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join22("modules", module) : ".";
-    const repositoriesLocalDir = join22(base, "src", "repositories");
-    const repositoriesDir = join22(process.cwd(), repositoriesLocalDir);
-    const filePath = join22(repositoriesDir, `${name}Repository.ts`);
+    const base = module ? join25("modules", module) : ".";
+    const repositoriesLocalDir = join25(base, "src", "repositories");
+    const repositoriesDir = join25(process.cwd(), repositoriesLocalDir);
+    const filePath = join25(repositoriesDir, `${name}Repository.ts`);
     await Bun.write(filePath, content);
     const testContent = repository_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join22(base, "tests", "repositories");
-    const testsDir = join22(process.cwd(), testsLocalDir);
-    const testFilePath = join22(testsDir, `${name}Repository.spec.ts`);
+    const testsLocalDir = join25(base, "tests", "repositories");
+    const testsDir = join25(process.cwd(), testsLocalDir);
+    const testFilePath = join25(testsDir, `${name}Repository.spec.ts`);
     await Bun.write(testFilePath, testContent);
-    const logger = new TerminalLogger21;
-    logger.success(`${join22(repositoriesLocalDir, name)}Repository.ts created successfully`, undefined, {
+    const logger = new TerminalLogger24;
+    logger.success(`${join25(repositoriesLocalDir, name)}Repository.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join22(testsLocalDir, name)}Repository.spec.ts created successfully`, undefined, {
+    logger.success(`${join25(testsLocalDir, name)}Repository.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    const packageJsonPath = join22(process.cwd(), "package.json");
+    const packageJsonPath = join25(process.cwd(), "package.json");
     const packageJson = await Bun.file(packageJsonPath).json();
     const deps = packageJson.dependencies ?? {};
     const devDeps = packageJson.devDependencies ?? {};
@@ -10195,11 +10384,11 @@ class MakeRepositoryCommand {
   }
 }
 MakeRepositoryCommand = __legacyDecorateClassTS([
-  decorator21.command()
+  decorator25.command()
 ], MakeRepositoryCommand);
 // src/commands/MakeResourceBookCommand.ts
-import { join as join24 } from "path";
-import { decorator as decorator23 } from "@ooneex/command";
+import { join as join27 } from "path";
+import { decorator as decorator27 } from "@ooneex/command";
 var {Glob } = globalThis.Bun;
 
 // src/templates/resources/book/BookEntity.txt
@@ -10895,9 +11084,9 @@ export class UpdateBookService implements IService {
 `;
 
 // src/commands/MakeServiceCommand.ts
-import { join as join23 } from "path";
-import { decorator as decorator22 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger22 } from "@ooneex/logger";
+import { join as join26 } from "path";
+import { decorator as decorator26 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger25 } from "@ooneex/logger";
 import { toPascalCase as toPascalCase15 } from "@ooneex/utils";
 
 // src/templates/service.test.txt
@@ -10949,28 +11138,28 @@ class MakeServiceCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join23("modules", module) : ".";
-    const serviceLocalDir = join23(base, "src", "services");
-    const serviceDir = join23(process.cwd(), serviceLocalDir);
-    const filePath = join23(serviceDir, `${name}Service.ts`);
+    const base = module ? join26("modules", module) : ".";
+    const serviceLocalDir = join26(base, "src", "services");
+    const serviceDir = join26(process.cwd(), serviceLocalDir);
+    const filePath = join26(serviceDir, `${name}Service.ts`);
     await Bun.write(filePath, content);
     const testContent = service_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join23(base, "tests", "services");
-    const testsDir = join23(process.cwd(), testsLocalDir);
-    const testFilePath = join23(testsDir, `${name}Service.spec.ts`);
+    const testsLocalDir = join26(base, "tests", "services");
+    const testsDir = join26(process.cwd(), testsLocalDir);
+    const testFilePath = join26(testsDir, `${name}Service.spec.ts`);
     await Bun.write(testFilePath, testContent);
-    const logger = new TerminalLogger22;
-    logger.success(`${join23(serviceLocalDir, name)}Service.ts created successfully`, undefined, {
+    const logger = new TerminalLogger25;
+    logger.success(`${join26(serviceLocalDir, name)}Service.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join23(testsLocalDir, name)}Service.spec.ts created successfully`, undefined, {
+    logger.success(`${join26(testsLocalDir, name)}Service.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    const packageJsonPath = join23(process.cwd(), "package.json");
+    const packageJsonPath = join26(process.cwd(), "package.json");
     const packageJson = await Bun.file(packageJsonPath).json();
     const deps = packageJson.dependencies ?? {};
     const devDeps = packageJson.devDependencies ?? {};
@@ -10985,7 +11174,7 @@ class MakeServiceCommand {
   }
 }
 MakeServiceCommand = __legacyDecorateClassTS([
-  decorator22.command()
+  decorator26.command()
 ], MakeServiceCommand);
 
 // src/commands/MakeResourceBookCommand.ts
@@ -10998,7 +11187,7 @@ class MakeResourceBookCommand {
   }
   async run() {
     const module = "book";
-    const base = join24("modules", module);
+    const base = join27("modules", module);
     const makeModuleCommand = new MakeModuleCommand;
     await makeModuleCommand.run({ name: module, silent: true, skipMigrations: false, skipSeeds: true });
     const makeEntityCommand = new MakeEntityCommand;
@@ -11018,26 +11207,26 @@ class MakeResourceBookCommand {
     for (const controller of controllers) {
       await makeControllerCommand.run({ ...controller, module, isSocket: false });
     }
-    const controllersDir = join24(process.cwd(), base, "src", "controllers");
-    await Bun.write(join24(controllersDir, "CreateBookController.ts"), CreateBookController_default);
-    await Bun.write(join24(controllersDir, "GetBookController.ts"), GetBookController_default);
-    await Bun.write(join24(controllersDir, "ListBooksController.ts"), ListBooksController_default);
-    await Bun.write(join24(controllersDir, "UpdateBookController.ts"), UpdateBookController_default);
-    await Bun.write(join24(controllersDir, "DeleteBookController.ts"), DeleteBookController_default);
+    const controllersDir = join27(process.cwd(), base, "src", "controllers");
+    await Bun.write(join27(controllersDir, "CreateBookController.ts"), CreateBookController_default);
+    await Bun.write(join27(controllersDir, "GetBookController.ts"), GetBookController_default);
+    await Bun.write(join27(controllersDir, "ListBooksController.ts"), ListBooksController_default);
+    await Bun.write(join27(controllersDir, "UpdateBookController.ts"), UpdateBookController_default);
+    await Bun.write(join27(controllersDir, "DeleteBookController.ts"), DeleteBookController_default);
     const makeServiceCommand = new MakeServiceCommand;
     const services = ["CreateBook", "GetBook", "ListBooks", "UpdateBook", "DeleteBook"];
     for (const name of services) {
       await makeServiceCommand.run({ name, module });
     }
-    const servicesDir = join24(process.cwd(), base, "src", "services");
-    await Bun.write(join24(servicesDir, "CreateBookService.ts"), CreateBookService_default);
-    await Bun.write(join24(servicesDir, "GetBookService.ts"), GetBookService_default);
-    await Bun.write(join24(servicesDir, "ListBooksService.ts"), ListBooksService_default);
-    await Bun.write(join24(servicesDir, "UpdateBookService.ts"), UpdateBookService_default);
-    await Bun.write(join24(servicesDir, "DeleteBookService.ts"), DeleteBookService_default);
-    const entityPath = join24(process.cwd(), base, "src", "entities", "BookEntity.ts");
+    const servicesDir = join27(process.cwd(), base, "src", "services");
+    await Bun.write(join27(servicesDir, "CreateBookService.ts"), CreateBookService_default);
+    await Bun.write(join27(servicesDir, "GetBookService.ts"), GetBookService_default);
+    await Bun.write(join27(servicesDir, "ListBooksService.ts"), ListBooksService_default);
+    await Bun.write(join27(servicesDir, "UpdateBookService.ts"), UpdateBookService_default);
+    await Bun.write(join27(servicesDir, "DeleteBookService.ts"), DeleteBookService_default);
+    const entityPath = join27(process.cwd(), base, "src", "entities", "BookEntity.ts");
     await Bun.write(entityPath, BookEntity_default);
-    const migrationsDir = join24(process.cwd(), base, "src", "migrations");
+    const migrationsDir = join27(process.cwd(), base, "src", "migrations");
     const glob = new Glob("Migration*.ts");
     for await (const file of glob.scan(migrationsDir)) {
       if (file === "migrations.ts")
@@ -11045,28 +11234,28 @@ class MakeResourceBookCommand {
       const name = file.replace(/\.ts$/, "");
       const version = name.replace("Migration", "");
       const content = BookMigration_default.replaceAll("{{ name }}", name).replaceAll("{{ version }}", version);
-      await Bun.write(join24(migrationsDir, file), content);
+      await Bun.write(join27(migrationsDir, file), content);
     }
-    const repositoryPath = join24(process.cwd(), base, "src", "repositories", "BookRepository.ts");
+    const repositoryPath = join27(process.cwd(), base, "src", "repositories", "BookRepository.ts");
     await Bun.write(repositoryPath, BookRepository_default);
   }
 }
 MakeResourceBookCommand = __legacyDecorateClassTS([
-  decorator23.command()
+  decorator27.command()
 ], MakeResourceBookCommand);
 // src/commands/MakeSeedCommand.ts
-import { join as join25 } from "path";
-import { decorator as decorator24 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger23 } from "@ooneex/logger";
+import { join as join28 } from "path";
+import { decorator as decorator28 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger26 } from "@ooneex/logger";
 import { seedCreate } from "@ooneex/seeds";
 
 // src/templates/module/seed.run.txt
 var seed_run_default = `#!/usr/bin/env bun
 
-import { seedRun } from "@ooneex/seeds";
+import { run } from "@ooneex/seeds";
 import "@/seeds/seeds";
 
-await seedRun();
+await run();
 `;
 
 // src/commands/MakeSeedCommand.ts
@@ -11085,26 +11274,19 @@ class MakeSeedCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join25("modules", module) : ".";
+    const base = module ? join28("modules", module) : ".";
     const { seedPath: filePath, dataPath } = await seedCreate({
       name,
-      seedsDir: join25(base, "src", "seeds"),
-      testsDir: join25(base, "tests", "seeds")
+      seedsDir: join28(base, "src", "seeds"),
+      testsDir: join28(base, "tests", "seeds")
     });
-    const binSeedRunPath = join25(process.cwd(), base, "bin", "seed", "run.ts");
+    const binSeedRunPath = join28(process.cwd(), base, "bin", "seed", "run.ts");
     const binSeedRunFile = Bun.file(binSeedRunPath);
     if (!await binSeedRunFile.exists()) {
       await Bun.write(binSeedRunPath, seed_run_default);
     }
-    const packageJsonPath = join25(process.cwd(), base, "package.json");
-    const packageJsonFile = Bun.file(packageJsonPath);
-    if (await packageJsonFile.exists()) {
-      const packageJson = await packageJsonFile.json();
-      packageJson.scripts = packageJson.scripts || {};
-      packageJson.scripts["seed:run"] = "bun ./bin/seed/run.ts";
-      await Bun.write(packageJsonPath, JSON.stringify(packageJson, null, 2));
-    }
-    const logger = new TerminalLogger23;
+    const packageJsonPath = join28(process.cwd(), base, "package.json");
+    const logger = new TerminalLogger26;
     logger.success(`${filePath} created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
@@ -11115,17 +11297,12 @@ class MakeSeedCommand {
       showArrow: false,
       useSymbol: true
     });
-    logger.info("Run 'bun run seed:run' to execute seeds", undefined, {
-      showTimestamp: false,
-      showArrow: true,
-      showLevel: false
-    });
     const pkgJson = await Bun.file(packageJsonPath).json();
     const deps = pkgJson.dependencies ?? {};
     const devDeps = pkgJson.devDependencies ?? {};
     if (!deps["@ooneex/seeds"] && !devDeps["@ooneex/seeds"]) {
       const install = Bun.spawn(["bun", "add", "--dev", "@ooneex/seeds"], {
-        cwd: join25(process.cwd(), base),
+        cwd: join28(process.cwd(), base),
         stdout: "ignore",
         stderr: "inherit"
       });
@@ -11134,12 +11311,12 @@ class MakeSeedCommand {
   }
 }
 MakeSeedCommand = __legacyDecorateClassTS([
-  decorator24.command()
+  decorator28.command()
 ], MakeSeedCommand);
 // src/commands/MakeStorageCommand.ts
-import { join as join26 } from "path";
-import { decorator as decorator25 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger24 } from "@ooneex/logger";
+import { join as join29 } from "path";
+import { decorator as decorator29 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger27 } from "@ooneex/logger";
 import { toPascalCase as toPascalCase16, toSnakeCase as toSnakeCase3 } from "@ooneex/utils";
 
 // src/templates/storage.test.txt
@@ -11239,28 +11416,28 @@ class MakeStorageCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join26("modules", module) : ".";
-    const storageLocalDir = join26(base, "src", "storage");
-    const storageDir = join26(process.cwd(), storageLocalDir);
-    const filePath = join26(storageDir, `${name}Storage.ts`);
+    const base = module ? join29("modules", module) : ".";
+    const storageLocalDir = join29(base, "src", "storage");
+    const storageDir = join29(process.cwd(), storageLocalDir);
+    const filePath = join29(storageDir, `${name}Storage.ts`);
     await Bun.write(filePath, content);
     const testContent = storage_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join26(base, "tests", "storage");
-    const testsDir = join26(process.cwd(), testsLocalDir);
-    const testFilePath = join26(testsDir, `${name}Storage.spec.ts`);
+    const testsLocalDir = join29(base, "tests", "storage");
+    const testsDir = join29(process.cwd(), testsLocalDir);
+    const testFilePath = join29(testsDir, `${name}Storage.spec.ts`);
     await Bun.write(testFilePath, testContent);
-    const logger = new TerminalLogger24;
-    logger.success(`${join26(storageLocalDir, name)}Storage.ts created successfully`, undefined, {
+    const logger = new TerminalLogger27;
+    logger.success(`${join29(storageLocalDir, name)}Storage.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join26(testsLocalDir, name)}Storage.spec.ts created successfully`, undefined, {
+    logger.success(`${join29(testsLocalDir, name)}Storage.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    const packageJsonPath = join26(process.cwd(), "package.json");
+    const packageJsonPath = join29(process.cwd(), "package.json");
     const packageJson = await Bun.file(packageJsonPath).json();
     const deps = packageJson.dependencies ?? {};
     const devDeps = packageJson.devDependencies ?? {};
@@ -11275,12 +11452,12 @@ class MakeStorageCommand {
   }
 }
 MakeStorageCommand = __legacyDecorateClassTS([
-  decorator25.command()
+  decorator29.command()
 ], MakeStorageCommand);
 // src/commands/MakeVectorDatabaseCommand.ts
-import { join as join27 } from "path";
-import { decorator as decorator26 } from "@ooneex/command";
-import { TerminalLogger as TerminalLogger25 } from "@ooneex/logger";
+import { join as join30 } from "path";
+import { decorator as decorator30 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger28 } from "@ooneex/logger";
 import { toPascalCase as toPascalCase17 } from "@ooneex/utils";
 
 // src/templates/vector-database.test.txt
@@ -11354,28 +11531,28 @@ class MakeVectorDatabaseCommand {
     if (module) {
       await ensureModule(module);
     }
-    const base = module ? join27("modules", module) : ".";
-    const vectorDatabaseLocalDir = join27(base, "src", "databases");
-    const vectorDatabaseDir = join27(process.cwd(), vectorDatabaseLocalDir);
-    const filePath = join27(vectorDatabaseDir, `${name}VectorDatabase.ts`);
+    const base = module ? join30("modules", module) : ".";
+    const vectorDatabaseLocalDir = join30(base, "src", "databases");
+    const vectorDatabaseDir = join30(process.cwd(), vectorDatabaseLocalDir);
+    const filePath = join30(vectorDatabaseDir, `${name}VectorDatabase.ts`);
     await Bun.write(filePath, content);
     const testContent = vector_database_test_default.replace(/{{NAME}}/g, name);
-    const testsLocalDir = join27(base, "tests", "databases");
-    const testsDir = join27(process.cwd(), testsLocalDir);
-    const testFilePath = join27(testsDir, `${name}VectorDatabase.spec.ts`);
+    const testsLocalDir = join30(base, "tests", "databases");
+    const testsDir = join30(process.cwd(), testsLocalDir);
+    const testFilePath = join30(testsDir, `${name}VectorDatabase.spec.ts`);
     await Bun.write(testFilePath, testContent);
-    const logger = new TerminalLogger25;
-    logger.success(`${join27(vectorDatabaseLocalDir, name)}VectorDatabase.ts created successfully`, undefined, {
+    const logger = new TerminalLogger28;
+    logger.success(`${join30(vectorDatabaseLocalDir, name)}VectorDatabase.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    logger.success(`${join27(testsLocalDir, name)}VectorDatabase.spec.ts created successfully`, undefined, {
+    logger.success(`${join30(testsLocalDir, name)}VectorDatabase.spec.ts created successfully`, undefined, {
       showTimestamp: false,
       showArrow: false,
       useSymbol: true
     });
-    const packageJsonPath = join27(process.cwd(), "package.json");
+    const packageJsonPath = join30(process.cwd(), "package.json");
     const packageJson = await Bun.file(packageJsonPath).json();
     const deps = packageJson.dependencies ?? {};
     const devDeps = packageJson.devDependencies ?? {};
@@ -11390,9 +11567,157 @@ class MakeVectorDatabaseCommand {
   }
 }
 MakeVectorDatabaseCommand = __legacyDecorateClassTS([
-  decorator26.command()
+  decorator30.command()
 ], MakeVectorDatabaseCommand);
+// src/commands/MigrationUpCommand.ts
+import { existsSync } from "fs";
+import { join as join31 } from "path";
+import { decorator as decorator31 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger29 } from "@ooneex/logger";
+class MigrationUpCommand {
+  getName() {
+    return "migration:up";
+  }
+  getDescription() {
+    return "Run migrations for all modules";
+  }
+  async run() {
+    const logger = new TerminalLogger29;
+    const modulesDir = join31(process.cwd(), "modules");
+    if (!existsSync(modulesDir)) {
+      logger.warn("No modules with migrations found", undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+      return;
+    }
+    const glob = new Bun.Glob("*/package.json");
+    const modules = [];
+    for await (const match of glob.scan({ cwd: modulesDir, onlyFiles: true })) {
+      const entry = match.replace("/package.json", "");
+      const moduleDir = join31(modulesDir, entry);
+      const migrationUpFile = Bun.file(join31(moduleDir, "bin", "migration", "up.ts"));
+      if (await migrationUpFile.exists()) {
+        const packageJson = await Bun.file(join31(modulesDir, match)).json();
+        modules.push({ name: packageJson.name ?? entry, dir: moduleDir });
+      }
+    }
+    if (modules.length === 0) {
+      logger.warn("No modules with migrations found", undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+      return;
+    }
+    for (const { name, dir } of modules) {
+      const migrationUpPath = join31(dir, "bin", "migration", "up.ts");
+      logger.info(`Running migrations for ${name}...`, undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+      const proc = Bun.spawn(["bun", "run", migrationUpPath], {
+        cwd: dir,
+        stdout: "inherit",
+        stderr: "inherit"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode === 0) {
+        logger.success(`Migrations completed for ${name}`, undefined, {
+          showTimestamp: false,
+          showArrow: false,
+          useSymbol: true
+        });
+      } else {
+        logger.error(`Migrations failed for ${name} (exit code: ${exitCode})`, undefined, {
+          showTimestamp: false,
+          showArrow: false,
+          useSymbol: true
+        });
+      }
+    }
+  }
+}
+MigrationUpCommand = __legacyDecorateClassTS([
+  decorator31.command()
+], MigrationUpCommand);
+// src/commands/SeedRunCommand.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join32 } from "path";
+import { decorator as decorator32 } from "@ooneex/command";
+import { TerminalLogger as TerminalLogger30 } from "@ooneex/logger";
+class SeedRunCommand {
+  getName() {
+    return "seed:run";
+  }
+  getDescription() {
+    return "Run seeds for all modules";
+  }
+  async run() {
+    const logger = new TerminalLogger30;
+    const modulesDir = join32(process.cwd(), "modules");
+    if (!existsSync2(modulesDir)) {
+      logger.warn("No modules with seeds found", undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+      return;
+    }
+    const glob = new Bun.Glob("*/package.json");
+    const modules = [];
+    for await (const match of glob.scan({ cwd: modulesDir, onlyFiles: true })) {
+      const entry = match.replace("/package.json", "");
+      const moduleDir = join32(modulesDir, entry);
+      const seedRunFile = Bun.file(join32(moduleDir, "bin", "seed", "run.ts"));
+      if (await seedRunFile.exists()) {
+        const packageJson = await Bun.file(join32(modulesDir, match)).json();
+        modules.push({ name: packageJson.name ?? entry, dir: moduleDir });
+      }
+    }
+    if (modules.length === 0) {
+      logger.warn("No modules with seeds found", undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+      return;
+    }
+    for (const { name, dir } of modules) {
+      const seedRunPath = join32(dir, "bin", "seed", "run.ts");
+      logger.info(`Running seeds for ${name}...`, undefined, {
+        showTimestamp: false,
+        showArrow: false,
+        useSymbol: true
+      });
+      const proc = Bun.spawn(["bun", "run", seedRunPath], {
+        cwd: dir,
+        stdout: "inherit",
+        stderr: "inherit"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode === 0) {
+        logger.success(`Seeds completed for ${name}`, undefined, {
+          showTimestamp: false,
+          showArrow: false,
+          useSymbol: true
+        });
+      } else {
+        logger.error(`Seeds failed for ${name} (exit code: ${exitCode})`, undefined, {
+          showTimestamp: false,
+          showArrow: false,
+          useSymbol: true
+        });
+      }
+    }
+  }
+}
+SeedRunCommand = __legacyDecorateClassTS([
+  decorator32.command()
+], SeedRunCommand);
 // src/index.ts
 await run();
 
-//# debugId=14FC8E204F5BE58B64756E2164756E21
+//# debugId=1317A3FF7CEC8E3164756E2164756E21