@gaman/kame 0.1.0

package/README.md

@@ -0,0 +1,21 @@
+# @gaman/static
+**Secure, Lightweight & High-Performance Static File Server for GamanJS**. Built for Bun, optimized for speed with non-blocking I/O, built-in compression, and ETag caching.
+
+## Installation
+```bash
+bun add @gaman/static
+```
+
+## Quick Used
+By default, this middleware will serve files from the `public/` folder in the root of your project.
+```ts
+import { defineBootstrap } from "gaman";
+import { StaticServe } from "@gaman/static";
+
+defineBootstrap((app) => {
+  // Mount the static server
+  app.mount(StaticServe());
+  
+  app.mountServer(...)
+});
+```

package/dist/commands/buntest-cmd.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/buntest-cmd.js

@@ -0,0 +1,23 @@
+"use strict";
+var import_bun = require("bun"), import_utils = require('gaman/utils'), import_registry = require('./registry.js');
+const handler = async (args) => {
+  import_utils.Logger.info("Starting Bun test suite...");
+  try {
+    (await import_bun.$`bun test ${args}`.quiet().text()).split(`
+`).forEach((line) => {
+      line.trim() && import_utils.Logger.info(line);
+    }), import_utils.Logger.info("All tests passed successfully.");
+  } catch (err) {
+    (err.stderr?.toString() || err.stdout?.toString() || "").split(`
+`).forEach((line) => {
+      line.trim() && import_utils.Logger.error(line);
+    }), import_utils.Logger.error("Test suite failed.");
+  }
+};
+(0, import_registry.registerCommand)({
+  name: "test",
+  description: "Run project tests.",
+  usage: "test [filter]",
+  aliases: ["t"],
+  handler
+});

package/dist/commands/buntest-cmd.mjs

@@ -0,0 +1,24 @@
+import { $ } from "bun";
+import { Logger } from 'gaman/utils';
+import { registerCommand } from "./registry.mjs";
+const handler = async (args) => {
+  Logger.info("Starting Bun test suite...");
+  try {
+    (await $`bun test ${args}`.quiet().text()).split(`
+`).forEach((line) => {
+      line.trim() && Logger.info(line);
+    }), Logger.info("All tests passed successfully.");
+  } catch (err) {
+    (err.stderr?.toString() || err.stdout?.toString() || "").split(`
+`).forEach((line) => {
+      line.trim() && Logger.error(line);
+    }), Logger.error("Test suite failed.");
+  }
+};
+registerCommand({
+  name: "test",
+  description: "Run project tests.",
+  usage: "test [filter]",
+  aliases: ["t"],
+  handler
+});

package/dist/commands/fetch.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/fetch.js

@@ -0,0 +1,46 @@
+"use strict";
+var import_utils = require('gaman/utils'), import_registry = require('./registry.js');
+const handler = async (args) => {
+  const method = args[0]?.toUpperCase(), url = args[1];
+  if (!method || !url) {
+    import_utils.Logger.error("Usage: fetch <METHOD> <URL> [-h Header] [-b Body]");
+    return;
+  }
+  const headerIndex = args.indexOf("-h"), bodyIndex = args.indexOf("-b"), headers = {
+    "Content-Type": "application/json"
+  };
+  if (headerIndex !== -1 && args[headerIndex + 1]) {
+    const headerRaw = args[headerIndex + 1], splitIndex = headerRaw?.indexOf(":") || -1;
+    if (splitIndex !== -1) {
+      const key = headerRaw?.slice(0, splitIndex).trim() || "", value = headerRaw?.slice(splitIndex + 1).trim() || "";
+      headers[key] = value;
+    }
+  }
+  let body = null;
+  bodyIndex !== -1 && args[bodyIndex + 1] && (body = args[bodyIndex + 1]), import_utils.Logger.info(`Sending ${method} request to: ${url}`);
+  try {
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: ["GET", "HEAD"].includes(method) ? null : body
+    }), resText = await response.text();
+    let resData;
+    try {
+      resData = JSON.parse(resText);
+    } catch {
+      resData = resText;
+    }
+    response.ok ? (import_utils.Logger.info(`Status: ${response.status}`), console.log(
+      typeof resData == "object" ? JSON.stringify(resData, null, 2) : resData
+    )) : (import_utils.Logger.error(`Status: ${response.status}`), console.log(resData));
+  } catch (err) {
+    import_utils.Logger.error(`Fetch failed: ${err.message}`);
+  }
+};
+(0, import_registry.registerCommand)({
+  name: "fetch",
+  description: "Request internal/external API via CLI",
+  usage: 'fetch <METHOD> <URL> [-h "Key: Value"] [-b "Body"]',
+  aliases: ["req"],
+  handler
+});

package/dist/commands/fetch.mjs

@@ -0,0 +1,46 @@
+import { Logger } from 'gaman/utils';
+import { registerCommand } from "./registry.mjs";
+const handler = async (args) => {
+  const method = args[0]?.toUpperCase(), url = args[1];
+  if (!method || !url) {
+    Logger.error("Usage: fetch <METHOD> <URL> [-h Header] [-b Body]");
+    return;
+  }
+  const headerIndex = args.indexOf("-h"), bodyIndex = args.indexOf("-b"), headers = {
+    "Content-Type": "application/json"
+  };
+  if (headerIndex !== -1 && args[headerIndex + 1]) {
+    const headerRaw = args[headerIndex + 1], splitIndex = headerRaw?.indexOf(":") || -1;
+    if (splitIndex !== -1) {
+      const key = headerRaw?.slice(0, splitIndex).trim() || "", value = headerRaw?.slice(splitIndex + 1).trim() || "";
+      headers[key] = value;
+    }
+  }
+  let body = null;
+  bodyIndex !== -1 && args[bodyIndex + 1] && (body = args[bodyIndex + 1]), Logger.info(`Sending ${method} request to: ${url}`);
+  try {
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: ["GET", "HEAD"].includes(method) ? null : body
+    }), resText = await response.text();
+    let resData;
+    try {
+      resData = JSON.parse(resText);
+    } catch {
+      resData = resText;
+    }
+    response.ok ? (Logger.info(`Status: ${response.status}`), console.log(
+      typeof resData == "object" ? JSON.stringify(resData, null, 2) : resData
+    )) : (Logger.error(`Status: ${response.status}`), console.log(resData));
+  } catch (err) {
+    Logger.error(`Fetch failed: ${err.message}`);
+  }
+};
+registerCommand({
+  name: "fetch",
+  description: "Request internal/external API via CLI",
+  usage: 'fetch <METHOD> <URL> [-h "Key: Value"] [-b "Body"]',
+  aliases: ["req"],
+  handler
+});

package/dist/commands/gen-controller.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/gen-controller.js

@@ -0,0 +1,21 @@
+"use strict";
+var import_utils = require('gaman/utils'), import_node_path = require("node:path"), import_registry = require('./registry.js'), import_module = require('../templates/module.js'), import_utils2 = require('../utils.js');
+const handler = async (args) => {
+  const [name, module2 = "app"] = args;
+  if (!name || !module2) {
+    import_utils.Logger.error("Usage: gen:controller <name> <module: 'app'>");
+    return;
+  }
+  const nameCapitalized = (0, import_utils2.capitalize)(name), cwd = process.cwd(), controllerDir = (0, import_node_path.join)(cwd, "src", "modules", module2, "controllers"), filePath = (0, import_node_path.join)(controllerDir, `${nameCapitalized}Controller.ts`);
+  await Bun.$`mkdir -p ${controllerDir}`.quiet(), await Bun.write(filePath, (0, import_module.controllerTemplate)(name) + `
+`), import_utils.Logger.info(`created  ${(0, import_node_path.relative)(cwd, filePath)}`), import_utils.Logger.info(
+    `Controller "${nameCapitalized}Controller" generated successfully.`
+  );
+};
+(0, import_registry.registerCommand)({
+  name: "gen:controller",
+  description: "Generate a new Controller inside an existing module",
+  usage: "gen:controller <name> <module: 'app'>",
+  aliases: ["gen:co"],
+  handler
+});

package/dist/commands/gen-controller.mjs

@@ -0,0 +1,24 @@
+import { Logger } from 'gaman/utils';
+import { join, relative } from "node:path";
+import { registerCommand } from "./registry.mjs";
+import { controllerTemplate } from "../templates/module.mjs";
+import { capitalize } from "../utils.mjs";
+const handler = async (args) => {
+  const [name, module = "app"] = args;
+  if (!name || !module) {
+    Logger.error("Usage: gen:controller <name> <module: 'app'>");
+    return;
+  }
+  const nameCapitalized = capitalize(name), cwd = process.cwd(), controllerDir = join(cwd, "src", "modules", module, "controllers"), filePath = join(controllerDir, `${nameCapitalized}Controller.ts`);
+  await Bun.$`mkdir -p ${controllerDir}`.quiet(), await Bun.write(filePath, controllerTemplate(name) + `
+`), Logger.info(`created  ${relative(cwd, filePath)}`), Logger.info(
+    `Controller "${nameCapitalized}Controller" generated successfully.`
+  );
+};
+registerCommand({
+  name: "gen:controller",
+  description: "Generate a new Controller inside an existing module",
+  usage: "gen:controller <name> <module: 'app'>",
+  aliases: ["gen:co"],
+  handler
+});

package/dist/commands/gen-exception.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/gen-exception.js

@@ -0,0 +1,23 @@
+"use strict";
+var import_utils = require('gaman/utils'), import_node_path = require("node:path"), import_registry = require('./registry.js'), import_module = require('../templates/module.js'), import_utils2 = require('../utils.js');
+const handler = async (args) => {
+  const [name, module2 = "app"] = args;
+  if (!name || !module2) {
+    import_utils.Logger.error("Usage: gen:exception <name> <module: 'app'>");
+    return;
+  }
+  const nameCapitalized = (0, import_utils2.capitalize)(name), cwd = process.cwd(), exceptionDir = (0, import_node_path.join)(cwd, "src", "modules", module2, "exceptions"), filePath = (0, import_node_path.join)(exceptionDir, `${nameCapitalized}Exception.ts`);
+  await Bun.$`mkdir -p ${exceptionDir}`.quiet(), await Bun.write(filePath, (0, import_module.exceptionTemplate)() + `
+`), import_utils.Logger.info(
+    `created ${import_utils.TextFormat.UNDERLINE}${(0, import_node_path.relative)(cwd, filePath)}${import_utils.TextFormat.RESET}`
+  ), import_utils.Logger.info(
+    `Exception "${nameCapitalized}Exception" generated successfully.`
+  );
+};
+(0, import_registry.registerCommand)({
+  name: "gen:exception",
+  description: "Generate a new Exception inside an existing module",
+  usage: "gen:exception <name> <module: 'app'>",
+  aliases: ["gen:ex"],
+  handler
+});

package/dist/commands/gen-exception.mjs

@@ -0,0 +1,26 @@
+import { Logger, TextFormat } from 'gaman/utils';
+import { join, relative } from "node:path";
+import { registerCommand } from "./registry.mjs";
+import { exceptionTemplate } from "../templates/module.mjs";
+import { capitalize } from "../utils.mjs";
+const handler = async (args) => {
+  const [name, module = "app"] = args;
+  if (!name || !module) {
+    Logger.error("Usage: gen:exception <name> <module: 'app'>");
+    return;
+  }
+  const nameCapitalized = capitalize(name), cwd = process.cwd(), exceptionDir = join(cwd, "src", "modules", module, "exceptions"), filePath = join(exceptionDir, `${nameCapitalized}Exception.ts`);
+  await Bun.$`mkdir -p ${exceptionDir}`.quiet(), await Bun.write(filePath, exceptionTemplate() + `
+`), Logger.info(
+    `created ${TextFormat.UNDERLINE}${relative(cwd, filePath)}${TextFormat.RESET}`
+  ), Logger.info(
+    `Exception "${nameCapitalized}Exception" generated successfully.`
+  );
+};
+registerCommand({
+  name: "gen:exception",
+  description: "Generate a new Exception inside an existing module",
+  usage: "gen:exception <name> <module: 'app'>",
+  aliases: ["gen:ex"],
+  handler
+});

package/dist/commands/gen-middleware.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/gen-middleware.js

@@ -0,0 +1,23 @@
+"use strict";
+var import_utils = require('gaman/utils'), import_node_path = require("node:path"), import_registry = require('./registry.js'), import_module = require('../templates/module.js'), import_utils2 = require('../utils.js');
+const handler = async (args) => {
+  const [name, module2 = "app"] = args;
+  if (!name || !module2) {
+    import_utils.Logger.error("Usage: gen:middleware <name> <module: 'app'>");
+    return;
+  }
+  const nameCapitalized = (0, import_utils2.capitalize)(name), cwd = process.cwd(), middlewareDir = (0, import_node_path.join)(cwd, "src", "modules", module2, "middlewares"), filePath = (0, import_node_path.join)(middlewareDir, `${nameCapitalized}Middleware.ts`);
+  await Bun.$`mkdir -p ${middlewareDir}`.quiet(), await Bun.write(filePath, (0, import_module.middlewareTemplate)() + `
+`), import_utils.Logger.info(
+    `created ${import_utils.TextFormat.UNDERLINE}${(0, import_node_path.relative)(cwd, filePath)}${import_utils.TextFormat.RESET}`
+  ), import_utils.Logger.info(
+    `Middleware "${nameCapitalized}Middleware" generated successfully.`
+  );
+};
+(0, import_registry.registerCommand)({
+  name: "gen:middleware",
+  description: "Generate a new Middleware inside an existing module",
+  usage: "gen:middleware <name> <module: 'app'>",
+  aliases: ["gen:mi"],
+  handler
+});

package/dist/commands/gen-middleware.mjs

@@ -0,0 +1,26 @@
+import { Logger, TextFormat } from 'gaman/utils';
+import { join, relative } from "node:path";
+import { registerCommand } from "./registry.mjs";
+import { middlewareTemplate } from "../templates/module.mjs";
+import { capitalize } from "../utils.mjs";
+const handler = async (args) => {
+  const [name, module = "app"] = args;
+  if (!name || !module) {
+    Logger.error("Usage: gen:middleware <name> <module: 'app'>");
+    return;
+  }
+  const nameCapitalized = capitalize(name), cwd = process.cwd(), middlewareDir = join(cwd, "src", "modules", module, "middlewares"), filePath = join(middlewareDir, `${nameCapitalized}Middleware.ts`);
+  await Bun.$`mkdir -p ${middlewareDir}`.quiet(), await Bun.write(filePath, middlewareTemplate() + `
+`), Logger.info(
+    `created ${TextFormat.UNDERLINE}${relative(cwd, filePath)}${TextFormat.RESET}`
+  ), Logger.info(
+    `Middleware "${nameCapitalized}Middleware" generated successfully.`
+  );
+};
+registerCommand({
+  name: "gen:middleware",
+  description: "Generate a new Middleware inside an existing module",
+  usage: "gen:middleware <name> <module: 'app'>",
+  aliases: ["gen:mi"],
+  handler
+});

package/dist/commands/gen-module.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/gen-module.js

@@ -0,0 +1,40 @@
+"use strict";
+var import_utils = require('gaman/utils'), import_node_path = require("node:path"), import_registry = require('./registry.js'), import_module = require('../templates/module.js'), import_utils2 = require('../utils.js');
+const handler = async (args) => {
+  const modulePath = args[0];
+  if (!modulePath) {
+    import_utils.Logger.error("Usage: gen:module <name>");
+    return;
+  }
+  const name = (0, import_node_path.basename)(modulePath), nameCapitalized = (0, import_utils2.capitalize)(name), cwd = process.cwd(), moduleDir = (0, import_node_path.join)(cwd, "src", "modules", modulePath), files = [
+    {
+      filePath: (0, import_node_path.join)(
+        moduleDir,
+        "controllers",
+        `${nameCapitalized}Controller.ts`
+      ),
+      content: (0, import_module.controllerTemplate)(name)
+    },
+    {
+      filePath: (0, import_node_path.join)(moduleDir, "services", `${nameCapitalized}Service.ts`),
+      content: (0, import_module.serviceTemplate)(name)
+    },
+    {
+      filePath: (0, import_node_path.join)(moduleDir, `${nameCapitalized}Router.ts`),
+      content: (0, import_module.routerTemplate)(name)
+    }
+  ];
+  for (const { filePath, content } of files) {
+    const dir = (0, import_node_path.dirname)(filePath);
+    await Bun.$`mkdir -p ${dir}`.quiet(), await Bun.write(filePath, content + `
+`), import_utils.Logger.info(`created  ${(0, import_node_path.relative)(cwd, filePath)}`);
+  }
+  import_utils.Logger.info(`Module "${nameCapitalized}" generated successfully.`);
+};
+(0, import_registry.registerCommand)({
+  name: "gen:module",
+  description: "Generate a new module with Controller, Service, and Router",
+  usage: "gen:module <name>",
+  aliases: ["gen:mo"],
+  handler
+});

package/dist/commands/gen-module.mjs

@@ -0,0 +1,47 @@
+import { Logger } from 'gaman/utils';
+import { join, basename, relative, dirname } from "node:path";
+import { registerCommand } from "./registry.mjs";
+import {
+  controllerTemplate,
+  routerTemplate,
+  serviceTemplate
+} from "../templates/module.mjs";
+import { capitalize } from "../utils.mjs";
+const handler = async (args) => {
+  const modulePath = args[0];
+  if (!modulePath) {
+    Logger.error("Usage: gen:module <name>");
+    return;
+  }
+  const name = basename(modulePath), nameCapitalized = capitalize(name), cwd = process.cwd(), moduleDir = join(cwd, "src", "modules", modulePath), files = [
+    {
+      filePath: join(
+        moduleDir,
+        "controllers",
+        `${nameCapitalized}Controller.ts`
+      ),
+      content: controllerTemplate(name)
+    },
+    {
+      filePath: join(moduleDir, "services", `${nameCapitalized}Service.ts`),
+      content: serviceTemplate(name)
+    },
+    {
+      filePath: join(moduleDir, `${nameCapitalized}Router.ts`),
+      content: routerTemplate(name)
+    }
+  ];
+  for (const { filePath, content } of files) {
+    const dir = dirname(filePath);
+    await Bun.$`mkdir -p ${dir}`.quiet(), await Bun.write(filePath, content + `
+`), Logger.info(`created  ${relative(cwd, filePath)}`);
+  }
+  Logger.info(`Module "${nameCapitalized}" generated successfully.`);
+};
+registerCommand({
+  name: "gen:module",
+  description: "Generate a new module with Controller, Service, and Router",
+  usage: "gen:module <name>",
+  aliases: ["gen:mo"],
+  handler
+});

package/dist/commands/gen-router.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/gen-router.js

@@ -0,0 +1,19 @@
+"use strict";
+var import_utils = require('gaman/utils'), import_node_path = require("node:path"), import_registry = require('./registry.js'), import_module = require('../templates/module.js'), import_utils2 = require('../utils.js');
+const handler = async (args) => {
+  const [name, module2 = "app"] = args;
+  if (!name || !module2) {
+    import_utils.Logger.error("Usage: gen:router <name> <module: 'app'>");
+    return;
+  }
+  const nameCapitalized = (0, import_utils2.capitalize)(name), cwd = process.cwd(), routerDir = (0, import_node_path.join)(cwd, "src", "modules", module2), filePath = (0, import_node_path.join)(routerDir, `${nameCapitalized}Router.ts`);
+  await Bun.$`mkdir -p ${routerDir}`.quiet(), await Bun.write(filePath, (0, import_module.routerBlankTemplate)() + `
+`), import_utils.Logger.info(`created  ${(0, import_node_path.relative)(cwd, filePath)}`), import_utils.Logger.info(`Router "${nameCapitalized}Router" generated successfully.`);
+};
+(0, import_registry.registerCommand)({
+  name: "gen:router",
+  description: "Generate a new Router inside an existing module",
+  usage: "gen:router <name> <module: 'app'>",
+  aliases: ["gen:ro"],
+  handler
+});

package/dist/commands/gen-router.mjs

@@ -0,0 +1,22 @@
+import { Logger } from 'gaman/utils';
+import { join, relative } from "node:path";
+import { registerCommand } from "./registry.mjs";
+import { routerBlankTemplate } from "../templates/module.mjs";
+import { capitalize } from "../utils.mjs";
+const handler = async (args) => {
+  const [name, module = "app"] = args;
+  if (!name || !module) {
+    Logger.error("Usage: gen:router <name> <module: 'app'>");
+    return;
+  }
+  const nameCapitalized = capitalize(name), cwd = process.cwd(), routerDir = join(cwd, "src", "modules", module), filePath = join(routerDir, `${nameCapitalized}Router.ts`);
+  await Bun.$`mkdir -p ${routerDir}`.quiet(), await Bun.write(filePath, routerBlankTemplate() + `
+`), Logger.info(`created  ${relative(cwd, filePath)}`), Logger.info(`Router "${nameCapitalized}Router" generated successfully.`);
+};
+registerCommand({
+  name: "gen:router",
+  description: "Generate a new Router inside an existing module",
+  usage: "gen:router <name> <module: 'app'>",
+  aliases: ["gen:ro"],
+  handler
+});

package/dist/commands/gen-service.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/gen-service.js

@@ -0,0 +1,55 @@
+"use strict";
+var import_utils = require('gaman/utils'), import_node_path = require("node:path"), import_registry = require('./registry.js'), import_service = require('../templates/service.js'), import_utils2 = require('../utils.js');
+const patchRouter = async (routerPath, serviceName) => {
+  const file = Bun.file(routerPath);
+  if (!await file.exists()) {
+    import_utils.Logger.warn(`Router not found at ${routerPath}, skipping auto-register.`);
+    return;
+  }
+  const nameCapitalized = (0, import_utils2.capitalize)(serviceName), camelName = (0, import_utils2.toCamelCase)(serviceName), importLine = `import { ${nameCapitalized}Service } from './services/${nameCapitalized}Service';`, mountEntry = `		${camelName}Service: ${nameCapitalized}Service(),`;
+  let source = await file.text();
+  if (!source.includes(importLine)) {
+    const lastImportIdx = source.lastIndexOf(`
+import `), insertAfter = lastImportIdx !== -1 ? source.indexOf(`
+`, lastImportIdx + 1) : source.indexOf(`
+`);
+    source = source.slice(0, insertAfter) + `
+` + importLine + source.slice(insertAfter);
+  }
+  if (!source.includes(`${camelName}Service:`)) {
+    const mountStart = source.indexOf("r.mountService({");
+    if (mountStart !== -1) {
+      const closingIdx = source.indexOf("	});", mountStart);
+      closingIdx !== -1 && (source = source.slice(0, closingIdx) + mountEntry + `
+` + source.slice(closingIdx));
+    } else
+      import_utils.Logger.warn(
+        `r.mountService block not found in ${routerPath}, skipping auto-register.`
+      );
+  }
+  await Bun.write(routerPath, source);
+}, handler = async (args) => {
+  const [name, module2 = "app"] = args;
+  if (!name || !module2) {
+    import_utils.Logger.error("Usage: gen:service <name> <module: 'app'>");
+    return;
+  }
+  const nameCapitalized = (0, import_utils2.capitalize)(name), moduleSegment = (0, import_node_path.basename)(module2), moduleCapitalized = (0, import_utils2.capitalize)(moduleSegment), cwd = process.cwd(), serviceDir = (0, import_node_path.join)(cwd, "src", "modules", module2, "services"), filePath = (0, import_node_path.join)(serviceDir, `${nameCapitalized}Service.ts`);
+  await Bun.$`mkdir -p ${serviceDir}`.quiet(), await Bun.write(filePath, (0, import_service.standaloneServiceTemplate)(name) + `
+`), import_utils.Logger.info(`created  ${(0, import_node_path.relative)(cwd, filePath)}`);
+  const routerPath = (0, import_node_path.join)(
+    cwd,
+    "src",
+    "modules",
+    module2,
+    `${moduleCapitalized}Router.ts`
+  );
+  await patchRouter(routerPath, name), import_utils.Logger.info(`updated  ${(0, import_node_path.relative)(cwd, routerPath)}`), import_utils.Logger.info(`Service "${nameCapitalized}Service" generated successfully.`);
+};
+(0, import_registry.registerCommand)({
+  name: "gen:service",
+  description: "Generate a new Service and register it in the module Router",
+  usage: "gen:service <name> <module: 'app'>",
+  aliases: ["gen:se"],
+  handler
+});

package/dist/commands/gen-service.mjs

@@ -0,0 +1,58 @@
+import { Logger } from 'gaman/utils';
+import { join, relative, basename } from "node:path";
+import { registerCommand } from "./registry.mjs";
+import { standaloneServiceTemplate } from "../templates/service.mjs";
+import { capitalize, toCamelCase } from "../utils.mjs";
+const patchRouter = async (routerPath, serviceName) => {
+  const file = Bun.file(routerPath);
+  if (!await file.exists()) {
+    Logger.warn(`Router not found at ${routerPath}, skipping auto-register.`);
+    return;
+  }
+  const nameCapitalized = capitalize(serviceName), camelName = toCamelCase(serviceName), importLine = `import { ${nameCapitalized}Service } from './services/${nameCapitalized}Service.mjs';`, mountEntry = `		${camelName}Service: ${nameCapitalized}Service(),`;
+  let source = await file.text();
+  if (!source.includes(importLine)) {
+    const lastImportIdx = source.lastIndexOf(`
+import `), insertAfter = lastImportIdx !== -1 ? source.indexOf(`
+`, lastImportIdx + 1) : source.indexOf(`
+`);
+    source = source.slice(0, insertAfter) + `
+` + importLine + source.slice(insertAfter);
+  }
+  if (!source.includes(`${camelName}Service:`)) {
+    const mountStart = source.indexOf("r.mountService({");
+    if (mountStart !== -1) {
+      const closingIdx = source.indexOf("	});", mountStart);
+      closingIdx !== -1 && (source = source.slice(0, closingIdx) + mountEntry + `
+` + source.slice(closingIdx));
+    } else
+      Logger.warn(
+        `r.mountService block not found in ${routerPath}, skipping auto-register.`
+      );
+  }
+  await Bun.write(routerPath, source);
+}, handler = async (args) => {
+  const [name, module = "app"] = args;
+  if (!name || !module) {
+    Logger.error("Usage: gen:service <name> <module: 'app'>");
+    return;
+  }
+  const nameCapitalized = capitalize(name), moduleSegment = basename(module), moduleCapitalized = capitalize(moduleSegment), cwd = process.cwd(), serviceDir = join(cwd, "src", "modules", module, "services"), filePath = join(serviceDir, `${nameCapitalized}Service.ts`);
+  await Bun.$`mkdir -p ${serviceDir}`.quiet(), await Bun.write(filePath, standaloneServiceTemplate(name) + `
+`), Logger.info(`created  ${relative(cwd, filePath)}`);
+  const routerPath = join(
+    cwd,
+    "src",
+    "modules",
+    module,
+    `${moduleCapitalized}Router.ts`
+  );
+  await patchRouter(routerPath, name), Logger.info(`updated  ${relative(cwd, routerPath)}`), Logger.info(`Service "${nameCapitalized}Service" generated successfully.`);
+};
+registerCommand({
+  name: "gen:service",
+  description: "Generate a new Service and register it in the module Router",
+  usage: "gen:service <name> <module: 'app'>",
+  aliases: ["gen:se"],
+  handler
+});

package/dist/commands/registry.d.ts

@@ -0,0 +1,26 @@
+export type CommandHandler = (args: string[], flags: Record<string, string | boolean>) => Promise<void> | void;
+export declare class Command {
+    private _name;
+    private _handler;
+    private _description;
+    private _usage;
+    private _aliases;
+    constructor(name: string, handler: CommandHandler);
+    description(description: string): this;
+    usage(usage: string): this;
+    aliases(aliases: string[]): this;
+    getName(): string;
+    getHandler(): CommandHandler;
+    getDescription(): string;
+    getUsage(): string;
+    getAliases(): string[];
+}
+export declare const registerCommand: (cmd: Command | {
+    name: string;
+    handler: CommandHandler;
+    description?: string;
+    usage?: string;
+    aliases?: string[];
+}) => void;
+export declare const getCommand: (name: string) => Command | undefined;
+export declare const getAllCommands: () => Command[];