@cosider.construction/eapp 1.0.0

package/src/tui/engine.js

@@ -0,0 +1,330 @@
+/**
+ * TUI Engine
+ * Keyboard-driven interactive terminal UI components.
+ * Uses raw stdin to capture arrow keys, space, enter etc.
+ */
+
+import readline from 'readline';
+import chalk from 'chalk';
+
+// ─── Raw input helpers ────────────────────────────────────────────────────────
+
+export function enableRawInput() {
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  process.stdin.setEncoding('utf8');
+}
+
+export function disableRawInput() {
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(false);
+  }
+  process.stdin.pause();
+}
+
+export function clearLines(n) {
+  for (let i = 0; i < n; i++) {
+    process.stdout.write('\x1B[1A\x1B[2K');
+  }
+}
+
+export function hideCursor() { process.stdout.write('\x1B[?25l'); }
+export function showCursor() { process.stdout.write('\x1B[?25h'); }
+
+// ─── Key constants ────────────────────────────────────────────────────────────
+
+export const KEYS = {
+  UP:     '\x1B[A',
+  DOWN:   '\x1B[B',
+  RIGHT:  '\x1B[C',
+  LEFT:   '\x1B[D',
+  ENTER:  '\r',
+  SPACE:  ' ',
+  PLUS:   '+',
+  MINUS:  '-',
+  ESC:    '\x1B',
+  CTRL_C: '\x03',
+  BACKSPACE: '\x7F',
+};
+
+// ─── Simple text input ────────────────────────────────────────────────────────
+
+export async function textInput(prompt, defaultVal = '') {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const hint = defaultVal ? chalk.dim(` (${defaultVal})`) : '';
+    rl.question(chalk.cyan('  ? ') + prompt + hint + ' ', (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultVal);
+    });
+  });
+}
+
+// ─── Radio selector ───────────────────────────────────────────────────────────
+
+/**
+ * Horizontal radio — one choice from options
+ * Returns selected value
+ */
+export async function radioLine(prompt, options, defaultIdx = 0) {
+  let selected = defaultIdx;
+
+  const render = () => {
+    process.stdout.clearLine?.(0);
+    process.stdout.cursorTo?.(0);
+    const opts = options.map((o, i) =>
+      i === selected
+        ? chalk.green(`◉ ${o.label}`)
+        : chalk.dim(`○ ${o.label}`)
+    ).join('  ');
+    process.stdout.write(`  ${chalk.cyan(prompt)}  ${opts}`);
+  };
+
+  return new Promise((resolve) => {
+    hideCursor();
+    enableRawInput();
+    console.log('');
+    render();
+
+    const onKey = (key) => {
+      if (key === KEYS.CTRL_C) { showCursor(); disableRawInput(); process.exit(0); }
+      if (key === KEYS.LEFT)  { selected = (selected - 1 + options.length) % options.length; render(); }
+      if (key === KEYS.RIGHT) { selected = (selected + 1) % options.length; render(); }
+      if (key === KEYS.ENTER) {
+        process.stdout.write('\n');
+        process.stdin.removeListener('data', onKey);
+        showCursor();
+        disableRawInput();
+        resolve(options[selected].value);
+      }
+    };
+    process.stdin.on('data', onKey);
+  });
+}
+
+// ─── Options toggles ──────────────────────────────────────────────────────────
+
+/**
+ * One-line toggleable options
+ * Returns object { [key]: boolean }
+ */
+export async function optionsLine(options) {
+  // options = [{ key, label, default }]
+  const state = {};
+  options.forEach(o => { state[o.key] = o.default !== false; });
+  let cursor = 0;
+
+  const render = (lines = 1) => {
+    clearLines(lines);
+    const rendered = options.map((o, i) => {
+      const on = state[o.key];
+      const box = on ? chalk.green('◼') : chalk.dim('◻');
+      const label = i === cursor ? chalk.bold.white(o.label) : (on ? chalk.white(o.label) : chalk.dim(o.label));
+      return `${box} ${label}`;
+    }).join('  ');
+    console.log('  ' + rendered);
+    console.log(chalk.dim('  ← → navigate   space toggle   enter confirm'));
+  };
+
+  return new Promise((resolve) => {
+    hideCursor();
+    enableRawInput();
+    console.log('');
+    const rendered = options.map((o) => {
+      const on = state[o.key];
+      return `${on ? chalk.green('◼') : chalk.dim('◻')} ${on ? chalk.white(o.label) : chalk.dim(o.label)}`;
+    }).join('  ');
+    console.log('  ' + rendered);
+    console.log(chalk.dim('  ← → navigate   space toggle   enter confirm'));
+
+    const onKey = (key) => {
+      if (key === KEYS.CTRL_C) { showCursor(); disableRawInput(); process.exit(0); }
+      if (key === KEYS.LEFT)  { cursor = (cursor - 1 + options.length) % options.length; render(2); }
+      if (key === KEYS.RIGHT) { cursor = (cursor + 1) % options.length; render(2); }
+      if (key === KEYS.SPACE) { state[options[cursor].key] = !state[options[cursor].key]; render(2); }
+      if (key === KEYS.ENTER) {
+        process.stdin.removeListener('data', onKey);
+        showCursor();
+        disableRawInput();
+        resolve({ ...state });
+      }
+    };
+    process.stdin.on('data', onKey);
+  });
+}
+
+// ─── Interactive table ────────────────────────────────────────────────────────
+
+const COL_WIDTHS = {
+  field:  18,
+  type:   10,
+  values: 14,
+  pk:      4,
+  fk:      4,
+  group:  14,
+};
+
+const FIELD_TYPES = ['varchar', 'int', 'decimal', 'date', 'datetime', 'bit', 'text', 'float', 'enum'];
+
+const AUDIT_COL_WIDTHS = { field: 20, type: 10 };
+
+function pad(str, len) {
+  const s = String(str ?? '');
+  return s.length >= len ? s.slice(0, len - 1) + ' ' : s + ' '.repeat(len - s.length);
+}
+
+function renderTableHeader(cols, widths) {
+  const header = cols.map(c => chalk.bold.cyan(pad(c, widths[c] || 12))).join(chalk.dim('│'));
+  const divider = cols.map(c => '─'.repeat(widths[c] || 12)).join('┼');
+  return `  ┌${'─'.repeat(divider.length)}┐\n  │${header}│\n  ├${divider}┤`;
+}
+
+function renderFieldRow(row, cols, widths, isActive, activeCol) {
+  const cells = cols.map((col, ci) => {
+    let val = row[col] ?? '';
+    if (col === 'pk' || col === 'fk') val = val ? chalk.green('◼') : chalk.dim('◻');
+    const isThisCell = isActive && ci === activeCol;
+    const cell = pad(val, widths[col] || 12);
+    return isThisCell ? chalk.bgBlue.white(cell) : (isActive ? chalk.white(cell) : chalk.dim(cell));
+  }).join(chalk.dim('│'));
+  return `  │${cells}│`;
+}
+
+/**
+ * Interactive fields table
+ * Returns array of field objects
+ */
+export async function fieldsTable(initialRows, cols, widths, title) {
+  const rows = initialRows.map(r => ({ ...r }));
+  let rowIdx = 0;
+  let colIdx = 0;
+  let editBuffer = null; // currently editing text cell
+  let typeMenuOpen = false;
+  let typeMenuIdx = 0;
+
+  const toggleCols = cols.filter(c => c === 'pk' || c === 'fk');
+  const textCols   = cols.filter(c => c !== 'pk' && c !== 'fk');
+
+  function totalLines() {
+    return rows.length + 4; // header(3) + footer(1)
+  }
+
+  function render(initial = false) {
+    if (!initial) clearLines(totalLines() + (typeMenuOpen ? FIELD_TYPES.length + 2 : 0));
+
+    console.log('\n  ' + chalk.bold.white(title));
+    console.log(renderTableHeader(cols, widths));
+
+    rows.forEach((row, ri) => {
+      console.log(renderFieldRow(row, cols, widths, ri === rowIdx, colIdx));
+    });
+
+    console.log(`  └${'─'.repeat(cols.map(c => widths[c] || 12).reduce((a, b) => a + b, 0) + cols.length - 1)}┘`);
+    console.log(chalk.dim('  ← → cols   ↑ ↓ rows   + add row   - del row   space toggle pk/fk   enter done'));
+
+    if (typeMenuOpen) {
+      console.log('');
+      FIELD_TYPES.forEach((t, i) => {
+        console.log(i === typeMenuIdx ? chalk.green(`  ▶ ${t}`) : chalk.dim(`    ${t}`));
+      });
+    }
+  }
+
+  return new Promise((resolve) => {
+    hideCursor();
+    enableRawInput();
+    render(true);
+
+    const onKey = (key) => {
+      if (key === KEYS.CTRL_C) { showCursor(); disableRawInput(); process.exit(0); }
+
+      // Type menu open
+      if (typeMenuOpen) {
+        if (key === KEYS.UP)    { typeMenuIdx = (typeMenuIdx - 1 + FIELD_TYPES.length) % FIELD_TYPES.length; render(); return; }
+        if (key === KEYS.DOWN)  { typeMenuIdx = (typeMenuIdx + 1) % FIELD_TYPES.length; render(); return; }
+        if (key === KEYS.ENTER) {
+          rows[rowIdx].type = FIELD_TYPES[typeMenuIdx];
+          typeMenuOpen = false;
+          render();
+          return;
+        }
+        if (key === KEYS.ESC) { typeMenuOpen = false; render(); return; }
+        return;
+      }
+
+      // Navigation
+      if (key === KEYS.UP)    { rowIdx = Math.max(0, rowIdx - 1); editBuffer = null; render(); return; }
+      if (key === KEYS.DOWN)  { rowIdx = Math.min(rows.length - 1, rowIdx + 1); editBuffer = null; render(); return; }
+      if (key === KEYS.LEFT)  { colIdx = Math.max(0, colIdx - 1); editBuffer = null; render(); return; }
+      if (key === KEYS.RIGHT) { colIdx = Math.min(cols.length - 1, colIdx + 1); editBuffer = null; render(); return; }
+
+      // Add / remove rows
+      if (key === KEYS.PLUS) {
+        const newRow = {};
+        cols.forEach(c => { newRow[c] = c === 'pk' || c === 'fk' ? false : ''; });
+        rows.splice(rowIdx + 1, 0, newRow);
+        rowIdx++;
+        render();
+        return;
+      }
+      if (key === KEYS.MINUS) {
+        if (rows.length > 1) { rows.splice(rowIdx, 1); rowIdx = Math.min(rowIdx, rows.length - 1); }
+        render();
+        return;
+      }
+
+      // Toggle pk/fk
+      if (key === KEYS.SPACE) {
+        const col = cols[colIdx];
+        if (col === 'pk' || col === 'fk') {
+          rows[rowIdx][col] = !rows[rowIdx][col];
+          // Only one PK allowed
+          if (col === 'pk' && rows[rowIdx][col]) {
+            rows.forEach((r, i) => { if (i !== rowIdx) r.pk = false; });
+          }
+          render();
+          return;
+        }
+        // Open type menu on type column
+        if (col === 'type') {
+          typeMenuOpen = true;
+          typeMenuIdx = FIELD_TYPES.indexOf(rows[rowIdx].type || 'varchar');
+          if (typeMenuIdx < 0) typeMenuIdx = 0;
+          render();
+          return;
+        }
+      }
+
+      // Done
+      if (key === KEYS.ENTER) {
+        const col = cols[colIdx];
+        if (col === 'type') { typeMenuOpen = true; typeMenuIdx = 0; render(); return; }
+        process.stdin.removeListener('data', onKey);
+        showCursor();
+        disableRawInput();
+        resolve(rows);
+        return;
+      }
+
+      // Text editing for current cell
+      const col = cols[colIdx];
+      if (col === 'pk' || col === 'fk') return;
+
+      if (key === KEYS.BACKSPACE) {
+        rows[rowIdx][col] = String(rows[rowIdx][col] || '').slice(0, -1);
+        render();
+        return;
+      }
+
+      // Printable character
+      if (key.length === 1 && key >= ' ') {
+        rows[rowIdx][col] = (rows[rowIdx][col] || '') + key;
+        render();
+      }
+    };
+
+    process.stdin.on('data', onKey);
+  });
+}

package/src/utils/fs.js

@@ -0,0 +1,125 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+export async function writeFile(filePath, content, { dryRun = false } = {}) {
+  if (dryRun) {
+    console.log(chalk.cyan('  [dry-run]'), filePath);
+    return;
+  }
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, 'utf8');
+  console.log(chalk.green('  created '), chalk.dim(filePath));
+}
+
+export async function writeJson(filePath, data, opts = {}) {
+  await writeFile(filePath, JSON.stringify(data, null, 2) + '\n', opts);
+}
+
+export async function readJson(filePath) {
+  return fs.readJson(filePath);
+}
+
+export async function exists(p) {
+  return fs.pathExists(p);
+}
+
+export async function readDir(p) {
+  if (!(await exists(p))) return [];
+  const entries = await fs.readdir(p, { withFileTypes: true });
+  return entries.filter(e => e.isDirectory()).map(e => e.name);
+}
+
+export function assertProjectRoot(cwd = process.cwd()) {
+  const marker = path.join(cwd, 'src', 'backend', 'engine');
+  if (!fs.existsSync(marker)) {
+    console.error(chalk.red('✖ Not inside a generated eapp project.'));
+    console.error(chalk.dim('  Could not find src/backend/engine/ — are you in the right directory?'));
+    process.exit(1);
+  }
+}
+
+/**
+ * Read all ipc.json files to build entity registry
+ * Returns Map<"module.entity", { module, entity, schema, fields, pkField }>
+ */
+export async function loadEntityRegistry(cwd = process.cwd()) {
+  const registry = new Map();
+  const backendRoot = path.join(cwd, 'src', 'backend');
+
+  async function scanDir(dir, module) {
+    if (!(await exists(dir))) return;
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const entityDir = path.join(dir, entry.name);
+      const ipcFile = path.join(entityDir, 'ipc.json');
+      const metaFile = path.join(entityDir, 'entity.meta.json');
+      if (await exists(ipcFile)) {
+        const ipc = await readJson(ipcFile);
+        const meta = (await exists(metaFile)) ? await readJson(metaFile) : {};
+        const entity = entry.name.toLowerCase();
+        registry.set(`${module}.${entity}`, {
+          module,
+          entity,
+          schema: meta.schema || (module === 'shared' ? 'dbo' : module),
+          fields: meta.fields || [],
+          auditFields: meta.auditFields || [],
+          pkField: meta.pkField || 'id',
+          slaves: meta.slaves || [],
+        });
+      }
+    }
+  }
+
+  // Scan shared
+  await scanDir(path.join(backendRoot, 'shared'), 'shared');
+
+  // Scan modules
+  const modulesDir = path.join(backendRoot, 'modules');
+  if (await exists(modulesDir)) {
+    const modules = await readDir(modulesDir);
+    for (const mod of modules) {
+      await scanDir(path.join(modulesDir, mod), mod.toLowerCase());
+    }
+  }
+
+  return registry;
+}
+
+/**
+ * Append or update a menu entry in a menu.json file
+ */
+export async function upsertMenuItem(menuFilePath, { module, entity, route, hMenu, vMenu }) {
+  let menu = { module, label: module, hMenu: { style: 'classic', items: [] }, vMenu: { items: [] } };
+  if (await exists(menuFilePath)) {
+    menu = await readJson(menuFilePath);
+  }
+
+  // Normalise: support both old array format and new { items: [] } format
+  if (Array.isArray(menu.hMenu)) menu.hMenu = { style: 'classic', items: menu.hMenu };
+  if (Array.isArray(menu.vMenu)) menu.vMenu = { items: menu.vMenu };
+  if (!menu.hMenu) menu.hMenu = { style: 'classic', items: [] };
+  if (!menu.vMenu) menu.vMenu = { items: [] };
+  if (!Array.isArray(menu.hMenu.items)) menu.hMenu.items = [];
+  if (!Array.isArray(menu.vMenu.items)) menu.vMenu.items = [];
+
+  const item = {
+    label: entity.charAt(0).toUpperCase() + entity.slice(1),
+    route,
+    icon: '',
+    permission: `${module}.${entity}.view`,
+  };
+
+  const upsert = (arr, item) => {
+    const idx = arr.findIndex(i => i.route === item.route);
+    if (idx >= 0) arr[idx] = item;
+    else arr.push(item);
+    return arr;
+  };
+
+  if (hMenu) menu.hMenu.items = upsert(menu.hMenu.items, item);
+  if (vMenu) menu.vMenu.items = upsert(menu.vMenu.items, item);
+
+  await writeJson(menuFilePath, menu);
+}

package/src/utils/log.js

@@ -0,0 +1,11 @@
+import chalk from 'chalk';
+
+export const log = {
+  info:    (...a) => console.log(chalk.blue('ℹ'), ...a),
+  success: (...a) => console.log(chalk.green('✔'), ...a),
+  warn:    (...a) => console.log(chalk.yellow('⚠'), ...a),
+  error:   (...a) => console.error(chalk.red('✖'), ...a),
+  title:   (s)   => console.log('\n' + chalk.bold.white(s)),
+  dim:     (...a) => console.log(chalk.dim(...a)),
+  danger:  (...a) => console.log(chalk.red('⚠'), chalk.red(...a)),
+};

package/src/utils/naming.js

@@ -0,0 +1,95 @@
+/**
+ * Naming utilities
+ */
+
+export const toUpper = (s) => s.toUpperCase();
+export const toLower = (s) => s.toLowerCase();
+
+export const toPascal = (s) =>
+  s.split(/[-_\s]+/)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+    .join('');
+
+export const isValidName = (s) => /^[a-zA-Z0-9_-]+$/.test(s);
+
+/**
+ * Parse "module/entity.schema" format
+ *
+ * /employee          → { module: 'shared', entity: 'employee', schema: 'dbo' }
+ * rh/employee        → { module: 'rh',     entity: 'employee', schema: 'rh'  }
+ * rh/employee.dbo    → { module: 'rh',     entity: 'employee', schema: 'dbo' }
+ * rh/employee.hr     → { module: 'rh',     entity: 'employee', schema: 'hr'  }
+ * rh/employee.       → { module: 'rh',     entity: 'employee', schema: 'rh'  } (dot alone = module)
+ * employee           → { module: 'shared', entity: 'employee', schema: 'dbo' } (no slash = shared)
+ */
+export function parseEntityPath(input) {
+  if (!input) throw new Error('No entity path provided.');
+
+  let raw = input.trim();
+
+  // Handle old dot notation for backwards compat: rh.employee → rh/employee
+  if (!raw.includes('/') && raw.includes('.') && raw.split('.').length === 2) {
+    const [mod, ent] = raw.split('.');
+    raw = `${mod}/${ent}`;
+  }
+
+  // No slash at all → shared
+  if (!raw.includes('/')) {
+    return { module: 'shared', entity: toLower(raw), schema: 'dbo' };
+  }
+
+  // Split on /
+  const slashIdx = raw.indexOf('/');
+  const modulePart = raw.slice(0, slashIdx);   // may be empty → shared
+  const rest       = raw.slice(slashIdx + 1);  // entity.schema or entity
+
+  const module = modulePart === '' ? 'shared' : toLower(modulePart);
+
+  // Split entity and schema on .
+  const dotIdx = rest.indexOf('.');
+  let entity, schema;
+
+  if (dotIdx === -1) {
+    // No dot → schema = module (or dbo for shared)
+    entity = toLower(rest);
+    schema = module === 'shared' ? 'dbo' : module;
+  } else {
+    entity = toLower(rest.slice(0, dotIdx));
+    const schemaPart = rest.slice(dotIdx + 1);
+    if (schemaPart === '') {
+      // Trailing dot → schema = module
+      schema = module === 'shared' ? 'dbo' : module;
+    } else {
+      schema = toLower(schemaPart);
+    }
+  }
+
+  if (!isValidName(entity)) {
+    throw new Error(`Invalid entity name "${entity}". Use alphanumeric, hyphens, underscores only.`);
+  }
+  if (module !== 'shared' && !isValidName(module)) {
+    throw new Error(`Invalid module name "${module}".`);
+  }
+
+  return { module, entity, schema };
+}
+
+/**
+ * Derive IPC route
+ * shared + client   → shared.CLIENT
+ * rh     + employee → modules.RH.EMPLOYEE
+ */
+export function ipcRoute(module, entity) {
+  if (module === 'shared') return `shared.${toUpper(entity)}`;
+  return `modules.${toUpper(module)}.${toUpper(entity)}`;
+}
+
+/**
+ * Derive the backend directory path for an entity
+ */
+export function backendEntityDir(cwd, module, entity) {
+  if (module === 'shared') {
+    return `${cwd}/src/backend/shared/${toUpper(entity)}`;
+  }
+  return `${cwd}/src/backend/modules/${toUpper(module)}/${toUpper(entity)}`;
+}