@bhooai/nexus-cli 0.1.4 → 2.0.0

package/src/prompts.ts

@@ -0,0 +1,68 @@
+/**
+ * Minimal wizard prompts for the CLI. Uses node:readline/promises so deps
+ * stay tiny. Provides prompt + select with arrow-key navigation.
+ */
+import { createInterface, type Interface } from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+
+let rl: Interface | null = null;
+
+function getRl(): Interface {
+  if (!rl) rl = createInterface({ input, output });
+  return rl;
+}
+
+export function closePrompts(): void {
+  if (rl) {
+    rl.close();
+    rl = null;
+  }
+}
+
+export function isInteractive(): boolean {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+/** Free-form prompt. */
+export async function prompt(question: string, defaultValue?: string): Promise<string> {
+  const r = getRl();
+  const suffix = defaultValue ? ` (${defaultValue})` : '';
+  const answer = await r.question(`${question}${suffix}: `);
+  return answer.trim() || defaultValue || '';
+}
+
+/** Yes/No confirm. */
+export async function confirm(question: string, defaultValue: boolean = false): Promise<boolean> {
+  const hint = defaultValue ? 'Y/n' : 'y/N';
+  const answer = await prompt(`${question} [${hint}]`);
+  if (!answer) return defaultValue;
+  return /^y(es)?$/i.test(answer);
+}
+
+/** Single-select from a list. */
+export async function select<T extends string>(question: string, choices: readonly T[]): Promise<T> {
+  console.log(question);
+  choices.forEach((c, i) => console.log(`  ${i + 1}) ${c}`));
+  const answer = await prompt(`Choice [1-${choices.length}]`, '1');
+  const idx = parseInt(answer, 10) - 1;
+  if (idx < 0 || idx >= choices.length) return choices[0]!;
+  return choices[idx]!;
+}
+
+/** Multi-select (comma-separated). */
+export async function multiSelect<T extends string>(question: string, choices: readonly T[]): Promise<T[]> {
+  console.log(question);
+  choices.forEach((c, i) => console.log(`  ${i + 1}) ${c}`));
+  const answer = await prompt(`Choices [comma-separated], empty=none`, '');
+  if (!answer.trim()) return [];
+  return answer
+    .split(',')
+    .map((s) => parseInt(s.trim(), 10) - 1)
+    .filter((i) => i >= 0 && i < choices.length)
+    .map((i) => choices[i]!);
+}
+
+/** Hidden-input prompt (for secrets). Note: readline/promises doesn't mask input — caller beware. */
+export async function promptHidden(question: string): Promise<string> {
+  return prompt(question);
+}

package/src/templating/render.ts

@@ -0,0 +1,109 @@
+/**
+ * EJS-style template renderer. Supports `<%= expr %>` and `<%- expr %>` (unescaped),
+ * plus `<% if (...) { %>...<% } %>` control flow via Function constructor.
+ *
+ * Deliberately tiny — no external deps. Templates live in
+ * packages/nexus-cli/templates/ and use the `data` object passed in.
+ */
+
+export type TemplateVars = Record<string, unknown>;
+
+const CACHE = new Map<string, (vars: TemplateVars) => string>();
+
+/** Render a template string with vars. */
+export function renderString(template: string, vars: TemplateVars): string {
+  const fn = compile(template);
+  return fn(vars);
+}
+
+/** Pre-compile a template string into a render function. */
+export function compile(template: string): (vars: TemplateVars) => string {
+  const cached = CACHE.get(template);
+  if (cached) return cached;
+
+  // Build a function body that pieces together plain text + expressions.
+  // Escape backslashes + backticks in literal text segments, then emit as
+  // template literal parts. Expressions are pushed into an output array.
+  const body: string[] = ['const __out=[];'];
+  body.push('with(__data){'); // expose vars as bare identifiers
+
+  let i = 0;
+  let buf = '';
+  const flushLiteral = () => {
+    if (buf) {
+      body.push(`__out.push(${JSON.stringify(buf)});`);
+      buf = '';
+    }
+  };
+
+  while (i < template.length) {
+    const start = template.indexOf('<%', i);
+    if (start === -1) {
+      buf += template.slice(i);
+      break;
+    }
+    buf += template.slice(i, start);
+
+    const end = template.indexOf('%>', start);
+    if (end === -1) {
+      buf += template.slice(start);
+      break;
+    }
+
+    const tag = template.slice(start, end + 2);
+    const inner = tag.slice(2, -2);
+    flushLiteral();
+
+    if (inner.startsWith('=')) {
+      // Escaped interpolation
+      const expr = inner.slice(1).trim();
+      body.push(`__out.push(__esc(String(${expr})));`);
+    } else if (inner.startsWith('-')) {
+      // Raw interpolation
+      const expr = inner.slice(1).trim();
+      body.push(`__out.push(String(${expr}));`);
+    } else if (inner.startsWith('#')) {
+      // Comment — drop
+    } else {
+      // Control flow
+      body.push(inner);
+    }
+
+    i = end + 2;
+  }
+  flushLiteral();
+  body.push('}');
+  body.push('return __out.join("");');
+
+  const src = body.join('\n');
+  const fn = new Function('__data', '__esc', src) as (vars: TemplateVars, esc: (s: string) => string) => string;
+  const wrapped = (vars: TemplateVars) => fn(vars, escapeHtml);
+  CACHE.set(template, wrapped);
+  return wrapped;
+}
+
+function escapeHtml(s: string): string {
+  return s
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+/** Render a file (assumed UTF-8). */
+export async function renderFile(path: string, vars: TemplateVars): Promise<string> {
+  const { readFile } = await import('node:fs/promises');
+  const raw = await readFile(path, 'utf-8');
+  return renderString(raw, vars);
+}
+
+/** Whether a filename looks like a template (render) vs verbatim copy. */
+export function isTemplateName(name: string): boolean {
+  return name.endsWith('.ejs') || name.endsWith('.tmpl') || name.endsWith('.hbs');
+}
+
+/** Strip template suffix: foo.ejs → foo. */
+export function stripTemplateSuffix(name: string): string {
+  return name.replace(/\.(ejs|tmpl|hbs)$/, '');
+}

package/src/util.ts

@@ -1,132 +1,94 @@
-import { createConnection } from 'node:net';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
+/**
+ * CLI utilities — argument parsing, port probing, path helpers.
+ */
+import { createServer } from 'node:net';
 import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { resolve } from 'node:path';
 
-const execFileAsync = promisify(execFile);
+export interface ParsedArgs {
+  _: string[];
+  flags: Record<string, string | boolean>;
+}
 
-export interface CheckResult {
-  name: string;
-  ok: boolean;
-  detail: string;
+/** Parse argv like `--foo bar`, `--foo=bar`, `--flag` → { _: [...rest], flags: {...} }. */
+export function parseArgs(argv: string[]): ParsedArgs {
+  const _: string[] = [];
+  const flags: Record<string, string | boolean> = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!;
+    if (a.startsWith('--')) {
+      const eq = a.indexOf('=');
+      if (eq === -1) {
+        const key = a.slice(2);
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith('-')) {
+          flags[key] = next;
+          i++;
+        } else {
+          flags[key] = true;
+        }
+      } else {
+        flags[a.slice(2, eq)] = a.slice(eq + 1);
+      }
+    } else if (a.startsWith('-') && a.length > 1) {
+      // short flags: -abc → { a: true, b: true, c: true }
+      for (const ch of a.slice(1)) flags[ch] = true;
+    } else {
+      _.push(a);
+    }
+  }
+  return { _, flags };
 }
 
-/** Try a TCP connect to host:port within a timeout. */
-export function tcpReachable(host: string, port: number, timeoutMs = 1500): Promise<boolean> {
-  return new Promise((resolve) => {
-    const socket = createConnection({ host, port }, () => {
-      socket.destroy();
-      resolve(true);
-    });
-    socket.setTimeout(timeoutMs);
-    socket.on('error', () => resolve(false));
-    socket.on('timeout', () => {
-      socket.destroy();
-      resolve(false);
-    });
+/** Test whether a port is free. */
+export async function isPortFree(port: number, host: string = '127.0.0.1'): Promise<boolean> {
+  return new Promise((resolveFree) => {
+    const srv = createServer();
+    srv.once('error', () => resolveFree(false));
+    srv.once('listening', () => srv.close(() => resolveFree(true)));
+    srv.listen(port, host);
   });
 }
 
-/** True if nothing is listening on `port` (quick TCP connect check). */
-export async function isPortFree(host: string, port: number, timeoutMs = 700): Promise<boolean> {
-  return !(await tcpReachable(host === '0.0.0.0' ? '127.0.0.1' : host, port, timeoutMs));
+/** Find a free port by scanning from `start`. */
+export async function nextFreePort(start: number, host: string = '127.0.0.1'): Promise<number> {
+  let p = start;
+  while (!(await isPortFree(p, host))) {
+    p++;
+    if (p > 65535) throw new Error('No free port found');
+  }
+  return p;
 }
 
-/** Parse host/port from common connection-string formats. */
-export function parseHostPort(url: string, defaultPort: number): { host: string; port: number } {
-  try {
-    const u = new URL(url);
-    return { host: u.hostname || 'localhost', port: u.port ? Number(u.port) : defaultPort };
-  } catch {
-    return { host: 'localhost', port: defaultPort };
-  }
+/** Resolve a path that may be relative to cwd. */
+export function resolvePath(p: string): string {
+  return resolve(process.cwd(), p);
 }
 
-export async function versionOf(cmd: string, args: string[] = ['--version']): Promise<string> {
+/** Check directory existence. */
+export function dirExists(p: string): boolean {
   try {
-    // Windows: runtimes like `npm` are .cmd shims requiring a shell. Passing the
-    // full command line (no separate args array) avoids Node's DEP0190 warning.
-    const win = process.platform === 'win32';
-    const { stdout } = win
-      ? await execFileAsync(
-          [cmd, ...args].map((t) => (/\s/.test(t) ? `"${t}"` : t)).join(' '),
-          [],
-          { shell: true },
-        )
-      : await execFileAsync(cmd, args, {});
-    return stdout.trim();
+    return existsSync(p);
   } catch {
-    return '';
+    return false;
   }
 }
 
-/** A prerequisite check (runtime or service). */
-export interface Prereq extends CheckResult {
-  /** Critical = the wizard should refuse to proceed. Warnings ask to continue. */
-  critical?: boolean;
-}
-
-/**
- * Detect installed runtimes: node, npm, python, git. Returns a list of checks
- * suitable for printing. node/npm/python are critical; git is a warning.
- * Shared by `nexus doctor` and `nexus init` step 1.
- */
-export async function scanRuntimes(): Promise<Prereq[]> {
-  const out: Prereq[] = [];
-  out.push({ name: 'node', ok: !!process.versions.node, detail: `v${process.versions.node}`, critical: true });
-  const npmVer = await versionOf(process.platform === 'win32' ? 'npm' : 'npm');
-  out.push({ name: 'npm', ok: !!npmVer, detail: npmVer ? `v${npmVer}` : 'not found', critical: true });
-  const pyVer = await versionOf(process.platform === 'win32' ? 'python' : 'python3');
-  out.push({ name: 'python', ok: !!pyVer, detail: pyVer || 'not found (ai-server disabled)', critical: true });
-  const gitVer = await versionOf('git', ['--version']);
-  out.push({ name: 'git', ok: !!gitVer, detail: gitVer ? gitVer.replace(/^git version /, 'v') : 'not found' });
-  return out;
-}
-
-/** Lightweight config shape used by `scanServices` (avoids importing nexus-core here). */
-export interface ServiceConfig {
-  db: { uri: string };
-  redis: { url: string };
-  ai: { serverUrl: string };
-  server: { host: string; port: number };
-  frontend: { port: number };
-  admin: { port: number };
+/** Slugify a project name (lowercase, no spaces). */
+export function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
 }
 
-/**
- * Probe Mongo, Redis, and the AI server (TCP reachability) plus check that the
- * backend/frontend/admin ports are free. Returns a list of checks.
- * Shared by `nexus doctor` and `nexus init` step 1 / step 18 (verify).
- */
-export async function scanServices(cfg: ServiceConfig): Promise<Prereq[]> {
-  const out: Prereq[] = [];
-  const db = parseHostPort(cfg.db.uri, 27017);
-  const dbOk = await tcpReachable(db.host, db.port);
-  out.push({ name: 'mongodb', ok: dbOk, detail: `${db.host}:${db.port} ${dbOk ? 'reachable' : 'unreachable'}` });
-
-  const redis = parseHostPort(cfg.redis.url, 6379);
-  const redisOk = await tcpReachable(redis.host, redis.port);
-  out.push({ name: 'redis', ok: redisOk, detail: `${redis.host}:${redis.port} ${redisOk ? 'reachable' : 'unreachable'}` });
-
-  const ai = parseHostPort(cfg.ai.serverUrl, 8000);
-  const aiOk = await tcpReachable(ai.host, ai.port);
-  out.push({ name: 'ai server', ok: aiOk, detail: `${ai.host}:${ai.port} ${aiOk ? 'reachable' : 'unreachable'}` });
-
-  const backendFree = await isPortFree(cfg.server.host, cfg.server.port, 500);
-  out.push({ name: 'backend port', ok: backendFree, detail: `:${cfg.server.port} ${backendFree ? 'free' : 'IN USE'}` });
-
-  const frontendFree = await isPortFree('127.0.0.1', cfg.frontend.port, 500);
-  out.push({ name: 'frontend port', ok: frontendFree, detail: `:${cfg.frontend.port} ${frontendFree ? 'free' : 'in use'}` });
-
-  const adminFree = await isPortFree('127.0.0.1', cfg.admin.port, 500);
-  out.push({ name: 'admin port', ok: adminFree, detail: `:${cfg.admin.port} ${adminFree ? 'free' : 'in use'}` });
-
-  return out;
+/** Generate a random base64url secret. */
+export function randomSecret(bytes: number = 32): string {
+  const buf = new Uint8Array(bytes);
+  if (typeof globalThis.crypto !== 'undefined' && globalThis.crypto.getRandomValues) {
+    globalThis.crypto.getRandomValues(buf);
+  } else {
+    for (let i = 0; i < bytes; i++) buf[i] = Math.floor(Math.random() * 256);
+  }
+  return Buffer.from(buf).toString('base64url');
 }
-
-/** Returns true if `path` exists and its directory looks like a nexus project root. */
-export function looksLikeProject(root: string): boolean {
-  return existsSync(join(root, 'package.json')) &&
-    ['ts', 'js', 'mjs', 'cjs'].some((ext) => existsSync(join(root, `nexus.config.${ext}`)));
-}

package/templates/base/Dockerfile.ejs

@@ -0,0 +1,68 @@
+# Multi-stage Docker build for <%= name %>.
+# Targets: backend-<name>, frontend-<name>, admin, ai-server.
+# Build:        docker compose build
+# Run:          docker compose up
+# Scale:        docker compose up --scale backend-main=3
+
+# ---------------------------------------------------------------------------
+# Backend base — Node runtime + workspace deps installed.
+# ---------------------------------------------------------------------------
+FROM node:22-alpine AS backend-base
+WORKDIR /app
+RUN corepack enable
+COPY package.json package-lock.json* ./
+COPY apps/backend/package.json apps/backend/package.json
+RUN npm install --omit=dev --workspace=apps/backend --include-workspace-root=false
+COPY apps/backend apps/backend
+COPY tsconfig.json ./
+
+EXPOSE <%= backendPort %>
+ENV NODE_ENV=production
+CMD ["npx", "tsx", "apps/backend/src/main.ts"]
+
+# ---------------------------------------------------------------------------
+# Frontend — React/Vite → static assets served by nginx
+# ---------------------------------------------------------------------------
+FROM node:22-alpine AS frontend-build
+WORKDIR /app
+RUN corepack enable
+COPY package.json package-lock.json* ./
+COPY apps/frontend apps/frontend
+RUN npm install --workspace=apps/frontend --include-workspace-root=false
+WORKDIR /app/apps/frontend
+RUN npx vite build
+
+FROM nginx:1.27-alpine AS frontend
+COPY --from=frontend-build /app/apps/frontend/dist /usr/share/nginx/html
+COPY apps/frontend/nginx.conf /etc/nginx/conf.d/default.conf
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]
+
+# ---------------------------------------------------------------------------
+# Admin SPA — same as frontend but separate stage for independent deploys
+# ---------------------------------------------------------------------------
+FROM node:22-alpine AS admin-build
+WORKDIR /app
+RUN corepack enable
+COPY package.json package-lock.json* ./
+COPY apps/admin apps/admin
+RUN npm install --workspace=apps/admin --include-workspace-root=false
+WORKDIR /app/apps/admin
+RUN npx vite build
+
+FROM nginx:1.27-alpine AS admin
+COPY --from=admin-build /app/apps/admin/dist /usr/share/nginx/html
+COPY apps/admin/nginx.conf /etc/nginx/conf.d/default.conf
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]
+
+# ---------------------------------------------------------------------------
+# AI server — Python FastAPI
+# ---------------------------------------------------------------------------
+FROM python:3.13-slim AS ai-server
+WORKDIR /app
+COPY apps/ai-server/requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+COPY apps/ai-server ./
+EXPOSE <%= aiPort %>
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "<%= aiPort %>"]

package/templates/base/README.md.ejs

@@ -0,0 +1,62 @@
+# <%= name %>
+
+Built with [BhooAI Nexus](https://github.com/bhooai/nexus).
+
+## Quick start
+
+```bash
+npm install
+npm run dev
+```
+
+Default services:
+
+- Backend API   → http://localhost:<%= backendPort %>
+- Frontend      → http://localhost:<%= frontendPort %>
+- Admin panel   → http://localhost:<%= adminPort %>
+- AI server     → http://localhost:<%= aiPort %>
+
+## Project layout
+
+```
+apps/
+  backend/    # Node.js backend — auto-discovers routes/, graphql/, ws/, mail/, errors/, …
+    src/
+      routes/          # HTTP endpoints
+      graphql/         # *.graph.ts (federation)
+      ws/              # *.room.ts (WebSocket rooms)
+      mail/            # templates/ + mailables/
+      errors/          # pages/ + Handler.ts
+      models/ services/ repositories/ controllers/ middleware/ validators/
+      jobs/ listeners/ events/ policies/ resources/ requests/
+      helpers/ config/ database/ providers/ plugins/ types/ constants/
+    storage/
+      uploads/  private/  temp/  cache/  logs/
+  frontend/   # React + Vite
+  admin/      # Admin console (wraps @bhooai/nexus-admin)
+  ai-server/  # Python FastAPI (optional AI features)
+```
+
+## Common commands
+
+```bash
+npm run dev            # start all services
+npm run build          # production build
+npm run test           # run tests
+npm run doctor         # environment check
+npm run down           # enable maintenance mode
+npm run up             # disable maintenance mode
+```
+
+Generate code:
+
+```bash
+nexus make:route users
+nexus make:model Post
+nexus make:job SendWelcomeEmail
+nexus make:mail PasswordReset
+```
+
+## Configuration
+
+Edit `nexus.config.ts`. Secrets go in `.env`. See [PLAN.md](../../../PLAN.md) for the architecture.

package/templates/base/apps/admin/index.html.ejs

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8"/>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+  <title><%= name %> — Admin</title>
+</head>
+<body>
+  <div id="root"></div>
+  <script type="module" src="/src/main.tsx"></script>
+</body>
+</html>

package/templates/base/apps/admin/nginx.conf.ejs

@@ -0,0 +1,16 @@
+server {
+  listen 80;
+  server_name _;
+  root /usr/share/nginx/html;
+  index index.html;
+
+  location / {
+    try_files $uri $uri/ /index.html;
+  }
+  location /admin/ {
+    proxy_pass http://backend:<%= backendPort %>/admin/;
+    proxy_http_version 1.1;
+    proxy_set_header Host $host;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+  }
+}

package/templates/base/apps/admin/package.json.ejs

@@ -0,0 +1,15 @@
+{
+  "name": "@<%= nameSlug %>/admin",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite --port <%= adminPort %>",
+    "build": "vite build"
+  },
+  "dependencies": {
+    "@bhooai/nexus-admin": "^2.0.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  }
+}

package/templates/base/apps/admin/src/main.tsx.ejs

@@ -0,0 +1,7 @@
+import '@bhooai/nexus-admin/style.css';
+import NexusAdmin from '@bhooai/nexus-admin';
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+
+const el = document.getElementById('root');
+if (el) createRoot(el).render(<NexusAdmin />);

package/templates/base/apps/admin/vite.config.ts.ejs

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  server: {
+    port: <%= adminPort %>,
+    proxy: {
+      '/admin': {
+        target: 'http://localhost:<%= backendPort %>',
+        changeOrigin: true,
+      },
+      '/api': {
+        target: 'http://localhost:<%= backendPort %>',
+        changeOrigin: true,
+        rewrite: (p: string) => p.replace(/^\/api/, ''),
+      },
+      '/health': {
+        target: 'http://localhost:<%= backendPort %>',
+        changeOrigin: true,
+      },
+    },
+  },
+});

package/templates/base/apps/ai-server/main.py.ejs

@@ -0,0 +1,30 @@
+"""AI server (FastAPI) — provides /health and OpenAI-compatible /v1/chat/completions stub.
+
+Extend with real provider integrations (Ollama, OpenAI, Anthropic, etc.).
+"""
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+app = FastAPI(title="<%= name %> AI server")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/health")
+async def health():
+    return {"ok": True, "service": "ai", "app": "<%= nameSlug %>"}
+
+
+@app.get("/v1/models")
+async def models():
+    return {"data": [{"id": "default", "object": "model"}]}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=<%= aiPort %>)

package/templates/base/apps/ai-server/requirements.txt

@@ -0,0 +1,4 @@
+fastapi>=0.115
+uvicorn[standard]>=0.30
+httpx>=0.27
+pydantic>=2.0

package/templates/base/apps/backend/src/main.ts

@@ -0,0 +1,14 @@
+import { createNexusApp } from '@bhooai/nexus-core';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+
+const app = await createNexusApp({
+  name: 'backend',
+  srcRoot: HERE,                     // apps/backend/src
+  projectRoot: resolve(HERE, '..', '..', '..'), // workspace root
+});
+
+await app.listen();
+console.log(`[backend] http://${app.config.server.host}:${app.config.server.port}`);

package/templates/base/apps/backend/src/routes/index.ts.ejs

@@ -0,0 +1,11 @@
+import { defineRoutes } from '@bhooai/nexus-core';
+
+export default defineRoutes([
+  {
+    method: 'GET',
+    path: '/',
+    handler: (ctx) => {
+      ctx.json({ ok: true, name: '<%= nameSlug %>', docs: 'https://github.com/bhooai/nexus' });
+    },
+  },
+]);