@bhooai/nexus-cli 2.0.3 → 2.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bhooai/nexus-cli",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "BhooAI Nexus v2 CLI — init, dev, build, test, scaffolding, plugins, queue, db.",
   "license": "MIT",
   "type": "module",

package/src/commands/add.ts

@@ -178,7 +178,7 @@ export default defineConfig({
   server: {
     port: ${port},
     proxy: {
-      '/api':     { target: 'http://localhost:${backendPort}', changeOrigin: true, rewrite: (p: string) => p.replace(/^\\/api/, '') },
+      '/api':     { target: 'http://localhost:${backendPort}', changeOrigin: true },
       '/uploads': { target: 'http://localhost:${backendPort}', changeOrigin: true },
       '/ws':      { target: 'ws://localhost:${backendPort}', ws: true },
     },

package/src/commands/dev.ts

@@ -29,7 +29,7 @@ export async function run(ctx: CommandContext): Promise<void> {
     return;
   }
 
-  const manager = new ServiceManager(specs);
+  const manager = new ServiceManager(specs, projectRoot);
 
   if (isTty && !noPanel) {
     // Full-screen Nexus Console.
@@ -91,13 +91,13 @@ async function discoverServices(projectRoot: string, only: string[] | null): Pro
     if (!existsSync(join(appsDir, f, 'package.json'))) continue;
     const port = await ensurePort(projectRoot, f);
     if (only && !only.includes(f)) continue;
-    specs.push({ name: f, cmd: 'npx', args: ['vite', '--port', String(port), '--strictPort'], cwd: join(appsDir, f), port });
+    specs.push({ name: f, cmd: 'npx', args: ['vite', '--port', String(port), '--strictPort'], cwd: join(appsDir, f), port, portArgIndex: 2 });
   }
   for (const a of admins) {
     if (!existsSync(join(appsDir, a, 'package.json'))) continue;
     const port = await ensurePort(projectRoot, a);
     if (only && !only.includes(a)) continue;
-    specs.push({ name: a, cmd: 'npx', args: ['vite', '--port', String(port), '--strictPort'], cwd: join(appsDir, a), port });
+    specs.push({ name: a, cmd: 'npx', args: ['vite', '--port', String(port), '--strictPort'], cwd: join(appsDir, a), port, portArgIndex: 2 });
   }
   for (const ai of aiServers) {
     if (!existsSync(join(appsDir, ai, 'main.py'))) continue;

package/src/commands/init.ts

@@ -1,26 +1,29 @@
 /**
- * nexus init — scaffold a new Nexus project.
+ * nexus init — scaffold a new Nexus project via the guided wizard.
  *
- * Modes:
- *   nexus init my-app                    — quick, no prompts, sensible defaults
- *   nexus init --interactive my-app      — full wizard with example picker
- *   nexus init my-app --example chat     — quick + named example
+ *   nexus init              open the full-screen setup wizard
+ *   nexus init my-app       open the wizard with the name pre-filled
+ *
+ * Always interactive (the wizard). Requires a TTY; in a non-interactive
+ * context it prints a message and exits non-zero. `--no-install` skips the
+ * dependency install, `--force` overwrites an existing target directory.
  */
-import { mkdir, writeFile, cp, readFile, readdir } from 'node:fs/promises';
+import { mkdir, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { spawn } from 'node:child_process';
-import { join, resolve, dirname, basename } from 'node:path';
+import { join, resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import type { CommandContext } from '../dispatcher.js';
-import { prompt, confirm, select, isInteractive } from '../prompts.js';
-import { randomSecret, slugify } from '../util.js';
-import { ensurePort } from '../ports.js';
-import { renderString, isTemplateName, stripTemplateSuffix } from '../templating/render.js';
+import { confirm } from '../prompts.js';
+import { randomSecret } from '../util.js';
+import { writeRegistry, type PortRegistry } from '../ports.js';
+import { renderTemplateTree } from '../templating/tree.js';
+import { runWizard } from '../wizard.js';
+import { getFeature, installFeature } from '../features.js';
+import { isTty } from '../tui.js';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const TEMPLATES_DIR = resolve(HERE, '..', '..', 'templates');
-// Examples ship as @bhooai/nexus-examples workspace package.
-const EXAMPLES_DIR = resolve(HERE, '..', '..', '..', 'nexus-examples', 'examples');
 
 interface InitVars {
   name: string;
@@ -38,75 +41,47 @@ interface InitVars {
 
 export async function run(ctx: CommandContext): Promise<void> {
   const args = ctx.args;
-  const targetDirArg = args._[0] ?? '.';
-  const interactive = !!args.flags.interactive;
-  let example = (args.flags.example as string) ?? 'empty';
-  let name = (args.flags.name as string) ?? '';
-
-  // Resolve target directory
-  const targetDir = resolve(process.cwd(), targetDirArg);
-  if (!name) {
-    name = targetDirArg === '.' ? basename(process.cwd()) : basename(targetDir);
-  }
-  name = slugify(name);
-  if (!name) {
-    console.error('Project name cannot be empty after slugification.');
+  const prefillName = (args._[0] as string) ?? '';
+
+  // `nexus init` is always the guided wizard — it needs a terminal.
+  if (!isTty()) {
+    console.error('nexus init needs an interactive terminal for the guided wizard.');
+    console.error('Run it from a terminal, or use `nexus` to open the welcome screen.');
     process.exitCode = 1;
     return;
   }
 
-  // Interactive mode: ask for everything
-  let mongoUri = (args.flags['mongo-uri'] as string) ?? `mongodb://localhost:27017/${name}`;
-  let redisUrl = (args.flags['redis-url'] as string) ?? 'redis://localhost:6379';
-  let aiProviders: string[] = [];
-  let useVenv = true;
-
-  if (interactive && isInteractive()) {
-    console.log(`\nCreating Nexus project: ${name}\n`);
-
-    // Example picker
-    const examples = await listExamples();
-    example = await select('Start with:', ['empty', ...examples] as const) as string;
-
-    mongoUri = await prompt('MongoDB URI', mongoUri);
-    redisUrl = await prompt('Redis URL', redisUrl);
-
-    const providerNames = await prompt(
-      'AI providers (comma-separated, empty for none) — e.g. ollama,openai',
-      '',
-    );
-    aiProviders = providerNames
-      .split(',')
-      .map((s) => s.trim())
-      .filter(Boolean);
-
-    useVenv = await confirm('Create Python virtualenv for AI server?', true);
+  console.log('Launching Nexus project setup…');
+  const result = await runWizard(prefillName);
+  if (!result) {
+    console.log('Setup cancelled.');
+    return;
   }
 
-  // Allocate ports via registry (writes .nexus-ports.json)
-  // We allocate AFTER targetDir is created (see below), so use a temp registry for now.
-  // Simpler: pre-pick ports via nextFreePort, then commit them once the dir exists.
-  const backendPort  = 4000;
-  const frontendPort = 3000;
-  const adminPort    = 3300;
-  const aiPort       = 8000;
+  const name = result.nameSlug;
+  const targetDir = resolve(process.cwd(), name);
+
+  const includeAdmin = result.includeAdmin;
+  const includeFrontend = result.features.includes('frontend');
+  const includeAi = result.features.includes('ai-server');
+  const backendFeatureIds = result.features.filter((id) => !!getFeature(id)?.templateDir);
 
   const vars: InitVars = {
     name,
     nameSlug: name,
     jwtSecret: randomSecret(32),
-    mongoUri,
-    redisUrl,
-    example,
-    backendPort,
-    frontendPort,
-    adminPort,
-    aiPort,
-    aiProviders,
+    mongoUri: result.mongoUri,
+    redisUrl: result.redisUrl,
+    example: result.example,
+    backendPort: result.ports.backend,
+    frontendPort: result.ports.frontend,
+    adminPort: result.ports.admin,
+    aiPort: result.ports.ai,
+    aiProviders: result.aiProviders,
   };
 
-  if (existsSync(targetDir) && targetDirArg !== '.' && !args.flags.force) {
-    const ok = isInteractive() ? await confirm(`Directory ${targetDir} exists — proceed?`, false) : false;
+  if (existsSync(targetDir) && !args.flags.force) {
+    const ok = await confirm(`Directory ${targetDir} exists — proceed?`, false);
     if (!ok) {
       console.error('Aborted.');
       process.exitCode = 1;
@@ -114,41 +89,51 @@ export async function run(ctx: CommandContext): Promise<void> {
     }
   }
 
-  // 1. Create directory
+  // 1. Create directory + commit the chosen ports to the registry.
   await mkdir(targetDir, { recursive: true });
+  const registry: PortRegistry = { backend: vars.backendPort };
+  if (includeFrontend) registry.frontend = vars.frontendPort;
+  if (includeAdmin) registry.admin = vars.adminPort;
+  if (includeAi) registry['ai-server'] = vars.aiPort;
+  await writeRegistry(targetDir, registry);
 
-  // Commit allocated ports into the project's registry so `add` / `dev` see them.
-  await ensurePort(targetDir, 'backend');
-  await ensurePort(targetDir, 'frontend');
-  await ensurePort(targetDir, 'admin');
-  await ensurePort(targetDir, 'ai-server');
+  // 2. Render base templates, excluding apps the user turned off.
+  const exclude = (rel: string): boolean =>
+    (!includeAdmin && (rel === 'apps/admin' || rel.startsWith('apps/admin/'))) ||
+    (!includeFrontend && (rel === 'apps/frontend' || rel.startsWith('apps/frontend/'))) ||
+    (!includeAi && (rel === 'apps/ai-server' || rel.startsWith('apps/ai-server/')));
 
-  // 2. Render base templates (recursive)
-  await renderTemplateTree(join(TEMPLATES_DIR, 'base'), targetDir, vars);
+  await renderTemplateTree(join(TEMPLATES_DIR, 'base'), targetDir, vars as unknown as Record<string, unknown>, { exclude });
 
   // 2b. Create the full Laravel-style folder tree for the default backend.
-  //      Mirrors what `add backend` does so subsequent `make:*` calls find their homes.
   await ensureBackendFolderTree(join(targetDir, 'apps', 'backend'));
 
-  // 3. Apply example overlay (if not 'empty')
-  if (example && example !== 'empty') {
-    const exampleDir = join(EXAMPLES_DIR, example);
-    if (existsSync(exampleDir)) {
-      await renderTemplateTree(exampleDir, targetDir, vars);
-      console.log(`✓ Applied example: ${example}`);
+  // 3. Apply example overlay (if not 'empty').
+  if (vars.example && vars.example !== 'empty') {
+    const exampleDir = join(result.examplesDir, vars.example);
+    if (result.examplesDir && existsSync(exampleDir)) {
+      await renderTemplateTree(exampleDir, targetDir, vars as unknown as Record<string, unknown>);
+      console.log(`✓ Applied example: ${vars.example}`);
     } else {
-      console.warn(`! Example "${example}" not found — continuing with empty scaffold.`);
+      console.warn(`! Example "${vars.example}" not found — continuing with empty scaffold.`);
     }
   }
 
+  // 3b. Install selected backend feature starter code.
+  for (const id of backendFeatureIds) {
+    const feature = getFeature(id);
+    if (!feature) continue;
+    const res = await installFeature(targetDir, id);
+    for (const msg of res.messages) console.log(msg);
+  }
+
   // 4. .env
   const envPath = join(targetDir, '.env');
   if (!existsSync(envPath)) {
-    const envContent = buildEnvFile(vars);
-    await writeFile(envPath, envContent, 'utf-8');
+    await writeFile(envPath, buildEnvFile(vars), 'utf-8');
   }
 
-  // 5. Install dependencies (unless --no-install)
+  // 5. Install dependencies (unless --no-install).
   const skipInstall = !!args.flags['no-install'];
   if (skipInstall) {
     console.log(`\n( --no-install given — run \`npm install\` in ${targetDir} manually. )`);
@@ -168,15 +153,17 @@ export async function run(ctx: CommandContext): Promise<void> {
 ✓ Project scaffolded at ${targetDir}
 
 Next steps:
-  cd ${targetDirArg === '.' ? '.' : targetDirArg}
+  cd ${name}
   npm run dev
 
 Ports allocated:
-  Backend   : ${backendPort}
-  Frontend  : ${frontendPort}
-  Admin     : ${adminPort}
-  AI server : ${aiPort}
+  Backend   : ${vars.backendPort}
+  Frontend  : ${includeFrontend ? vars.frontendPort : '(not included)'}
+  Admin     : ${includeAdmin ? vars.adminPort : '(not included)'}
+  AI server : ${includeAi ? vars.aiPort : '(not included)'}
 `);
+
+
 }
 
 /** Run `npm install` in a directory; returns the exit code. */
@@ -195,13 +182,6 @@ function runNpmInstall(dir: string): Promise<number> {
   });
 }
 
-async function listExamples(): Promise<string[]> {
-  const dir = EXAMPLES_DIR;
-  if (!existsSync(dir)) return [];
-  const entries = await readdir(dir, { withFileTypes: true });
-  return entries.filter((e) => e.isDirectory()).map((e) => e.name);
-}
-
 /** The canonical 26-folder Laravel-style tree under a backend's src/. Exported for `add.ts`. */
 export const BACKEND_FOLDERS = [
   'src/routes', 'src/graphql', 'src/ws',
@@ -222,38 +202,6 @@ async function ensureBackendFolderTree(backendDir: string): Promise<void> {
   }
 }
 
-async function renderTemplateTree(srcDir: string, targetDir: string, vars: InitVars): Promise<void> {
-  if (!existsSync(srcDir)) {
-    console.warn(`[init] missing template dir: ${srcDir}`);
-    return;
-  }
-  const entries = await readdir(srcDir, { withFileTypes: true });
-  for (const e of entries) {
-    const src = join(srcDir, e.name);
-    const renderedName = isTemplateName(e.name) ? stripTemplateSuffix(e.name) : e.name;
-    // Handle special filenames
-    const fileName = renderedName === 'gitignore' ? '.gitignore'
-      : renderedName === 'dockerignore' ? '.dockerignore'
-      : renderedName;
-    const dest = join(targetDir, fileName);
-
-    if (e.isDirectory()) {
-      await mkdir(dest, { recursive: true });
-      await renderTemplateTree(src, dest, vars);
-    } else if (e.isFile()) {
-      try {
-        const raw = await readFile(src, 'utf-8');
-        const isTemplate = isTemplateName(e.name) || raw.includes('<%');
-        const content = isTemplate ? renderString(raw, vars as unknown as Record<string, unknown>) : raw;
-        await mkdir(dirname(dest), { recursive: true });
-        await writeFile(dest, content, 'utf-8');
-      } catch (err) {
-        console.warn(`[init] failed to render ${src}:`, err);
-      }
-    }
-  }
-}
-
 function buildEnvFile(vars: InitVars): string {
   return `# BhooAI Nexus — generated .env
 # Secrets live here. Do not commit.
@@ -271,8 +219,11 @@ NEXUS_REDIS_URL=${vars.redisUrl}
 # Auth
 NEXUS_AUTH_JWT_SECRET=${vars.jwtSecret}
 
-# AI providers (uncomment as needed)
-${vars.aiProviders.map((p) => `NEXUS_AI_${p.toUpperCase()}_API_KEY=`).join('\n') || '# NEXUS_AI_<PROVIDER>_API_KEY='}
+# AI (ollama is local by default; uncomment others as needed)
+NEXUS_AI_PROVIDER=ollama
+NEXUS_AI_MODEL=llama3.1:8b
+OLLAMA_MODEL=llama3.1:8b
+${vars.aiProviders.filter((p) => p !== 'ollama').map((p) => `# NEXUS_AI_${p.toUpperCase()}_API_KEY=`).join('\n')}
 
 # Storage (uncomment for S3)
 # NEXUS_STORAGE_S3_BUCKET=
@@ -282,5 +233,5 @@ ${vars.aiProviders.map((p) => `NEXUS_AI_${p.toUpperCase()}_API_KEY=`).join('\n')
 `;
 }
 
-export const description = 'Scaffold a new Nexus project (quick or interactive)';
-export const usage = 'nexus init [dir] [--example <name>] [--interactive] [--name <name>] [--no-install]';
+export const description = 'Scaffold a new Nexus project (guided wizard)';
+export const usage = 'nexus init [name] [--no-install] [--force]';