@bhooai/nexus-cli 0.1.5 → 2.0.1

package/package.json

@@ -1,27 +1,26 @@
-{
-  "name": "@bhooai/nexus-cli",
-  "version": "0.1.5",
-  "publishConfig": {
-    "access": "public"
-  },
-  "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
-  "bin": {
-    "nexus": "./bin/nexus.js"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "test": "vitest run"
-  },
-  "dependencies": {
-    "@bhooai/nexus-cluster": "^0.1.0",
-    "@bhooai/nexus-core": "^0.1.0",
-    "@bhooai/nexus-data": "^0.1.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.5.0",
-    "typescript": "^5.6.2",
-    "vitest": "^2.1.1"
-  }
-}
+{
+    "name":  "@bhooai/nexus-cli",
+    "version":  "2.0.1",
+    "description":  "BhooAI Nexus v2 CLI — init, dev, build, test, scaffolding, plugins, queue, db.",
+    "license":  "MIT",
+    "type":  "module",
+    "main":  "./src/index.ts",
+    "bin":  {
+                "nexus":  "./bin/nexus.js"
+            },
+    "scripts":  {
+                    "typecheck":  "tsc --noEmit"
+                },
+    "dependencies":  {
+                         "@bhooai/nexus-core":  "^2.0.1",
+                         "tsx":  "^4.19.0",
+                         "zod":  "^3.23.8"
+                     },
+    "devDependencies":  {
+                            "@types/node":  "^22.5.0",
+                            "typescript":  "^5.6.2"
+                        },
+    "publishConfig":  {
+                          "access":  "public"
+                      }
+}

package/src/commands/add.ts

@@ -0,0 +1,274 @@
+/**
+ * nexus add — multi-app scaffolds (backend, frontend, route, module).
+ *
+ *   nexus add backend <name>
+ *   nexus add frontend <name> [--for <backend>]
+ *   nexus add route <name> --app <backend>
+ *   nexus add module <payments|ai|admin|uploads|graphql-subgraph>
+ */
+import { mkdir, writeFile, readFile, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { resolve, join, dirname } from 'node:path';
+import type { CommandContext } from '../dispatcher.js';
+import { slugify } from '../util.js';
+import { prompt, select, isInteractive } from '../prompts.js';
+import { ensurePort, lookupPort } from '../ports.js';
+import { BACKEND_FOLDERS } from './init.js';
+
+const BACKEND_MAIN_TEMPLATE = `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: '<%= appName %>',
+  srcRoot: HERE,
+  projectRoot: resolve(HERE, '..'),
+});
+
+await app.listen();
+console.log('[<%= appName %>] http://' + app.config.server.host + ':' + app.config.server.port);
+`;
+
+const BACKEND_ROUTE_TEMPLATE = `import { defineRoutes } from '@bhooai/nexus-core';
+
+export default defineRoutes([
+  {
+    method: 'GET',
+    path: '/',
+    handler: (ctx) => ctx.json({ ok: true, app: '<%= appName %>' }),
+  },
+]);
+`;
+
+const ROUTE_TEMPLATE = `import { defineRoutes } from '@bhooai/nexus-core';
+
+export default defineRoutes([
+  { method: 'GET',    path: '/<%= name %>',      handler: list   },
+  { method: 'POST',   path: '/<%= name %>',      handler: create },
+  { method: 'GET',    path: '/<%= name %>/:id',  handler: getOne },
+  { method: 'PATCH',  path: '/<%= name %>/:id',  handler: update },
+  { method: 'DELETE', path: '/<%= name %>/:id',  handler: remove },
+]);
+
+// Handlers -- replace with real implementations
+import type { RequestContext } from '@bhooai/nexus-core';
+
+function list(_ctx: RequestContext)     { _ctx.json([]); }
+function create(ctx: RequestContext)    { ctx.json({ created: true }, 201); }
+function getOne(ctx: RequestContext)    { ctx.json({ id: ctx.params.id }); }
+function update(ctx: RequestContext)    { ctx.json({ id: ctx.params.id, updated: true }); }
+function remove(ctx: RequestContext)    { ctx.status(204); }
+`;
+
+export async function run(ctx: CommandContext): Promise<void> {
+  const sub = ctx.args._[0];
+  if (!sub) {
+    console.error('Usage: nexus add <backend|frontend|route|module> [args]');
+    process.exitCode = 1;
+    return;
+  }
+
+  switch (sub) {
+    case 'backend':  return addBackend(ctx);
+    case 'frontend': return addFrontend(ctx);
+    case 'route':    return addRoute(ctx);
+    case 'module':   return addModule(ctx);
+    default:
+      console.error(`Unknown add subcommand: ${sub}`);
+      process.exitCode = 1;
+  }
+}
+
+async function addBackend(ctx: CommandContext): Promise<void> {
+  const name = ctx.args._[1];
+  if (!name) {
+    console.error('Usage: nexus add backend <name>');
+    process.exitCode = 1;
+    return;
+  }
+  const slug = slugify(name);
+  const appName = `backend-${slug}`;
+  const projectRoot = process.cwd();
+  const appDir = join(projectRoot, 'apps', appName);
+
+  if (existsSync(appDir)) {
+    console.error(`✗ ${appName} already exists`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const port = await ensurePort(projectRoot, appName);
+
+  // Create directory structure (shared with init.ts's BACKEND_FOLDERS constant)
+  for (const f of BACKEND_FOLDERS) {
+    await mkdir(join(appDir, f), { recursive: true });
+  }
+
+  // main.ts — pass the assigned port via env (NEXUS_PORT) so dev and prod use the same.
+  await writeFile(join(appDir, 'src', 'main.ts'),
+    BACKEND_MAIN_TEMPLATE.replace(/<%= appName %>/g, appName));
+
+  // routes/index.ts
+  await writeFile(join(appDir, 'src', 'routes', 'index.ts'),
+    BACKEND_ROUTE_TEMPLATE.replace(/<%= appName %>/g, appName));
+
+  // package.json
+  await writeFile(join(appDir, 'package.json'), JSON.stringify({
+    name: `@${slug}/${appName}`,
+    private: true,
+    version: '0.1.0',
+    type: 'module',
+    scripts: { dev: 'tsx watch src/main.ts' },
+  }, null, 2));
+
+  console.log(`✓ Created apps/${appName}`);
+  console.log(`  srcRoot: apps/${appName}/src`);
+  console.log(`  port:    ${port} (persisted in .nexus-ports.json)`);
+  console.log(`\nAdd to apps/dev list when you want \`nexus dev\` to pick it up.`);
+}
+
+async function addFrontend(ctx: CommandContext): Promise<void> {
+  const name = ctx.args._[1];
+  if (!name) {
+    console.error('Usage: nexus add frontend <name> [--for <backend>]');
+    process.exitCode = 1;
+    return;
+  }
+  const slug = slugify(name);
+  const appName = `frontend-${slug}`;
+  const projectRoot = process.cwd();
+  const appDir = join(projectRoot, 'apps', appName);
+
+  if (existsSync(appDir)) {
+    console.error(`✗ ${appName} already exists`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // Pick backend target
+  let backend = ctx.args.flags.for as string | undefined;
+  if (!backend && isInteractive()) {
+    backend = await pickBackend(projectRoot);
+  }
+  backend = backend ?? 'backend-main';
+
+  const port = await ensurePort(projectRoot, appName);
+
+  await mkdir(join(appDir, 'src'), { recursive: true });
+
+  // package.json
+  await writeFile(join(appDir, 'package.json'), JSON.stringify({
+    name: `@${slug}/${appName}`,
+    private: true,
+    version: '0.1.0',
+    type: 'module',
+    scripts: {
+      dev: `vite --port ${port}`,
+      build: 'vite build',
+    },
+  }, null, 2));
+
+  // vite.config.ts — resolve the backend's port from the registry.
+  const backendPort = (await lookupPort(projectRoot, backend)) ?? await ensurePort(projectRoot, backend);
+  await writeFile(join(appDir, 'vite.config.ts'), `import { defineConfig } from 'vite';
+
+export default defineConfig({
+  server: {
+    port: ${port},
+    proxy: {
+      '/api':     { target: 'http://localhost:${backendPort}', changeOrigin: true, rewrite: (p: string) => p.replace(/^\\/api/, '') },
+      '/uploads': { target: 'http://localhost:${backendPort}', changeOrigin: true },
+      '/ws':      { target: 'ws://localhost:${backendPort}', ws: true },
+    },
+  },
+});
+`);
+
+  // index.html + main.tsx
+  await writeFile(join(appDir, 'index.html'), `<!doctype html>
+<html lang="en">
+<head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width, initial-scale=1.0"/><title>${name}</title></head>
+<body><div id="root"></div><script type="module" src="/src/main.tsx"></script></body>
+</html>
+`);
+
+  await writeFile(join(appDir, 'src', 'main.tsx'), `import React from 'react';
+import { createRoot } from 'react-dom/client';
+
+function App() {
+  return <main style={{ fontFamily: 'system-ui', padding: '2rem' }}>
+    <h1>${name}</h1>
+    <p>Served by apps/${appName}; proxying API to ${backend}.</p>
+  </main>;
+}
+
+const el = document.getElementById('root');
+if (el) createRoot(el).render(<App />);
+`);
+
+  console.log(`✓ Created apps/${appName} (port ${port}, proxying to ${backend}:${backendPort})`);
+}
+
+async function addRoute(ctx: CommandContext): Promise<void> {
+  const name = ctx.args._[1];
+  const app = (ctx.args.flags.app as string) ?? 'backend';
+  if (!name) {
+    console.error('Usage: nexus add route <name> [--app <backend>]');
+    process.exitCode = 1;
+    return;
+  }
+  const slug = slugify(name);
+  const projectRoot = process.cwd();
+  const routeDir = join(projectRoot, 'apps', app, 'src', 'routes');
+
+  if (!existsSync(dirname(routeDir))) {
+    console.error(`✗ Backend "${app}" not found. Run \`nexus add backend ${app}\` first.`);
+    process.exitCode = 1;
+    return;
+  }
+
+  await mkdir(routeDir, { recursive: true });
+  const target = join(routeDir, `${slug}.ts`);
+  if (existsSync(target)) {
+    console.error(`✗ Route "${slug}" already exists`);
+    process.exitCode = 1;
+    return;
+  }
+
+  await writeFile(target, ROUTE_TEMPLATE.replace(/<%= name %>/g, slug));
+  console.log(`✓ Created apps/${app}/src/routes/${slug}.ts`);
+}
+
+async function addModule(ctx: CommandContext): Promise<void> {
+  const name = ctx.args._[1];
+  if (!name) {
+    console.error('Usage: nexus add module <payments|ai|admin|uploads|graphql-subgraph>');
+    process.exitCode = 1;
+    return;
+  }
+  console.log(`Module "${name}" — TBD in P6. Will scaffold a prewired set of routes/services/graphql for that feature.`);
+}
+
+async function pickBackend(projectRoot: string): Promise<string> {
+  const apps = await listBackends(projectRoot);
+  if (apps.length === 0) return 'backend';
+  if (apps.length === 1) return apps[0]!;
+  return select('Pick a backend to proxy to:', apps);
+}
+
+async function listBackends(projectRoot: string): Promise<string[]> {
+  const appsDir = join(projectRoot, 'apps');
+  if (!existsSync(appsDir)) return [];
+  const entries = await readdir(appsDir, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory() && e.name.startsWith('backend')).map((e) => e.name);
+}
+
+async function getBackendPort(_projectRoot: string, _backend: string): Promise<number> {
+  // Deprecrated — superseded by lookupPort/ensurePort.
+  return 4000;
+}
+
+export const description = 'Add backend, frontend, route, or feature module to the project';
+export const usage = 'nexus add <backend|frontend|route|module> ...';

package/src/commands/build.ts

@@ -0,0 +1,91 @@
+/**
+ * nexus build — production build for all apps or a named target.
+ *
+ * Builds backend (tsc + prune), frontend (vite build), admin (vite build),
+ * and produces a docker-ready dist/ tree at the project root.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { readdir, mkdir } from 'node:fs/promises';
+import { resolve, join } from 'node:path';
+import type { CommandContext } from '../dispatcher.js';
+
+interface BuildTarget {
+  name: string;
+  path: string;
+  buildCmd: { cmd: string; args: string[] };
+}
+
+export async function run(ctx: CommandContext): Promise<void> {
+  const target = (ctx.args.flags.target as string) ?? 'all';
+  const projectRoot = process.cwd();
+
+  const targets: BuildTarget[] = await resolveTargets(target, projectRoot);
+
+  if (targets.length === 0) {
+    console.log('No buildable targets found.');
+    return;
+  }
+
+  await mkdir(join(projectRoot, 'dist'), { recursive: true });
+
+  for (const t of targets) {
+    console.log(`\n▶ ${t.name}`);
+    const code = await runCmd(t.buildCmd.cmd, t.buildCmd.args, t.path);
+    if (code !== 0) {
+      console.error(`✗ ${t.name} build failed (${code})`);
+      process.exitCode = code ?? 1;
+      return;
+    }
+    console.log(`✓ ${t.name}`);
+  }
+
+  console.log('\nBuild complete → dist/');
+}
+
+async function resolveTargets(target: string, root: string): Promise<BuildTarget[]> {
+  const appsDir = join(root, 'apps');
+  if (!existsSync(appsDir)) return [];
+  const entries = await readdir(appsDir, { withFileTypes: true });
+
+  const all: BuildTarget[] = [];
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    const appPath = join(appsDir, e.name);
+    const pkg = join(appPath, 'package.json');
+    if (!existsSync(pkg)) continue;
+
+    // Skip ai-server (Python — no build step)
+    if (e.name === 'ai-server') continue;
+
+    // Backend (TypeScript): no build needed (tsx at runtime), but ensure tsc passes.
+    if (e.name.startsWith('backend')) {
+      all.push({
+        name: e.name,
+        path: appPath,
+        buildCmd: { cmd: 'npx', args: ['tsc', '--noEmit', '-p', '../../tsconfig.json'] },
+      });
+      continue;
+    }
+
+    // Frontend/admin: vite build
+    all.push({
+      name: e.name,
+      path: appPath,
+      buildCmd: { cmd: 'npx', args: ['vite', 'build'] },
+    });
+  }
+
+  if (target === 'all') return all;
+  return all.filter((t) => t.name === target);
+}
+
+function runCmd(cmd: string, args: string[], cwd: string): Promise<number> {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, { cwd, stdio: 'inherit', shell: true });
+    child.on('exit', (code) => resolve(code ?? 1));
+  });
+}
+
+export const description = 'Production build for all apps (or one via --target)';
+export const usage = 'nexus build [--target <app>|all]';

package/src/commands/db.ts

@@ -0,0 +1,241 @@
+/**
+ * nexus db — seed and migrate commands.
+ *
+ *   nexus db:seed [--class <name>]      — run seeder(s) from database/seeds/
+ *   nexus db:migrate [--step N]         — run pending migrations in order
+ *   nexus db:rollback [--step N]        — rollback last N migrations
+ *
+ * Discovery is by createNexusApp()'s auto-discovery — seeds must be in
+ *   apps/<backend>/src/database/seeds/*.ts     (matching *Seeder.ts pattern)
+ *   apps/<backend>/src/database/migrations/    (YYYYMMDDHHMMSS_*.ts)
+ *
+ * Migrations export an `up(db)` and optionally `down(db)` async function.
+ * A `_migrations` collection in the app DB tracks which have run.
+ */
+import { resolve, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import type { CommandContext } from '../dispatcher.js';
+import { MongoClient, type Db } from 'mongodb';
+
+interface MigrationRecord {
+  _id: string;        // filename
+  ranAt: Date;
+}
+
+interface MigrationModule {
+  up(db: Db): Promise<void>;
+  down?(db: Db): Promise<void>;
+}
+
+const SEEDS_SUBDIR = 'src/database/seeds';
+const MIGRATIONS_SUBDIR = 'src/database/migrations';
+
+// ----------------------------------------------------------------------
+// db:seed
+// ----------------------------------------------------------------------
+
+export async function runSeed(ctx: CommandContext): Promise<void> {
+  const appName = (ctx.args.flags.app as string) ?? 'backend';
+  const className = ctx.args.flags.class as string | undefined;
+  const projectRoot = process.cwd();
+  const appDir = join(projectRoot, 'apps', appName);
+  const seedsDir = join(appDir, SEEDS_SUBDIR);
+
+  if (!existsSync(seedsDir)) {
+    console.error(`✗ No seeders directory: ${seedsDir}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const files = (await readdir(seedsDir)).filter((f) => f.endsWith('Seeder.ts') || f.endsWith('Seeder.js'));
+  if (files.length === 0) {
+    console.log('(no seeders found)');
+    return;
+  }
+
+  const toRun = className ? files.filter((f) => f.replace(/\.(ts|js)$/, '') === className) : files;
+  if (toRun.length === 0) {
+    console.error(`✗ Seeder "${className}" not found`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const db = await connectDb(projectRoot);
+  if (!db) return;
+
+  try {
+    for (const file of toRun) {
+      const mod = await import(pathToFileURL(join(seedsDir, file)).href);
+      const SeederClass = (mod as any).default ?? (mod as any)[Object.keys(mod)[0]!];
+      if (typeof SeederClass !== 'function') continue;
+      const seeder = new SeederClass();
+      if (typeof seeder.run !== 'function') continue;
+      console.log(`▶ ${file}`);
+      await seeder.run(db);
+      console.log(`✓ ${file}`);
+    }
+  } finally {
+    await db.client.close();
+  }
+}
+
+// ----------------------------------------------------------------------
+// db:migrate
+// ----------------------------------------------------------------------
+
+export async function runMigrate(ctx: CommandContext): Promise<void> {
+  const appName = (ctx.args.flags.app as string) ?? 'backend';
+  const step = ctx.args.flags.step ? parseInt(String(ctx.args.flags.step), 10) : null;
+  const projectRoot = process.cwd();
+  const appDir = join(projectRoot, 'apps', appName);
+  const migrationsDir = join(appDir, MIGRATIONS_SUBDIR);
+
+  if (!existsSync(migrationsDir)) {
+    console.error(`✗ No migrations directory: ${migrationsDir}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const files = (await readdir(migrationsDir))
+    .filter((f) => /^\d{4}_\d{2}_\d{2}_\d{6}_.*\.(ts|js)$/.test(f))
+    .sort();
+  if (files.length === 0) {
+    console.log('(no migrations found)');
+    return;
+  }
+
+  const db = await connectDb(projectRoot);
+  if (!db) return;
+
+  try {
+    const applied = new Set(
+      (await db.collection<MigrationRecord>('_migrations').find({}).toArray()).map((r) => r._id),
+    );
+    const pending = files.filter((f) => !applied.has(f.replace(/\.(ts|js)$/, '')));
+    const toRun = step ? pending.slice(0, step) : pending;
+    if (toRun.length === 0) {
+      console.log('(nothing to migrate)');
+      return;
+    }
+    for (const file of toRun) {
+      const name = file.replace(/\.(ts|js)$/, '');
+      const mod = (await import(pathToFileURL(join(migrationsDir, file)).href)) as MigrationModule;
+      if (typeof mod.up !== 'function') {
+        console.warn(`! ${file} has no up() — skipped`);
+        continue;
+      }
+      console.log(`▶ ${name}`);
+      await mod.up(db);
+      await db.collection<MigrationRecord>('_migrations').updateOne(
+        { _id: name },
+        { $set: { _id: name, ranAt: new Date() } },
+        { upsert: true },
+      );
+      console.log(`✓ ${name}`);
+    }
+  } finally {
+    await db.client.close();
+  }
+}
+
+// ----------------------------------------------------------------------
+// db:rollback
+// ----------------------------------------------------------------------
+
+export async function runRollback(ctx: CommandContext): Promise<void> {
+  const appName = (ctx.args.flags.app as string) ?? 'backend';
+  const step = ctx.args.flags.step ? parseInt(String(ctx.args.flags.step), 10) : 1;
+  const projectRoot = process.cwd();
+  const appDir = join(projectRoot, 'apps', appName);
+  const migrationsDir = join(appDir, MIGRATIONS_SUBDIR);
+
+  if (!existsSync(migrationsDir)) {
+    console.error(`✗ No migrations directory: ${migrationsDir}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const db = await connectDb(projectRoot);
+  if (!db) return;
+
+  try {
+    const applied = await db
+      .collection<MigrationRecord>('_migrations')
+      .find({})
+      .sort({ ranAt: -1 })
+      .limit(step)
+      .toArray();
+    if (applied.length === 0) {
+      console.log('(nothing to rollback)');
+      return;
+    }
+    for (const rec of applied.reverse()) {
+      const file = `${rec._id}.ts`;
+      const fileJs = `${rec._id}.js`;
+      const target = existsSync(join(migrationsDir, file))
+        ? join(migrationsDir, file)
+        : existsSync(join(migrationsDir, fileJs))
+          ? join(migrationsDir, fileJs)
+          : null;
+      if (!target) {
+        console.warn(`! Migration file missing for ${rec._id} — removing record only`);
+        await db.collection<MigrationRecord>('_migrations').deleteOne({ _id: rec._id });
+        continue;
+      }
+      const mod = (await import(pathToFileURL(target).href)) as MigrationModule;
+      if (typeof mod.down !== 'function') {
+        console.warn(`! ${rec._id} has no down() — skipped`);
+        continue;
+      }
+      console.log(`▼ ${rec._id}`);
+      await mod.down(db);
+      await db.collection<MigrationRecord>('_migrations').deleteOne({ _id: rec._id });
+      console.log(`✓ ${rec._id}`);
+    }
+  } finally {
+    await db.client.close();
+  }
+}
+
+// ----------------------------------------------------------------------
+// Shared
+// ----------------------------------------------------------------------
+
+async function connectDb(projectRoot: string): Promise<Db | null> {
+  const uri = await readMongoUri(projectRoot);
+  if (!uri) {
+    console.error('✗ Cannot determine MongoDB URI (set NEXUS_DB_URI or in nexus.config.ts)');
+    process.exitCode = 1;
+    return null;
+  }
+  const client = new MongoClient(uri);
+  await client.connect();
+  return client.db();
+}
+
+async function readMongoUri(projectRoot: string): Promise<string | null> {
+  // env var first
+  if (process.env.NEXUS_DB_URI) return process.env.NEXUS_DB_URI;
+  // .env
+  const envPath = resolve(projectRoot, '.env');
+  if (existsSync(envPath)) {
+    const raw = await readFile(envPath, 'utf-8');
+    for (const line of raw.split('\n')) {
+      const m = line.match(/^\s*NEXUS_DB_URI\s*=\s*(.+?)\s*$/);
+      if (m) return m[1]!;
+    }
+  }
+  // nexus.config.ts — last resort, parse
+  const cfgPath = resolve(projectRoot, 'nexus.config.ts');
+  if (existsSync(cfgPath)) {
+    const raw = await readFile(cfgPath, 'utf-8');
+    const m = raw.match(/uri\s*:\s*['"]([^'"]+)['"]/);
+    if (m) return m[1]!;
+  }
+  return null;
+}
+
+export const description = 'Run database seeds, migrations, or rollbacks';
+export const usage = 'nexus db:<seed|migrate|rollback> [--app <backend>] [--class <name>] [--step N]';