@bhooai/nexus-cli 2.0.3 → 2.0.4

package/src/layout.ts

@@ -0,0 +1,101 @@
+/**
+ * ANSI-aware layout helpers for the TUI screens.
+ *
+ * `padEnd`/`padStart` count ANSI escape bytes, which drifts every padded
+ * column whenever text carries color/bold codes. These helpers measure on the
+ * VISIBLE width so columns align, and clip long lines so they never wrap past
+ * the terminal width and scramble the frame.
+ */
+import { ANSI, stripAnsi } from './tui.js';
+
+export { stripAnsi };
+
+/** Visible length of a string (ANSI escapes excluded). */
+export function visibleWidth(s: string): number {
+  return stripAnsi(s).length;
+}
+
+/** Pad `text` to `width` visible columns (left or right aligned). */
+export function padVisible(text: string, width: number, align: 'left' | 'right' = 'left', fill = ' '): string {
+  const v = visibleWidth(text);
+  if (v >= width) return text;
+  const gap = fill.repeat(width - v);
+  return align === 'right' ? gap + text : text + gap;
+}
+
+/** Center `text` within `width` visible columns. */
+export function centerVisible(text: string, width: number): string {
+  const v = visibleWidth(text);
+  if (v >= width) return text;
+  const left = Math.floor((width - v) / 2);
+  const right = width - v - left;
+  return ' '.repeat(left) + text + ' '.repeat(right);
+}
+
+/**
+ * Truncate `text` to `width` visible columns, preserving any leading ANSI
+ * color/style. A trailing reset is appended when color was stripped mid-span.
+ */
+export function clipVisible(text: string, width: number): string {
+  if (visibleWidth(text) <= width) return text;
+  let out = '';
+  let used = 0;
+  let i = 0;
+  let sawColor = false;
+  while (i < text.length && used < width) {
+    const ch = text[i]!;
+    if (ch === '\x1b') {
+      let j = i + 1;
+      if (text.charCodeAt(j) === 0x5b) {
+        // CSI: ESC [ params/intermediates final
+        j++;
+        while (j < text.length) {
+          const c = text.charCodeAt(j);
+          if (c >= 0x20 && c <= 0x3f) { j++; continue; } // parameter + intermediate bytes
+          break;
+        }
+        if (j < text.length) j++; // final byte (0x40–0x7e)
+      } else if (j < text.length) {
+        j++; // non-CSI escape: consume one more byte
+      }
+      out += text.slice(i, j);
+      sawColor = true;
+      i = j;
+    } else {
+      out += ch;
+      used++;
+      i++;
+    }
+  }
+  if (sawColor && !out.endsWith(ANSI.reset)) out += ANSI.reset;
+  return out;
+}
+
+/** Fit `text` into exactly `width` visible columns: clip then pad. */
+export function fitCell(text: string, width: number, align: 'left' | 'right' = 'left'): string {
+  return padVisible(clipVisible(text, width), width, align);
+}
+
+export const BORDER = {
+  tl: '┌', tr: '┐', bl: '└', br: '┘', h: '─', v: '│',
+};
+
+/**
+ * Wrap `inner` lines in a single-line border box of inner width `innerWidth`.
+ * Returns the full bordered lines (top border, padded rows, bottom border).
+ */
+export function boxAround(inner: string[], innerWidth: number): string[] {
+  const top = `${ANSI.dim}${BORDER.tl}${BORDER.h.repeat(innerWidth + 2)}${BORDER.tr}${ANSI.reset}`;
+  const bottom = `${ANSI.dim}${BORDER.bl}${BORDER.h.repeat(innerWidth + 2)}${BORDER.br}${ANSI.reset}`;
+  const rows = [top];
+  for (const line of inner) {
+    rows.push(`${ANSI.dim}${BORDER.v}${ANSI.reset} ${fitCell(line, innerWidth)} ${ANSI.dim}${BORDER.v}${ANSI.reset}`);
+  }
+  rows.push(bottom);
+  return rows;
+}
+
+/** Repeat the horizontal border char for `n` columns, dimmed. */
+export function divider(n: number): string {
+  return `${ANSI.dim}${BORDER.h.repeat(Math.max(n, 0))}${ANSI.reset}`;
+}

package/src/templating/tree.ts

@@ -0,0 +1,66 @@
+/**
+ * Recursive template-tree rendering shared by init + feature scaffolding.
+ *
+ * Walks a source template directory and copies every file into `targetDir`,
+ * rendering EJS-style files (`<%= %>`, `<%- %>`, `<% %>`) with the given vars.
+ * Supports an `exclude` predicate for skipping whole subtrees (used to leave
+ * apps out of a scaffold when their feature toggle is off).
+ */
+import { mkdir, writeFile, readFile, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { renderString, isTemplateName, stripTemplateSuffix, type TemplateVars } from './render.js';
+
+export interface RenderTreeOptions {
+  /** Return true to skip a path (relative, using `/` separators). */
+  exclude?: (relPath: string) => boolean;
+}
+
+export async function renderTemplateTree(
+  srcDir: string,
+  targetDir: string,
+  vars: TemplateVars,
+  opts: RenderTreeOptions = {},
+): Promise<void> {
+  if (!existsSync(srcDir)) {
+    console.warn(`[render] missing template dir: ${srcDir}`);
+    return;
+  }
+  await renderDir(srcDir, targetDir, vars, opts, '');
+}
+
+async function renderDir(
+  srcDir: string,
+  targetDir: string,
+  vars: TemplateVars,
+  opts: RenderTreeOptions,
+  rel: string,
+): Promise<void> {
+  const entries = await readdir(srcDir, { withFileTypes: true });
+  for (const e of entries) {
+    const src = join(srcDir, e.name);
+    const childRel = rel ? `${rel}/${e.name}` : e.name;
+    if (opts.exclude?.(childRel)) continue;
+
+    const renderedName = isTemplateName(e.name) ? stripTemplateSuffix(e.name) : e.name;
+    const fileName = renderedName === 'gitignore' ? '.gitignore'
+      : renderedName === 'dockerignore' ? '.dockerignore'
+      : renderedName;
+    const dest = join(targetDir, fileName);
+
+    if (e.isDirectory()) {
+      await mkdir(dest, { recursive: true });
+      await renderDir(src, dest, vars, opts, childRel);
+    } 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) : raw;
+        await mkdir(dirname(dest), { recursive: true });
+        await writeFile(dest, content, 'utf-8');
+      } catch (err) {
+        console.warn(`[render] failed to render ${src}:`, err);
+      }
+    }
+  }
+}

package/src/tui.ts

@@ -0,0 +1,170 @@
+/**
+ * Shared full-screen TUI helpers for the Nexus CLI.
+ *
+ * Zero-dependency ANSI + raw-mode keypress foundation used by the welcome
+ * launcher, the init wizard and the dev console panel. Owns raw input, the
+ * alternate screen buffer and suspend/resume for spawning interactive
+ * subcommands.
+ */
+import { stdin as input, stdout as output } from 'node:process';
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import * as readline from 'node:readline';
+
+export const ANSI = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  clear: '\x1b[2J\x1b[H',
+  altOn: '\x1b[?1049h',
+  altOff: '\x1b[?1049l',
+  hideCursor: '\x1b[?25l',
+  showCursor: '\x1b[?25h',
+  move: (r: number, c: number) => `\x1b[${r};${c}H`,
+  black: '\x1b[30m',
+  white: '\x1b[37m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  dimGray: '\x1b[90m',
+  bgReset: '\x1b[49m',
+  bgCyan: '\x1b[46m',
+  bgYellow: '\x1b[43m',
+  bgMagenta: '\x1b[45m',
+  bgGreen: '\x1b[42m',
+  bgBlue: '\x1b[44m',
+  bgRed: '\x1b[41m',
+};
+
+export interface KeyInfo {
+  name: string;
+  ctrl: boolean;
+  meta: boolean;
+  shift: boolean;
+  sequence: string;
+}
+
+export function isTty(): boolean {
+  return Boolean(input.isTTY && output.isTTY);
+}
+
+/** Fit a list of text lines into the current terminal height. */
+export function fitLines(lines: string[]): string[] {
+  const H = (output.rows || 24) - 1;
+  return lines.slice(0, Math.max(H, 1));
+}
+
+/**
+ * Tui — owns the alternate screen buffer + raw keypress stream.
+ *
+ * Callers provide an `onKey` handler and call `draw()` to paint a frame.
+ * `wait()` resolves once the `quit` flag is set (set by the caller, or by
+ * Ctrl+C via the internal signal handler).
+ */
+export class Tui {
+  private _quit = false;
+  private handler: (str: string, key: KeyInfo) => void;
+  private keypress = (str: string, key: KeyInfo) => this.handler(str, key);
+  private onSignal = () => { this._quit = true; };
+
+  constructor(handler: (str: string, key: KeyInfo) => void) {
+    this.handler = handler;
+  }
+
+  get quit(): boolean {
+    return this._quit;
+  }
+
+  set quit(v: boolean) {
+    this._quit = v;
+  }
+
+  enter(): void {
+    if (input.isTTY) {
+      input.setRawMode?.(true);
+      input.resume?.();
+      readline.emitKeypressEvents(input);
+      input.on('keypress', this.keypress);
+    }
+    output.write(ANSI.altOn + ANSI.hideCursor);
+    process.on('SIGINT', this.onSignal);
+    process.on('SIGTERM', this.onSignal);
+  }
+
+  /** Leave the screen so a child process can own the TTY. */
+  suspend(): void {
+    input.setRawMode?.(false);
+    output.write(ANSI.altOff + ANSI.showCursor);
+  }
+
+  resume(): void {
+    input.setRawMode?.(true);
+    input.resume?.();
+    output.write(ANSI.altOn + ANSI.hideCursor);
+  }
+
+  exit(): void {
+    input.removeListener('keypress', this.keypress);
+    input.setRawMode?.(false);
+    output.write(ANSI.altOff + ANSI.showCursor);
+    process.removeListener('SIGINT', this.onSignal);
+    process.removeListener('SIGTERM', this.onSignal);
+  }
+
+  /** Paint a frame. `rows` are the body; `footer` is the final status line. */
+  draw(rows: string[], footer = ''): void {
+    const H = output.rows || 24;
+    const body = fitLines(rows);
+    let out = ANSI.clear;
+    out += body.join('\n');
+    out += ANSI.move(H, 1);
+    out += footer;
+    output.write(out);
+  }
+
+  /** Resolve once `quit` becomes true. */
+  async wait(): Promise<void> {
+    while (!this._quit) {
+      await new Promise((r) => setTimeout(r, 100));
+    }
+  }
+}
+
+/** Strip ANSI color codes from a string. */
+export function stripAnsi(text: string): string {
+  return text.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+/** Spawn `node <bin> <args>` with inherited stdio (used for interactive CLI commands). */
+export function spawnNode(bin: string, args: string[]): Promise<void> {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [bin, ...args], { stdio: 'inherit', cwd: process.cwd() });
+    child.on('exit', () => resolve());
+    child.on('error', () => resolve());
+  });
+}
+
+/**
+ * Resolve the CLI bin for suspend-mode commands.
+ *
+ * Handles the monorepo layout (packages/nexus-cli/src → repo bin/nexus.js),
+ * the bundled layout (node_modules/bhooai-nexus/packages/nexus-cli/src →
+ * node_modules/bhooai-nexus/bin/nexus.js) and a CLI package with its own bin.
+ */
+export function resolveCliBin(): string {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(here, '..', '..', 'bin', 'nexus.js'),
+    join(here, '..', '..', '..', 'bin', 'nexus.js'),
+    join(here, '..', '..', '..', '..', 'bin', 'nexus.js'),
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) return p;
+  }
+  throw new Error(`Cannot resolve nexus bin (tried from ${here})`);
+}