@olonjs/cli 3.0.154 → 3.0.155

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@olonjs/cli",
-    "version": "3.0.154",
+    "version": "3.0.155",
     "description": "The Sovereign CLI Engine for OlonJS.",
     "type": "module",
     "bin": {
@@ -28,6 +28,7 @@
     },
     "scripts": {
         "build": "tsc -p .",
+        "test": "node --test src/**/*.test.js",
         "check:templates": "node ../../scripts/check-cli-templates.mjs"
     },
     "dependencies": {

package/src/index.js

@@ -7,6 +7,12 @@ import { execa } from 'execa';
 import ora from 'ora';
 import { fileURLToPath } from 'url';
 import os from 'os';
+import {
+  resolveTemplateId,
+  shouldPromptForTemplate,
+  UI_TEMPLATE_CHOICES,
+} from './templateChoice.js';
+import { selectWithArrows } from './selectWithArrows.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -86,11 +92,34 @@ function resolveTemplateScriptPath(templateName) {
   return templatePath;
 }
 
+async function resolveDnaTemplateId(templateOption) {
+  const isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  if (shouldPromptForTemplate({ templateOption, isTTY })) {
+    const dnaId = await selectWithArrows(
+      chalk.bold('Select stack:'),
+      UI_TEMPLATE_CHOICES.map((c) => ({ label: c.label, value: c.dnaId })),
+    );
+    return dnaId;
+  }
+
+  if (templateOption == null || String(templateOption).trim() === '') {
+    throw new Error(
+      'Non-interactive mode requires --template next|vite|alpha (for agents/CI).',
+    );
+  }
+
+  const dnaId = resolveTemplateId(templateOption);
+  if (!dnaId) {
+    throw new Error(`Unknown template "${templateOption}". Use next | vite | alpha.`);
+  }
+  return dnaId;
+}
+
 program
   .command('new')
   .argument('<type>', 'Type of artifact (tenant)')
   .argument('<name>', 'Name of the new tenant')
-  .option('--template <name>', 'Template profile (default: alpha)', 'alpha')
+  .option('--template <name>', 'Template for agents/CI: next | vite | alpha (skips interactive picker)')
   .option('--script <path>', 'Override default deterministic script path')
   .action(async (type, name, options) => {
     if (type !== 'tenant') {
@@ -100,46 +129,70 @@ program
 
     const targetDir = path.join(process.cwd(), name);
     const availableTemplates = getAvailableTemplates();
-    const template = options.template;
+
+    let dnaId;
+    try {
+      dnaId = await resolveDnaTemplateId(options.template);
+    } catch (error) {
+      console.log(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+      return;
+    }
+
     const scriptPath = options.script
       ? path.resolve(process.cwd(), options.script)
-      : resolveTemplateScriptPath(template);
-
-    if (!options.script && !availableTemplates.includes(template) && !(template === 'alpha' && fs.existsSync(LEGACY_ALPHA_DNA_PATH))) {
-      console.log(chalk.red(`Error: Unknown template "${template}".`));
-      console.log(chalk.yellow(`Available templates: ${availableTemplates.length ? availableTemplates.join(', ') : '(none found)'}`));
+      : resolveTemplateScriptPath(dnaId);
+
+    if (
+      !options.script &&
+      !availableTemplates.includes(dnaId) &&
+      !(dnaId === 'alpha' && fs.existsSync(LEGACY_ALPHA_DNA_PATH))
+    ) {
+      console.log(chalk.red(`Error: Unknown template "${dnaId}".`));
+      console.log(
+        chalk.yellow(
+          `Available templates: ${availableTemplates.length ? availableTemplates.join(', ') : '(none found)'}`,
+        ),
+      );
       return;
     }
 
     if (!fs.existsSync(scriptPath)) {
       console.log(chalk.red(`Error: DNA script not found at ${scriptPath}`));
-      console.log(chalk.yellow(`Debug info: template=${template}, assets=${CLI_ASSETS_DIR}`));
+      console.log(chalk.yellow(`Debug info: template=${dnaId}, assets=${CLI_ASSETS_DIR}`));
       return;
     }
 
-    console.log(chalk.blue.bold(`\nProjecting Sovereign Tenant: ${name} (template: ${template})\n`));
+    const stackLabel = dnaId === 'next' ? 'next' : 'vite';
+    console.log(chalk.blue.bold(`\nProjecting Sovereign Tenant: ${name} (stack: ${stackLabel}, dna: ${dnaId})\n`));
     const spinner = ora();
+    const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
 
     try {
-      spinner.start('Setting up environment (Vite + TS)...');
       await fs.ensureDir(targetDir);
 
-      const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-      await execa(npmCmd, ['create', 'vite@latest', '.', '--', '--template', 'react-ts'], { cwd: targetDir });
-      spinner.succeed('Environment scaffolded.');
+      if (dnaId === 'next') {
+        spinner.start('Preparing Next App Router workspace...');
+        spinner.succeed('Workspace ready.');
+      } else {
+        spinner.start('Setting up environment (Vite + TS)...');
+        await execa(npmCmd, ['create', 'vite@latest', '.', '--', '--template', 'react-ts'], {
+          cwd: targetDir,
+        });
+        spinner.succeed('Environment scaffolded.');
+
+        spinner.start('Wiping default boilerplate...');
+        await fs.emptyDir(path.join(targetDir, 'src'));
+        const junk = ['App.css', 'App.tsx', 'main.tsx', 'vite-env.d.ts', 'favicon.ico', 'index.html'];
+        for (const file of junk) {
+          await fs.remove(path.join(targetDir, file)).catch(() => {});
+          await fs.remove(path.join(targetDir, 'src', file)).catch(() => {});
+        }
+        spinner.succeed('Clean slate achieved.');
 
-      spinner.start('Wiping default boilerplate...');
-      await fs.emptyDir(path.join(targetDir, 'src'));
-      const junk = ['App.css', 'App.tsx', 'main.tsx', 'vite-env.d.ts', 'favicon.ico', 'index.html'];
-      for (const file of junk) {
-        await fs.remove(path.join(targetDir, file)).catch(() => {});
-        await fs.remove(path.join(targetDir, 'src', file)).catch(() => {});
+        spinner.start('Injecting Sovereign Configurations...');
+        await injectInfraFiles(targetDir, name);
+        spinner.succeed('Infrastructure configured.');
       }
-      spinner.succeed('Clean slate achieved.');
-
-      spinner.start('Injecting Sovereign Configurations...');
-      await injectInfraFiles(targetDir, name);
-      spinner.succeed('Infrastructure configured.');
 
       spinner.start('Executing deterministic src projection...');
       await processScriptInNode(scriptPath, targetDir);
@@ -153,7 +206,7 @@ program
       console.log(`  ${chalk.cyan(`cd ${name}`)}`);
       console.log(`  ${chalk.cyan('npm run dev')}   <- Start development`);
       console.log(`  ${chalk.cyan('npm run build')} <- Validate Green Build`);
-      console.log(`\nTemplate used: ${template}\n`);
+      console.log(`\nStack: ${stackLabel} · DNA: ${dnaId}\n`);
     } catch (error) {
       spinner.fail(chalk.red('Projection failed.'));
       console.error(error);

package/src/selectWithArrows.js

@@ -0,0 +1,71 @@
+import readline from 'node:readline';
+
+/**
+ * Minimal arrow-key select (no extra deps).
+ * @param {string} message
+ * @param {Array<{ label: string, value: string }>} choices
+ * @returns {Promise<string>} selected value
+ */
+export async function selectWithArrows(message, choices) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error('Interactive template selection requires a TTY. Pass --template next|vite|alpha.');
+  }
+
+  let index = 0;
+
+  const render = () => {
+    const lines = choices.map((choice, i) => {
+      const mark = i === index ? '>' : ' ';
+      return `  ${mark} ${choice.label}`;
+    });
+    process.stdout.write(`\x1B[?25l${message}\n${lines.join('\n')}\n`);
+  };
+
+  const clear = () => {
+    const lineCount = choices.length + 1;
+    process.stdout.write(`\x1B[${lineCount}A\x1B[0J`);
+  };
+
+  render();
+
+  return new Promise((resolve, reject) => {
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+
+    const onKey = (_str, key) => {
+      if (!key) return;
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        reject(new Error('Cancelled'));
+        return;
+      }
+      if (key.name === 'up' || key.name === 'k') {
+        index = (index - 1 + choices.length) % choices.length;
+        clear();
+        render();
+        return;
+      }
+      if (key.name === 'down' || key.name === 'j') {
+        index = (index + 1) % choices.length;
+        clear();
+        render();
+        return;
+      }
+      if (key.name === 'return') {
+        cleanup();
+        process.stdout.write(`\x1B[?25h`);
+        resolve(choices[index].value);
+      }
+    };
+
+    function cleanup() {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdin.off('keypress', onKey);
+      process.stdout.write('\x1B[?25h');
+    }
+
+    process.stdin.on('keypress', onKey);
+  });
+}

package/src/templateChoice.js

@@ -0,0 +1,29 @@
+/**
+ * Template selection for `olonjs new tenant`.
+ * UI labels: next | vite → DNA ids: next | alpha
+ */
+
+export const UI_TEMPLATE_CHOICES = [
+  { label: 'next', dnaId: 'next' },
+  { label: 'vite', dnaId: 'alpha' },
+];
+
+/** @param {string | undefined | null} raw */
+export function resolveTemplateId(raw) {
+  const v = String(raw ?? '')
+    .trim()
+    .toLowerCase();
+  if (!v) return null;
+  if (v === 'next') return 'next';
+  if (v === 'vite' || v === 'alpha') return 'alpha';
+  return null;
+}
+
+/**
+ * Prompt when humans run without --template on a TTY.
+ * Agents/CI must pass --template (non-TTY without flag → no prompt).
+ */
+export function shouldPromptForTemplate({ templateOption, isTTY }) {
+  if (templateOption != null && String(templateOption).trim() !== '') return false;
+  return Boolean(isTTY);
+}

package/src/templateChoice.test.js

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import {
+  resolveTemplateId,
+  shouldPromptForTemplate,
+  UI_TEMPLATE_CHOICES,
+} from './templateChoice.js';
+
+describe('UI_TEMPLATE_CHOICES', () => {
+  it('exposes next and vite labels for the TUI', () => {
+    assert.deepEqual(
+      UI_TEMPLATE_CHOICES.map((c) => c.label),
+      ['next', 'vite'],
+    );
+  });
+});
+
+describe('resolveTemplateId', () => {
+  it('maps next → next and vite/alpha → alpha', () => {
+    assert.equal(resolveTemplateId('next'), 'next');
+    assert.equal(resolveTemplateId('vite'), 'alpha');
+    assert.equal(resolveTemplateId('alpha'), 'alpha');
+    assert.equal(resolveTemplateId('NEXT'), 'next');
+  });
+
+  it('returns null for unknown values', () => {
+    assert.equal(resolveTemplateId('spa'), null);
+    assert.equal(resolveTemplateId(''), null);
+  });
+});
+
+describe('shouldPromptForTemplate', () => {
+  it('prompts only when flag absent and stdin is a TTY', () => {
+    assert.equal(shouldPromptForTemplate({ templateOption: undefined, isTTY: true }), true);
+    assert.equal(shouldPromptForTemplate({ templateOption: 'next', isTTY: true }), false);
+    assert.equal(shouldPromptForTemplate({ templateOption: undefined, isTTY: false }), false);
+  });
+});