@bhooai/nexus-cli 2.0.2 → 2.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bhooai/nexus-cli",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "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

@@ -1,26 +1,18 @@
 /**
- * nexus dev — start the dev services:
- *   every apps/backend-* (tsx watch), frontend(s) (vite), admin (vite), ai-server (python).
+ * nexus dev — start the dev services.
  *
- * Sub-process supervision with log prefixing, auto-restart, and clean shutdown
- * on Ctrl+C.
+ * In an interactive TTY this opens the full-screen Nexus Console control panel
+ * (services start/stop/restart + a palette that runs every other CLI command).
+ * When stdout isn't a TTY (CI, piped) it falls back to plain prefixed log
+ * streaming. Pass `--no-panel` to force plain mode in a TTY.
  */
-import { spawn, type ChildProcess } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
-import { resolve, join } from 'node:path';
+import { join } from 'node:path';
 import type { CommandContext } from '../dispatcher.js';
 import { ensurePort } from '../ports.js';
-
-interface Service {
-  name: string;
-  cmd: string;
-  args: string[];
-  cwd: string;
-  color: string;
-  enabled: boolean;
-  port: number;
-}
+import { ServiceManager, type ServiceSpec } from '../devServiceManager.js';
+import { startDevPanel } from '../devPanel.js';
 
 const COLORS = ['\x1b[36m', '\x1b[33m', '\x1b[35m', '\x1b[32m', '\x1b[34m', '\x1b[31m', '\x1b[37m', '\x1b[90m'];
 const RESET = '\x1b[0m';
@@ -28,8 +20,59 @@ const RESET = '\x1b[0m';
 export async function run(ctx: CommandContext): Promise<void> {
   const only = (ctx.args.flags.only as string)?.split(',').map((s) => s.trim()) ?? null;
   const projectRoot = process.cwd();
+  const noPanel = !!ctx.args.flags['no-panel'];
+  const isTty = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+
+  const specs = await discoverServices(projectRoot, only);
+  if (specs.length === 0) {
+    console.log('No services to start. Check that apps/* exist.');
+    return;
+  }
+
+  const manager = new ServiceManager(specs, projectRoot);
+
+  if (isTty && !noPanel) {
+    // Full-screen Nexus Console.
+    console.log(`nexus dev — ${specs.length} service(s). Opening console...\n`);
+    await startDevPanel({ services: manager, onQuit: () => manager.killAll() });
+    return;
+  }
+
+  // Plain mode (piped / CI / --no-panel): start all + stream prefixed logs.
+  console.log(`nexus dev — starting ${specs.length} service(s)\n`);
+  let shuttingDown = false;
+  const shutdown = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    manager.killAll();
+    setTimeout(() => process.exit(0), 500);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  // Wire a plain log printer (prints only NEW lines per service).
+  const colors = new Map<string, string>();
+  specs.forEach((s, i) => colors.set(s.name, COLORS[i % COLORS.length]!));
+  const printed = new Map<string, number>();
+  manager.onLog = (name) => {
+    const svc = manager.get(name);
+    if (!svc) return;
+    const prefix = `${colors.get(name) ?? ''}[${name}]${RESET}`;
+    const from = printed.get(name) ?? 0;
+    const newLines = svc.logBuffer.slice(from);
+    printed.set(name, svc.logBuffer.length);
+    for (const line of newLines) {
+      process.stdout.write(`${prefix} ${line}\n`);
+    }
+  };
+
+  for (const spec of specs) manager.start(spec.name);
 
-  // Discover backends, frontends, admin, ai-server under apps/
+  // Keep the process alive.
+  await new Promise(() => {});
+}
+
+async function discoverServices(projectRoot: string, only: string[] | null): Promise<ServiceSpec[]> {
   const appsDir = join(projectRoot, 'apps');
   const appEntries = existsSync(appsDir) ? await readdir(appsDir, { withFileTypes: true }) : [];
   const backends  = appEntries.filter((e) => e.isDirectory() && e.name.startsWith('backend')).map((e) => e.name);
@@ -37,127 +80,33 @@ export async function run(ctx: CommandContext): Promise<void> {
   const admins    = appEntries.filter((e) => e.isDirectory() && e.name.startsWith('admin')).map((e) => e.name);
   const aiServers = appEntries.filter((e) => e.isDirectory() && e.name === 'ai-server').map((e) => e.name);
 
-  const services: Service[] = [];
-  let colorIdx = 0;
-
+  const specs: ServiceSpec[] = [];
   for (const b of backends) {
-    const mainPath = join(appsDir, b, 'src', 'main.ts');
-    if (!existsSync(mainPath)) continue;
+    if (!existsSync(join(appsDir, b, 'src', 'main.ts'))) continue;
     const port = await ensurePort(projectRoot, b);
-    services.push({
-      name: b,
-      cmd: 'npx',
-      args: ['tsx', 'watch', 'src/main.ts'],
-      cwd: join(appsDir, b),
-      color: COLORS[colorIdx++ % COLORS.length]!,
-      enabled: !only || only.includes(b),
-      port: port,
-    });
+    if (only && !only.includes(b)) continue;
+    specs.push({ name: b, cmd: 'npx', args: ['tsx', 'watch', 'src/main.ts'], cwd: join(appsDir, b), port });
   }
   for (const f of frontends) {
     if (!existsSync(join(appsDir, f, 'package.json'))) continue;
     const port = await ensurePort(projectRoot, f);
-    services.push({
-      name: f,
-      cmd: 'npx',
-      args: ['vite', '--port', String(port), '--strictPort'],
-      cwd: join(appsDir, f),
-      color: COLORS[colorIdx++ % COLORS.length]!,
-      enabled: !only || only.includes(f),
-      port,
-    });
+    if (only && !only.includes(f)) continue;
+    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);
-    services.push({
-      name: a,
-      cmd: 'npx',
-      args: ['vite', '--port', String(port), '--strictPort'],
-      cwd: join(appsDir, a),
-      color: COLORS[colorIdx++ % COLORS.length]!,
-      enabled: !only || only.includes(a),
-      port,
-    });
+    if (only && !only.includes(a)) continue;
+    specs.push({ name: a, cmd: 'npx', args: ['vite', '--port', String(port), '--strictPort'], cwd: join(appsDir, a), port, portArgIndex: 2 });
   }
   for (const ai of aiServers) {
-    const mainPy = join(appsDir, ai, 'main.py');
-    if (!existsSync(mainPy)) continue;
+    if (!existsSync(join(appsDir, ai, 'main.py'))) continue;
     const port = await ensurePort(projectRoot, ai);
-    services.push({
-      name: ai,
-      cmd: 'python',
-      args: ['main.py'],
-      cwd: join(appsDir, ai),
-      color: COLORS[colorIdx++ % COLORS.length]!,
-      enabled: !only || only.includes(ai),
-      port,
-    });
-  }
-
-  const active = services.filter((s) => s.enabled);
-  if (active.length === 0) {
-    console.log('No services to start. Check that apps/* exist.');
-    return;
-  }
-
-  console.log(`nexus dev — starting ${active.length} service(s)\n`);
-  for (const s of active) {
-    console.log(`  ${s.color}[${s.name}]${RESET} → :${s.port}`);
-  }
-  console.log('');
-
-  const procs: ChildProcess[] = [];
-  let shuttingDown = false;
-
-  const shutdown = () => {
-    if (shuttingDown) return;
-    shuttingDown = true;
-    console.log('\nShutting down...');
-    for (const p of procs) {
-      try {
-        p.kill('SIGTERM');
-      } catch { /* ignore */ }
-    }
-    setTimeout(() => process.exit(0), 500);
-  };
-
-  process.on('SIGINT', shutdown);
-  process.on('SIGTERM', shutdown);
-
-  for (const svc of active) {
-    const child = spawn(svc.cmd, svc.args, {
-      cwd: svc.cwd,
-      stdio: ['inherit', 'pipe', 'pipe'],
-      env: { ...process.env, FORCE_COLOR: '1', NEXUS_PORT: String(svc.port) },
-      shell: true,
-    });
-
-    const prefix = `${svc.color}[${svc.name}]${RESET}`;
-    child.stdout?.on('data', (chunk: Buffer) => {
-      const lines = chunk.toString().split('\n');
-      for (const line of lines) {
-        if (line.trim()) process.stdout.write(`${prefix} ${line}\n`);
-      }
-    });
-    child.stderr?.on('data', (chunk: Buffer) => {
-      const lines = chunk.toString().split('\n');
-      for (const line of lines) {
-        if (line.trim()) process.stderr.write(`${prefix} ${line}\n`);
-      }
-    });
-    child.on('exit', (code, signal) => {
-      if (shuttingDown) return;
-      console.log(`${prefix} exited (${code ?? signal}). Restarting in 1s...`);
-      setTimeout(() => {
-        if (!shuttingDown) {
-          procs.push(spawn(svc.cmd, svc.args, { cwd: svc.cwd, stdio: 'inherit', env: process.env, shell: true }));
-        }
-      }, 1000);
-    });
-    procs.push(child);
+    if (only && !only.includes(ai)) continue;
+    specs.push({ name: ai, cmd: 'python', args: ['main.py'], cwd: join(appsDir, ai), port });
   }
+  return specs;
 }
 
-export const description = 'Start dev services (all apps under ./apps)';
-export const usage = 'nexus dev [--only backend,frontend]';
+export const description = 'Start dev services (all apps under ./apps) — interactive console in a TTY';
+export const usage = 'nexus dev [--only a,b] [--no-panel]';

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]';