@forinda/kickjs-cli 0.6.0 → 1.0.0

package/dist/cli.js

@@ -4,6 +4,9 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/cli.ts
 import { Command } from "commander";
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname3, join as join14 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/commands/init.ts
 import { resolve, basename } from "path";
@@ -11,8 +14,10 @@ import { createInterface } from "readline";
 import { existsSync, readdirSync, rmSync } from "fs";
 
 // src/generators/project.ts
-import { join } from "path";
+import { join, dirname as dirname2 } from "path";
 import { execSync } from "child_process";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
 
 // src/utils/fs.ts
 import { writeFile, mkdir, access, readFile } from "fs/promises";
@@ -35,15 +40,42 @@ async function fileExists(filePath) {
 __name(fileExists, "fileExists");
 
 // src/generators/project.ts
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var cliPkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+var KICKJS_VERSION = `^${cliPkg.version}`;
 async function initProject(options) {
-  const { name, directory, packageManager = "pnpm" } = options;
+  const { name, directory, packageManager = "pnpm", template = "rest" } = options;
   const dir = directory;
   console.log(`
   Creating KickJS project: ${name}
 `);
+  const baseDeps = {
+    "@forinda/kickjs-core": KICKJS_VERSION,
+    "@forinda/kickjs-http": KICKJS_VERSION,
+    "@forinda/kickjs-config": KICKJS_VERSION,
+    express: "^5.1.0",
+    "reflect-metadata": "^0.2.2",
+    zod: "^4.3.6",
+    pino: "^10.3.1",
+    "pino-pretty": "^13.1.3"
+  };
+  if (template !== "minimal") {
+    baseDeps["@forinda/kickjs-swagger"] = KICKJS_VERSION;
+  }
+  if (template === "graphql") {
+    baseDeps["@forinda/kickjs-graphql"] = KICKJS_VERSION;
+    baseDeps["graphql"] = "^16.11.0";
+  }
+  if (template === "microservice") {
+    baseDeps["@forinda/kickjs-queue"] = KICKJS_VERSION;
+    baseDeps["@forinda/kickjs-otel"] = KICKJS_VERSION;
+  }
+  if (template === "ddd") {
+    baseDeps["@forinda/kickjs-swagger"] = KICKJS_VERSION;
+  }
   await writeFileSafe(join(dir, "package.json"), JSON.stringify({
     name,
-    version: "0.1.0",
+    version: cliPkg.version,
     type: "module",
     scripts: {
       dev: "kick dev",
@@ -56,19 +88,9 @@ async function initProject(options) {
       lint: "eslint src/",
       format: "prettier --write src/"
     },
-    dependencies: {
-      "@forinda/kickjs-core": "^0.1.0",
-      "@forinda/kickjs-http": "^0.1.0",
-      "@forinda/kickjs-config": "^0.1.0",
-      "@forinda/kickjs-swagger": "^0.1.0",
-      express: "^5.1.0",
-      "reflect-metadata": "^0.2.2",
-      zod: "^4.3.6",
-      pino: "^10.3.1",
-      "pino-pretty": "^13.1.3"
-    },
+    dependencies: baseDeps,
     devDependencies: {
-      "@forinda/kickjs-cli": "^0.1.0",
+      "@forinda/kickjs-cli": KICKJS_VERSION,
       "@swc/core": "^1.7.28",
       "@types/express": "^5.0.6",
       "@types/node": "^24.5.2",
@@ -157,27 +179,18 @@ NODE_ENV=development
   await writeFileSafe(join(dir, ".env.example"), `PORT=3000
 NODE_ENV=development
 `);
-  await writeFileSafe(join(dir, "src/index.ts"), `import 'reflect-metadata'
-import { bootstrap } from '@forinda/kickjs-http'
-import { SwaggerAdapter } from '@forinda/kickjs-swagger'
-import { modules } from './modules'
-
-bootstrap({
-  modules,
-  adapters: [
-    new SwaggerAdapter({
-      info: { title: '${name}', version: '0.1.0' },
-    }),
-  ],
-})
-`);
+  await writeFileSafe(join(dir, "src/index.ts"), getEntryFile(name, template));
   await writeFileSafe(join(dir, "src/modules/index.ts"), `import type { AppModuleClass } from '@forinda/kickjs-core'
 
 export const modules: AppModuleClass[] = []
 `);
+  if (template === "graphql") {
+    await writeFileSafe(join(dir, "src/resolvers/.gitkeep"), "");
+  }
   await writeFileSafe(join(dir, "kick.config.ts"), `import { defineConfig } from '@forinda/kickjs-cli'
 
 export default defineConfig({
+  pattern: '${template}',
   modulesDir: 'src/modules',
   defaultRepo: 'inmemory',
 
@@ -258,17 +271,103 @@ export default defineConfig({
   console.log("  Next steps:");
   if (needsCd) console.log(`    cd ${name}`);
   if (!options.installDeps) console.log(`    ${packageManager} install`);
-  console.log("    kick g module user");
+  const genHint = {
+    rest: "kick g module user",
+    graphql: "kick g resolver user",
+    ddd: "kick g module user --repo drizzle",
+    microservice: "kick g module user && kick g job email",
+    minimal: "# add your routes to src/index.ts"
+  };
+  console.log(`    ${genHint[template] ?? genHint.rest}`);
   console.log("    kick dev");
   console.log();
   console.log("  Commands:");
   console.log("    kick dev         Start dev server with Vite HMR");
   console.log("    kick build       Production build via Vite");
   console.log("    kick start       Run production build");
-  console.log("    kick g module X  Generate a DDD module");
+  console.log(`    kick g module X  Generate a DDD module`);
+  if (template === "graphql") console.log("    kick g resolver X  Generate a GraphQL resolver");
+  if (template === "microservice") console.log("    kick g job X       Generate a queue job processor");
   console.log();
 }
 __name(initProject, "initProject");
+function getEntryFile(name, template) {
+  switch (template) {
+    case "graphql":
+      return `import 'reflect-metadata'
+import { bootstrap } from '@forinda/kickjs-http'
+import { DevToolsAdapter } from '@forinda/kickjs-http/devtools'
+import { GraphQLAdapter } from '@forinda/kickjs-graphql'
+import { modules } from './modules'
+
+// Import your resolvers here
+// import { UserResolver } from './resolvers/user.resolver'
+
+bootstrap({
+  modules,
+  adapters: [
+    new DevToolsAdapter(),
+    new GraphQLAdapter({
+      resolvers: [/* UserResolver */],
+      // Add custom type definitions here:
+      // typeDefs: userTypeDefs,
+    }),
+  ],
+})
+`;
+    case "microservice":
+      return `import 'reflect-metadata'
+import { bootstrap } from '@forinda/kickjs-http'
+import { DevToolsAdapter } from '@forinda/kickjs-http/devtools'
+import { SwaggerAdapter } from '@forinda/kickjs-swagger'
+import { OtelAdapter } from '@forinda/kickjs-otel'
+// import { QueueAdapter, BullMQProvider } from '@forinda/kickjs-queue'
+import { modules } from './modules'
+
+bootstrap({
+  modules,
+  adapters: [
+    new OtelAdapter({ serviceName: '${name}' }),
+    new DevToolsAdapter(),
+    new SwaggerAdapter({
+      info: { title: '${name}', version: '${cliPkg.version}' },
+    }),
+    // Uncomment when Redis is available:
+    // new QueueAdapter({
+    //   provider: new BullMQProvider({ host: 'localhost', port: 6379 }),
+    // }),
+  ],
+})
+`;
+    case "minimal":
+      return `import 'reflect-metadata'
+import { bootstrap } from '@forinda/kickjs-http'
+import { modules } from './modules'
+
+bootstrap({ modules })
+`;
+    case "ddd":
+    case "rest":
+    default:
+      return `import 'reflect-metadata'
+import { bootstrap } from '@forinda/kickjs-http'
+import { DevToolsAdapter } from '@forinda/kickjs-http/devtools'
+import { SwaggerAdapter } from '@forinda/kickjs-swagger'
+import { modules } from './modules'
+
+bootstrap({
+  modules,
+  adapters: [
+    new DevToolsAdapter(),
+    new SwaggerAdapter({
+      info: { title: '${name}', version: '${cliPkg.version}' },
+    }),
+  ],
+})
+`;
+  }
+}
+__name(getEntryFile, "getEntryFile");
 
 // src/commands/init.ts
 function ask(question, defaultValue) {
@@ -304,7 +403,7 @@ async function confirm(question, defaultYes = true) {
 }
 __name(confirm, "confirm");
 function registerInitCommand(program) {
-  program.command("new [name]").alias("init").description('Create a new KickJS project (use "." for current directory)').option("-d, --directory <dir>", "Target directory (defaults to project name)").option("--pm <manager>", "Package manager: pnpm | npm | yarn").option("--git", "Initialize git repository").option("--no-git", "Skip git initialization").option("--install", "Install dependencies after scaffolding").option("--no-install", "Skip dependency installation").option("-f, --force", "Remove existing files without prompting").action(async (name, opts) => {
+  program.command("new [name]").alias("init").description('Create a new KickJS project (use "." for current directory)').option("-d, --directory <dir>", "Target directory (defaults to project name)").option("--pm <manager>", "Package manager: pnpm | npm | yarn").option("--git", "Initialize git repository").option("--no-git", "Skip git initialization").option("--install", "Install dependencies after scaffolding").option("--no-install", "Skip dependency installation").option("-f, --force", "Remove existing files without prompting").option("-t, --template <type>", "Project template: rest | graphql | ddd | microservice | minimal").action(async (name, opts) => {
     console.log();
     if (!name) {
       name = await ask("Project name", "my-api");
@@ -346,6 +445,24 @@ function registerInitCommand(program) {
         }
       }
     }
+    let template = opts.template;
+    if (!template) {
+      template = await choose("Project template:", [
+        "REST API (Express + Swagger)",
+        "GraphQL API (GraphQL + GraphiQL)",
+        "DDD (Domain-Driven Design modules)",
+        "Microservice (REST + Queue worker)",
+        "Minimal (bare Express)"
+      ], 0);
+      const templateMap = {
+        "REST API (Express + Swagger)": "rest",
+        "GraphQL API (GraphQL + GraphiQL)": "graphql",
+        "DDD (Domain-Driven Design modules)": "ddd",
+        "Microservice (REST + Queue worker)": "microservice",
+        "Minimal (bare Express)": "minimal"
+      };
+      template = templateMap[template] ?? "rest";
+    }
     let packageManager = opts.pm;
     if (!packageManager) {
       packageManager = await choose("Package manager:", [
@@ -371,7 +488,8 @@ function registerInitCommand(program) {
       directory,
       packageManager,
       initGit,
-      installDeps
+      installDeps,
+      template
     });
   });
 }
@@ -1410,10 +1528,10 @@ async function confirm2(message) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve3) => {
+  return new Promise((resolve5) => {
     rl.question(`  ${message} (y/N) `, (answer) => {
       rl.close();
-      resolve3(answer.trim().toLowerCase() === "y");
+      resolve5(answer.trim().toLowerCase() === "y");
     });
   });
 }
@@ -1466,6 +1584,136 @@ export default defineConfig({
 }
 __name(generateConfig, "generateConfig");
 
+// src/generators/resolver.ts
+import { join as join10 } from "path";
+async function generateResolver(options) {
+  const { name, outDir } = options;
+  const pascal = toPascalCase(name);
+  const kebab = toKebabCase(name);
+  const camel = toCamelCase(name);
+  const files = [];
+  const write = /* @__PURE__ */ __name(async (relativePath, content) => {
+    const fullPath = join10(outDir, relativePath);
+    await writeFileSafe(fullPath, content);
+    files.push(fullPath);
+  }, "write");
+  await write(`${kebab}.resolver.ts`, `import { Service } from '@forinda/kickjs-core'
+import { Resolver, Query, Mutation, Arg } from '@forinda/kickjs-graphql'
+
+/**
+ * ${pascal} GraphQL Resolver
+ *
+ * Decorators:
+ *   @Resolver(typeName?) \u2014 marks this class as a GraphQL resolver
+ *   @Query(name?, { returnType?, description? }) \u2014 defines a query field
+ *   @Mutation(name?, { returnType?, description? }) \u2014 defines a mutation field
+ *   @Arg(name, type?) \u2014 marks a method parameter as a GraphQL argument
+ */
+@Service()
+@Resolver('${pascal}')
+export class ${pascal}Resolver {
+  private items: Array<{ id: string; name: string }> = []
+
+  @Query('${camel}s', { returnType: '[${pascal}]', description: 'List all ${camel}s' })
+  findAll() {
+    return this.items
+  }
+
+  @Query('${camel}', { returnType: '${pascal}', description: 'Get a ${camel} by ID' })
+  findById(@Arg('id', 'ID!') id: string) {
+    return this.items.find((item) => item.id === id) ?? null
+  }
+
+  @Mutation('create${pascal}', { returnType: '${pascal}', description: 'Create a new ${camel}' })
+  create(@Arg('name', 'String!') name: string) {
+    const item = { id: String(this.items.length + 1), name }
+    this.items.push(item)
+    return item
+  }
+
+  @Mutation('update${pascal}', { returnType: '${pascal}', description: 'Update a ${camel}' })
+  update(@Arg('id', 'ID!') id: string, @Arg('name', 'String!') name: string) {
+    const item = this.items.find((i) => i.id === id)
+    if (item) item.name = name
+    return item
+  }
+
+  @Mutation('delete${pascal}', { returnType: 'Boolean', description: 'Delete a ${camel}' })
+  remove(@Arg('id', 'ID!') id: string) {
+    const idx = this.items.findIndex((i) => i.id === id)
+    if (idx === -1) return false
+    this.items.splice(idx, 1)
+    return true
+  }
+}
+`);
+  await write(`${kebab}.typedefs.ts`, `/**
+ * ${pascal} GraphQL type definitions.
+ * Pass to GraphQLAdapter's typeDefs option to register custom types.
+ */
+export const ${camel}TypeDefs = \`
+  type ${pascal} {
+    id: ID!
+    name: String!
+  }
+\`
+`);
+  return files;
+}
+__name(generateResolver, "generateResolver");
+
+// src/generators/job.ts
+import { join as join11 } from "path";
+async function generateJob(options) {
+  const { name, outDir } = options;
+  const pascal = toPascalCase(name);
+  const kebab = toKebabCase(name);
+  const camel = toCamelCase(name);
+  const queueName = options.queue ?? `${kebab}-queue`;
+  const files = [];
+  const write = /* @__PURE__ */ __name(async (relativePath, content) => {
+    const fullPath = join11(outDir, relativePath);
+    await writeFileSafe(fullPath, content);
+    files.push(fullPath);
+  }, "write");
+  await write(`${kebab}.job.ts`, `import { Inject } from '@forinda/kickjs-core'
+import { Job, Process, QUEUE_MANAGER, type QueueService } from '@forinda/kickjs-queue'
+
+/**
+ * ${pascal} Job Processor
+ *
+ * Decorators:
+ *   @Job(queueName) \u2014 marks this class as a job processor for a queue
+ *   @Process(jobName?) \u2014 marks a method as the handler for a specific job type
+ *     - Without a name: handles all jobs in the queue
+ *     - With a name: handles only jobs matching that name
+ *
+ * To add jobs to this queue from a service or controller:
+ *   @Inject(QUEUE_MANAGER) private queue: QueueService
+ *   await this.queue.add('${queueName}', '${camel}', { ... })
+ */
+@Job('${queueName}')
+export class ${pascal}Job {
+  @Process()
+  async handle(job: { name: string; data: any; id?: string }) {
+    console.log(\`Processing \${job.name} (id: \${job.id})\`, job.data)
+
+    // TODO: Implement job logic here
+    // Example:
+    // await this.emailService.send(job.data.to, job.data.subject, job.data.body)
+  }
+
+  @Process('${camel}.priority')
+  async handlePriority(job: { name: string; data: any; id?: string }) {
+    console.log(\`Priority job: \${job.name}\`, job.data)
+    // Handle high-priority variant of this job
+  }
+}
+`);
+  return files;
+}
+__name(generateJob, "generateJob");
+
 // src/commands/generate.ts
 function printGenerated(files) {
   const cwd = process.cwd();
@@ -1532,6 +1780,21 @@ function registerGenerateCommand(program) {
     });
     printGenerated(files);
   });
+  gen.command("resolver <name>").description("Generate a GraphQL @Resolver class with @Query and @Mutation methods").option("-o, --out <dir>", "Output directory", "src/resolvers").action(async (name, opts) => {
+    const files = await generateResolver({
+      name,
+      outDir: resolve2(opts.out)
+    });
+    printGenerated(files);
+  });
+  gen.command("job <name>").description("Generate a @Job queue processor with @Process handlers").option("-o, --out <dir>", "Output directory", "src/jobs").option("-q, --queue <name>", "Queue name (default: <name>-queue)").action(async (name, opts) => {
+    const files = await generateJob({
+      name,
+      outDir: resolve2(opts.out),
+      queue: opts.queue
+    });
+    printGenerated(files);
+  });
   gen.command("config").description("Generate a kick.config.ts at the project root").option("--modules-dir <dir>", "Modules directory path", "src/modules").option("--repo <type>", "Default repository type: inmemory | drizzle", "inmemory").option("-f, --force", "Overwrite existing kick.config.ts without prompting").action(async (opts) => {
     const files = await generateConfig({
       outDir: resolve2("."),
@@ -1544,6 +1807,10 @@ function registerGenerateCommand(program) {
 }
 __name(registerGenerateCommand, "registerGenerateCommand");
 
+// src/commands/run.ts
+import { cpSync, existsSync as existsSync3, mkdirSync } from "fs";
+import { resolve as resolve3, join as join13 } from "path";
+
 // src/utils/shell.ts
 import { execSync as execSync2 } from "child_process";
 function runShellCommand(command, cwd) {
@@ -1554,6 +1821,42 @@ function runShellCommand(command, cwd) {
 }
 __name(runShellCommand, "runShellCommand");
 
+// src/config.ts
+import { readFile as readFile3, access as access2 } from "fs/promises";
+import { join as join12 } from "path";
+var CONFIG_FILES = [
+  "kick.config.ts",
+  "kick.config.js",
+  "kick.config.mjs",
+  "kick.config.json"
+];
+async function loadKickConfig(cwd) {
+  for (const filename of CONFIG_FILES) {
+    const filepath = join12(cwd, filename);
+    try {
+      await access2(filepath);
+    } catch {
+      continue;
+    }
+    if (filename.endsWith(".json")) {
+      const content = await readFile3(filepath, "utf-8");
+      return JSON.parse(content);
+    }
+    try {
+      const { pathToFileURL } = await import("url");
+      const mod = await import(pathToFileURL(filepath).href);
+      return mod.default ?? mod;
+    } catch (err) {
+      if (filename.endsWith(".ts")) {
+        console.warn(`Warning: Failed to load ${filename}. TypeScript config files require a runtime loader (e.g. tsx, ts-node) or use kick.config.js/.mjs instead.`);
+      }
+      continue;
+    }
+  }
+  return null;
+}
+__name(loadKickConfig, "loadKickConfig");
+
 // src/commands/run.ts
 function registerRunCommands(program) {
   program.command("dev").description("Start development server with Vite HMR (zero-downtime reload)").option("-e, --entry <file>", "Entry file", "src/index.ts").option("-p, --port <port>", "Port number").action((opts) => {
@@ -1571,9 +1874,32 @@ function registerRunCommands(program) {
     } catch {
     }
   });
-  program.command("build").description("Build for production via Vite").action(() => {
+  program.command("build").description("Build for production via Vite").action(async () => {
     console.log("\n  Building for production...\n");
     runShellCommand("npx vite build");
+    const config = await loadKickConfig(process.cwd());
+    const copyDirs = config?.copyDirs ?? [];
+    if (copyDirs.length > 0) {
+      console.log("\n  Copying directories to dist...");
+      for (const entry of copyDirs) {
+        const src = typeof entry === "string" ? entry : entry.src;
+        const dest = typeof entry === "string" ? join13("dist", entry) : entry.dest ?? join13("dist", src);
+        const srcPath = resolve3(src);
+        const destPath = resolve3(dest);
+        if (!existsSync3(srcPath)) {
+          console.log(`    \u26A0 Skipped ${src} (not found)`);
+          continue;
+        }
+        mkdirSync(destPath, {
+          recursive: true
+        });
+        cpSync(srcPath, destPath, {
+          recursive: true
+        });
+        console.log(`    \u2713 ${src} \u2192 ${dest}`);
+      }
+    }
+    console.log("\n  Build complete.\n");
   });
   program.command("start").description("Start production server").option("-e, --entry <file>", "Entry file", "dist/index.js").option("-p, --port <port>", "Port number").action((opts) => {
     const envVars = [
@@ -1650,51 +1976,352 @@ function registerSingleCommand(program, def) {
 }
 __name(registerSingleCommand, "registerSingleCommand");
 
-// src/config.ts
-import { readFile as readFile3, access as access2 } from "fs/promises";
-import { join as join10 } from "path";
-var CONFIG_FILES = [
-  "kick.config.ts",
-  "kick.config.js",
-  "kick.config.mjs",
-  "kick.config.json"
-];
-async function loadKickConfig(cwd) {
-  for (const filename of CONFIG_FILES) {
-    const filepath = join10(cwd, filename);
-    try {
-      await access2(filepath);
-    } catch {
-      continue;
+// src/commands/inspect.ts
+var esc = /* @__PURE__ */ __name((code) => `\x1B[${code}m`, "esc");
+var reset = esc("0");
+var bold = /* @__PURE__ */ __name((s) => `${esc("1")}${s}${reset}`, "bold");
+var dim = /* @__PURE__ */ __name((s) => `${esc("2")}${s}${reset}`, "dim");
+var green = /* @__PURE__ */ __name((s) => `${esc("32")}${s}${reset}`, "green");
+var red = /* @__PURE__ */ __name((s) => `${esc("31")}${s}${reset}`, "red");
+var yellow = /* @__PURE__ */ __name((s) => `${esc("33")}${s}${reset}`, "yellow");
+var cyan = /* @__PURE__ */ __name((s) => `${esc("36")}${s}${reset}`, "cyan");
+var magenta = /* @__PURE__ */ __name((s) => `${esc("35")}${s}${reset}`, "magenta");
+var blue = /* @__PURE__ */ __name((s) => `${esc("34")}${s}${reset}`, "blue");
+var METHOD_COLORS = {
+  GET: green,
+  POST: cyan,
+  PUT: yellow,
+  PATCH: magenta,
+  DELETE: red
+};
+function colorMethod(method) {
+  const fn = METHOD_COLORS[method] ?? dim;
+  return fn(method.padEnd(7));
+}
+__name(colorMethod, "colorMethod");
+function formatUptime(seconds) {
+  const d = Math.floor(seconds / 86400);
+  const h = Math.floor(seconds % 86400 / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const s = seconds % 60;
+  const parts = [];
+  if (d) parts.push(`${d}d`);
+  if (h) parts.push(`${h}h`);
+  if (m) parts.push(`${m}m`);
+  parts.push(`${s}s`);
+  return parts.join(" ");
+}
+__name(formatUptime, "formatUptime");
+async function fetchJson(url) {
+  const res = await fetch(url, {
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
+  return res.json();
+}
+__name(fetchJson, "fetchJson");
+async function fetchEndpoint(base, path) {
+  try {
+    return await fetchJson(`${base}${path}`);
+  } catch {
+    return null;
+  }
+}
+__name(fetchEndpoint, "fetchEndpoint");
+async function fetchAll(base) {
+  const [health, metrics, routes, container, ws] = await Promise.all([
+    fetchEndpoint(base, "/health"),
+    fetchEndpoint(base, "/metrics"),
+    fetchEndpoint(base, "/routes"),
+    fetchEndpoint(base, "/container"),
+    fetchEndpoint(base, "/ws")
+  ]);
+  return {
+    health,
+    metrics,
+    routes,
+    container,
+    ws
+  };
+}
+__name(fetchAll, "fetchAll");
+function printSummary(base, data) {
+  const { health, metrics, routes, container, ws } = data;
+  const line = dim("\u2500".repeat(60));
+  console.log();
+  console.log(bold(`  KickJS Inspector`) + dim(`  \u2192  ${base}`));
+  console.log(line);
+  if (health) {
+    const statusText = health.status === "healthy" ? green("\u25CF healthy") : red("\u25CF " + health.status);
+    console.log(`  ${bold("Health:")}    ${statusText}`);
+  } else {
+    console.log(`  ${bold("Health:")}    ${red("\u25CF unreachable")}`);
+  }
+  if (metrics) {
+    const rate = ((metrics.errorRate ?? 0) * 100).toFixed(1);
+    const rateColor = metrics.errorRate > 0.1 ? red : metrics.errorRate > 0 ? yellow : green;
+    console.log(`  ${bold("Uptime:")}    ${formatUptime(metrics.uptimeSeconds)}`);
+    console.log(`  ${bold("Requests:")}  ${metrics.requests}`);
+    console.log(`  ${bold("Errors:")}    ${metrics.serverErrors} server, ${metrics.clientErrors ?? 0} client  ${dim("(")}${rateColor(rate + "%")}${dim(")")}`);
+  }
+  if (container) {
+    console.log(`  ${bold("DI:")}        ${container.count} bindings`);
+  }
+  if (ws && ws.enabled) {
+    console.log(`  ${bold("WS:")}        ${ws.connections ?? 0} connections, ${ws.namespaces ?? 0} namespaces`);
+  }
+  if (routes?.routes?.length) {
+    console.log();
+    console.log(bold("  Routes"));
+    console.log(line);
+    console.log(`  ${dim("METHOD")}  ${dim("PATH".padEnd(36))} ${dim("CONTROLLER")}`);
+    for (const r of routes.routes) {
+      const path = r.path.length > 36 ? r.path.slice(0, 33) + "..." : r.path.padEnd(36);
+      console.log(`  ${colorMethod(r.method)} ${path} ${blue(r.controller)}.${dim(r.handler)}`);
     }
-    if (filename.endsWith(".json")) {
-      const content = await readFile3(filepath, "utf-8");
-      return JSON.parse(content);
+  }
+  console.log(line);
+  console.log();
+}
+__name(printSummary, "printSummary");
+function registerInspectCommand(program) {
+  program.command("inspect [url]").description("Connect to a running KickJS app and display debug info").option("-p, --port <port>", "Override port").option("-w, --watch", "Poll every 5 seconds").option("-j, --json", "Output raw JSON").action(async (url, opts) => {
+    let base = url ?? "http://localhost:3000";
+    if (opts.port) {
+      try {
+        const parsed = new URL(base);
+        parsed.port = opts.port;
+        base = parsed.origin;
+      } catch {
+        base = `http://localhost:${opts.port}`;
+      }
     }
-    try {
-      const { pathToFileURL } = await import("url");
-      const mod = await import(pathToFileURL(filepath).href);
-      return mod.default ?? mod;
-    } catch (err) {
-      if (filename.endsWith(".ts")) {
-        console.warn(`Warning: Failed to load ${filename}. TypeScript config files require a runtime loader (e.g. tsx, ts-node) or use kick.config.js/.mjs instead.`);
+    const debugBase = `${base.replace(/\/$/, "")}/_debug`;
+    const run = /* @__PURE__ */ __name(async () => {
+      try {
+        const data = await fetchAll(debugBase);
+        if (opts.json) {
+          console.log(JSON.stringify(data, null, 2));
+        } else {
+          printSummary(base, data);
+        }
+      } catch (err) {
+        if (opts.json) {
+          console.log(JSON.stringify({
+            error: String(err)
+          }));
+        } else {
+          console.error(red(`  \u2716 Could not connect to ${base}`));
+          console.error(dim(`    ${err instanceof Error ? err.message : String(err)}`));
+        }
+        if (!opts.watch) process.exitCode = 1;
       }
-      continue;
+    }, "run");
+    if (opts.watch) {
+      const poll = /* @__PURE__ */ __name(async () => {
+        process.stdout.write("\x1B[2J\x1B[H");
+        await run();
+      }, "poll");
+      await poll();
+      setInterval(poll, 5e3);
+    } else {
+      await run();
     }
+  });
+}
+__name(registerInspectCommand, "registerInspectCommand");
+
+// src/commands/add.ts
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve4 } from "path";
+var PACKAGE_REGISTRY = {
+  // Core (already installed by kick new)
+  core: {
+    pkg: "@forinda/kickjs-core",
+    peers: [],
+    description: "DI container, decorators, reactivity"
+  },
+  http: {
+    pkg: "@forinda/kickjs-http",
+    peers: [
+      "express"
+    ],
+    description: "Express 5, routing, middleware"
+  },
+  config: {
+    pkg: "@forinda/kickjs-config",
+    peers: [],
+    description: "Zod-based env validation"
+  },
+  cli: {
+    pkg: "@forinda/kickjs-cli",
+    peers: [],
+    description: "CLI tool and code generators"
+  },
+  // API
+  swagger: {
+    pkg: "@forinda/kickjs-swagger",
+    peers: [],
+    description: "OpenAPI spec + Swagger UI + ReDoc"
+  },
+  graphql: {
+    pkg: "@forinda/kickjs-graphql",
+    peers: [
+      "graphql"
+    ],
+    description: "GraphQL resolvers + GraphiQL"
+  },
+  // Database
+  drizzle: {
+    pkg: "@forinda/kickjs-drizzle",
+    peers: [
+      "drizzle-orm"
+    ],
+    description: "Drizzle ORM adapter + query builder"
+  },
+  prisma: {
+    pkg: "@forinda/kickjs-prisma",
+    peers: [
+      "@prisma/client"
+    ],
+    description: "Prisma adapter + query builder"
+  },
+  // Real-time
+  ws: {
+    pkg: "@forinda/kickjs-ws",
+    peers: [
+      "socket.io"
+    ],
+    description: "WebSocket with @WsController decorators"
+  },
+  // Observability
+  otel: {
+    pkg: "@forinda/kickjs-otel",
+    peers: [
+      "@opentelemetry/api"
+    ],
+    description: "OpenTelemetry tracing + metrics"
+  },
+  // Queue
+  queue: {
+    pkg: "@forinda/kickjs-queue",
+    peers: [],
+    description: "Queue adapter (BullMQ/RabbitMQ/Kafka)"
+  },
+  "queue:bullmq": {
+    pkg: "@forinda/kickjs-queue",
+    peers: [
+      "bullmq",
+      "ioredis"
+    ],
+    description: "Queue with BullMQ + Redis"
+  },
+  "queue:rabbitmq": {
+    pkg: "@forinda/kickjs-queue",
+    peers: [
+      "amqplib"
+    ],
+    description: "Queue with RabbitMQ"
+  },
+  "queue:kafka": {
+    pkg: "@forinda/kickjs-queue",
+    peers: [
+      "kafkajs"
+    ],
+    description: "Queue with Kafka"
+  },
+  // Multi-tenancy
+  "multi-tenant": {
+    pkg: "@forinda/kickjs-multi-tenant",
+    peers: [],
+    description: "Tenant resolution middleware"
+  },
+  // Testing
+  testing: {
+    pkg: "@forinda/kickjs-testing",
+    peers: [],
+    description: "Test utilities and TestModule builder"
   }
-  return null;
+};
+function detectPackageManager() {
+  if (existsSync4(resolve4("pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync4(resolve4("yarn.lock"))) return "yarn";
+  return "npm";
+}
+__name(detectPackageManager, "detectPackageManager");
+function registerAddCommand(program) {
+  program.command("add [packages...]").description("Add KickJS packages with their required dependencies").option("--pm <manager>", "Package manager override").option("-D, --dev", "Install as dev dependency").option("--list", "List all available packages").action(async (packages, opts) => {
+    if (opts.list || packages.length === 0) {
+      console.log("\n  Available KickJS packages:\n");
+      const maxName = Math.max(...Object.keys(PACKAGE_REGISTRY).map((k) => k.length));
+      for (const [name, info] of Object.entries(PACKAGE_REGISTRY)) {
+        const padded = name.padEnd(maxName + 2);
+        const peers = info.peers.length ? ` (+ ${info.peers.join(", ")})` : "";
+        console.log(`    ${padded} ${info.description}${peers}`);
+      }
+      console.log("\n  Usage: kick add graphql drizzle otel");
+      console.log("         kick add queue:bullmq");
+      console.log();
+      return;
+    }
+    const pm = opts.pm ?? detectPackageManager();
+    const devFlag = opts.dev ? " -D" : "";
+    const allDeps = /* @__PURE__ */ new Set();
+    const unknown = [];
+    for (const name of packages) {
+      const entry = PACKAGE_REGISTRY[name];
+      if (!entry) {
+        unknown.push(name);
+        continue;
+      }
+      allDeps.add(entry.pkg);
+      for (const peer of entry.peers) {
+        allDeps.add(peer);
+      }
+    }
+    if (unknown.length > 0) {
+      console.log(`
+  Unknown packages: ${unknown.join(", ")}`);
+      console.log('  Run "kick add --list" to see available packages.\n');
+      if (allDeps.size === 0) return;
+    }
+    const depsArray = Array.from(allDeps);
+    const installCmd = `${pm} add${devFlag} ${depsArray.join(" ")}`;
+    console.log(`
+  Installing ${depsArray.length} package(s):`);
+    for (const dep of depsArray) {
+      console.log(`    + ${dep}`);
+    }
+    console.log();
+    try {
+      execSync3(installCmd, {
+        stdio: "inherit"
+      });
+      console.log("\n  Done!\n");
+    } catch {
+      console.log(`
+  Installation failed. Run manually:
+    ${installCmd}
+`);
+    }
+  });
 }
-__name(loadKickConfig, "loadKickConfig");
+__name(registerAddCommand, "registerAddCommand");
 
 // src/cli.ts
+var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+var pkg = JSON.parse(readFileSync2(join14(__dirname2, "..", "package.json"), "utf-8"));
 async function main() {
   const program = new Command();
-  program.name("kick").description("KickJS \u2014 A production-grade, decorator-driven Node.js framework").version("0.1.0");
+  program.name("kick").description("KickJS \u2014 A production-grade, decorator-driven Node.js framework").version(pkg.version);
   const config = await loadKickConfig(process.cwd());
   registerInitCommand(program);
   registerGenerateCommand(program);
   registerRunCommands(program);
   registerInfoCommand(program);
+  registerInspectCommand(program);
+  registerAddCommand(program);
   registerCustomCommands(program, config);
   program.showHelpAfterError();
   await program.parseAsync(process.argv);