@cosider.construction/eapp 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosider.construction/eapp",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Project-local CLI for Electron + Vue ERP projects",
   "type": "module",
   "bin": {

package/src/generators/entity.js

@@ -28,8 +28,8 @@ const AUDIT_WIDTHS    = { field: 20, type: 10 };
 
 // ─── Code generators ──────────────────────────────────────────────────────────
 
-function buildModelJs({ module, entity, schema, fields, auditFields, pkField }) {
-  const TABLE   = toUpper(entity);
+function buildModelJs({ module, entity, table, schema, fields, auditFields, pkField }) {
+  const TABLE   = toUpper(table || entity);
   const dbAlias = schema === 'dbo' ? 'dbo' : schema;
   const importPath = module === 'shared' ? '../../../engine/db.js' : '../../engine/db.js';
 
@@ -85,7 +85,7 @@ export async function remove(${pkField})    { return model.remove(${pkField}); }
 `;
 }
 
-function buildIpcJson({ module, entity, schema }) {
+function buildIpcJson({ module, entity, table, schema }) {
   const route = ipcRoute(module, entity);
   const mod   = module === 'shared' ? 'shared' : module;
   const ent   = toLower(entity);
@@ -121,9 +121,17 @@ function buildMetaJson({ module, entity, schema, fields, auditFields, pkField })
 
 // ─── Write entity files ───────────────────────────────────────────────────────
 
-async function writeEntity({ module, entity, schema, fields, auditFields, pkField, opts, dryRun }) {
+async function writeEntity({ module, entity, table, schema, fields, auditFields, pkField, opts, dryRun }) {
   const cwd = process.cwd();
-  const backendBase = module === 'shared'
+  // If user typed POLE.dbo it means entity=pole, schema=dbo — show confirmation
+  const displayPath = `${module}/${entity}` + (parsedTable !== entity ? `:${parsedTable}` : '') + `.${schema}`;
+  console.log('');
+  console.log(chalk.bold.white('  Entity  ') + chalk.cyan(displayPath));
+  if (parsedTable !== entity) {
+    console.log(chalk.dim(`  table name in DB will be: ${toUpper(parsedTable)}`));
+  }
+
+  const backendBase = module === 'shared' 
     ? path.join(cwd, 'src', 'backend', 'shared', toUpper(entity))
     : path.join(cwd, 'src', 'backend', 'modules', toUpper(module), toUpper(entity));
 
@@ -131,7 +139,7 @@ async function writeEntity({ module, entity, schema, fields, auditFields, pkFiel
 
   if (o.model) {
     await writeFile(path.join(backendBase, 'model.js'),
-      buildModelJs({ module, entity, schema, fields, auditFields, pkField }), { dryRun });
+      buildModelJs({ module, entity, table: table || entity, schema, fields, auditFields, pkField }), { dryRun });
   }
   if (o.controller) {
     await writeFile(path.join(backendBase, 'controller.js'),
@@ -139,7 +147,7 @@ async function writeEntity({ module, entity, schema, fields, auditFields, pkFiel
   }
   if (o.ipc) {
     await writeFile(path.join(backendBase, 'ipc.json'),
-      buildIpcJson({ module, entity, schema }), { dryRun });
+      buildIpcJson({ module, entity, table: table || entity, schema }), { dryRun });
   }
   // Always write meta so registry can read it
   await writeJson(path.join(backendBase, 'entity.meta.json'),
@@ -186,12 +194,21 @@ export async function generateEntity(args, rawArgs) {
     catch (e) { log.error(e.message); process.exit(1); }
   }
 
-  const { module, entity, schema } = parsed;
+  const { module, entity, table: parsedTable, schema } = parsed;
   const pkField = `${entity}_id`;
+  let tableOverride = parsedTable !== entity ? parsedTable : null;
 
   // ── Check if exists ───────────────────────────────────────────────────────
   const cwd = process.cwd();
-  const backendBase = module === 'shared'
+  // If user typed POLE.dbo it means entity=pole, schema=dbo — show confirmation
+  const displayPath = `${module}/${entity}` + (parsedTable !== entity ? `:${parsedTable}` : '') + `.${schema}`;
+  console.log('');
+  console.log(chalk.bold.white('  Entity  ') + chalk.cyan(displayPath));
+  if (parsedTable !== entity) {
+    console.log(chalk.dim(`  table name in DB will be: ${toUpper(parsedTable)}`));
+  }
+
+  const backendBase = module === 'shared' 
     ? path.join(cwd, 'src', 'backend', 'shared', toUpper(entity))
     : path.join(cwd, 'src', 'backend', 'modules', toUpper(module), toUpper(entity));
 
@@ -204,7 +221,7 @@ export async function generateEntity(args, rawArgs) {
   // ── --default: skip all prompts ───────────────────────────────────────────
   if (useDefault) {
     await writeEntity({
-      module, entity, schema,
+      module, entity, table: parsedTable || entity, schema,
       fields: defaultFillableRows(entity),
       auditFields: DEFAULT_AUDIT_ROWS,
       pkField,
@@ -246,7 +263,7 @@ export async function generateEntity(args, rawArgs) {
   const resolvedPk = pkRow ? pkRow.field : pkField;
 
   await writeEntity({
-    module, entity, schema,
+    module, entity, table: tableOverride || entity, schema,
     fields: fillableRows,
     auditFields: auditRows,
     pkField: resolvedPk,

package/src/generators/menu.js

@@ -12,11 +12,12 @@ function flattenItems(items = [], parentLabel = '') {
   const rows = [];
   for (const item of items) {
     rows.push({
-      label:      item.label || '',
-      route:      item.route || '',
-      icon:       item.icon  || '',
-      parent:     parentLabel,
-      permission: item.permission || '',
+      label:      item.label      || '',
+      icon:       item.icon       || '',
+      path:       parentLabel,
+      route:      item.route      || '',
+      dot:        item.dot        ? 'on' : 'off',
+      nbr:        item.nbr        || '',
     });
     if (item.children?.length) {
       rows.push(...flattenItems(item.children, item.label));
@@ -28,17 +29,19 @@ function flattenItems(items = [], parentLabel = '') {
 // ─── Rebuild nested menu items from flat rows ─────────────────────────────────
 
 function nestItems(rows) {
-  const top      = rows.filter(r => !r.parent);
-  const children = rows.filter(r => r.parent);
+  const top      = rows.filter(r => !r.path);
+  const children = rows.filter(r =>  r.path);
 
   return top.map(r => {
-    const item = { label: r.label, route: r.route, icon: r.icon };
-    if (r.permission) item.permission = r.permission;
-    const kids = children.filter(c => c.parent === r.label);
+    const item = { label: r.label, icon: r.icon, route: r.route };
+    if (r.dot === 'on') item.dot = true;
+    if (r.nbr)          item.nbr = r.nbr;
+    const kids = children.filter(c => c.path === r.label);
     if (kids.length) {
       item.children = kids.map(c => ({
-        label: c.label, route: c.route, icon: c.icon,
-        ...(c.permission ? { permission: c.permission } : {}),
+        label: c.label, icon: c.icon, route: c.route,
+        ...(c.dot === 'on' ? { dot: true } : {}),
+        ...(c.nbr          ? { nbr: c.nbr } : {}),
       }));
     }
     return item;
@@ -59,7 +62,7 @@ async function editViewMenu(menuFile, existing) {
     // Classic — same item table as module menu
     const existing_items = flattenItems(existing?.hMenu?.items || []);
     if (!existing_items.length) {
-      existing_items.push({ label: 'Action', route: '', icon: '', parent: '', permission: '' });
+      existing_items.push({ label: 'Action', icon: '', path: '', route: '', dot: 'off', nbr: '' });
     }
     console.log('');
     const rows = await fieldsTable(
@@ -185,14 +188,14 @@ export async function generateMenu(args, rawArgs) {
   console.log(chalk.bold.white(`  ${toPascal(module)} — hMenu`));
   const hRows = flattenItems(existing.hMenu?.items || []);
   if (!hRows.length) {
-    hRows.push({ label: `${toPascal(module)} Home`, route: `/${module}`, icon: '', parent: '', permission: '' });
+    hRows.push({ label: `${toPascal(module)} Home`, icon: '', path: '', route: `/${module}`, dot: 'off', nbr: '' });
   }
 
   const updatedH = await fieldsTable(
     hRows,
-    ['label', 'route', 'icon', 'parent', 'permission'],
-    { label: 16, route: 20, icon: 6, parent: 14, permission: 20 },
-    'hMenu  (parent = dropdown group label, empty = top level   enter done)'
+    ['label', 'icon', 'path', 'route', 'dot', 'nbr'],
+    { label: 16, icon: 5, path: 14, route: 20, dot: 5, nbr: 6 },
+    'hMenu  (path = parent group label, dot = show dot indicator, nbr = badge)'
   );
 
   // Pass 2 — vMenu
@@ -200,14 +203,14 @@ export async function generateMenu(args, rawArgs) {
   console.log(chalk.bold.white(`  ${toPascal(module)} — vMenu`));
   const vRows = flattenItems(existing.vMenu?.items || []);
   if (!vRows.length) {
-    vRows.push({ label: toPascal(module), route: `/${module}`, icon: '', parent: '', permission: '' });
+    vRows.push({ label: toPascal(module), icon: '', path: '', route: `/${module}`, dot: 'off', nbr: '' });
   }
 
   const updatedV = await fieldsTable(
     vRows,
-    ['label', 'route', 'icon', 'parent', 'permission'],
-    { label: 16, route: 20, icon: 6, parent: 14, permission: 20 },
-    'vMenu  (parent = collapsible group label, empty = top level   enter done)'
+    ['label', 'icon', 'path', 'route', 'dot', 'nbr'],
+    { label: 16, icon: 5, path: 14, route: 20, dot: 5, nbr: 6 },
+    'vMenu  (path = collapsible group label, dot = show dot indicator, nbr = badge)'
   );
 
   // Also check hMenu style

package/src/generators/module.js

@@ -121,7 +121,7 @@ export async function generateModule(args, rawArgs) {
     return {
       module:  lower,
       layout:  `${toPascal(lower)}Layout`,
-      vmenu:   'own',
+      hmenu:   'own',
       home:    'on',
       grid:    'on',
     };
@@ -138,7 +138,7 @@ export async function generateModule(args, rawArgs) {
     newName = toLower(newName.trim());
     if (!isValidName(newName)) { log.error('Invalid module name.'); process.exit(1); }
     if (!existing.find(e => toLower(e) === newName)) {
-      rows.push({ module: newName, layout: `${toPascal(newName)}Layout`, vmenu: 'own', home: 'on', grid: 'on' });
+      rows.push({ module: newName, layout: `${toPascal(newName)}Layout`, hmenu: 'own', home: 'on', grid: '3x2' });
     }
   }
 
@@ -146,17 +146,18 @@ export async function generateModule(args, rawArgs) {
   console.log('');
   const updated = await fieldsTable(
     rows,
-    ['module', 'layout', 'vmenu', 'home', 'grid'],
-    { module: 14, layout: 18, vmenu: 8, home: 6, grid: 6 },
-    'Modules  (edit layout name, vmenu: own|share, home/grid: on|off   enter to save)'
+    ['module', 'layout', 'hmenu', 'home', 'grid'],
+    { module: 14, layout: 18, hmenu: 8, home: 6, grid: 8 },
+    'Modules  (hmenu: own|share|none  home: on|off  grid: 0 or NxM e.g. 3x2   enter to save)'
   );
 
   // ── Write new/updated modules ──────────────────────────────────────────────
   for (const row of updated) {
     const name      = toLower(row.module);
     const hasHome   = row.home  !== 'off';
-    const hasGrid   = row.grid  !== 'off';
-    const ownVMenu  = row.vmenu !== 'share';
+    const gridVal   = row.grid  || '0';  // '0' = no grid, 'NxM' = N cols x M rows
+    const hasGrid   = gridVal !== '0' && gridVal !== 'off';
+    const hMenuScope = row.hmenu || 'own';  // own | share | none
     const layoutName = row.layout || `${toPascal(name)}Layout`;
 
     const backendDir  = path.join(cwd, 'src', 'backend',  'modules', toUpper(name));

package/src/generators/sql.js

@@ -0,0 +1,118 @@
+import path from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import { toUpper, toLower, toPascal } from '../utils/naming.js';
+import { writeFile, assertProjectRoot, loadEntityRegistry } from '../utils/fs.js';
+import { log } from '../utils/log.js';
+import { radioLine, textInput } from '../tui/engine.js';
+
+// ─── SQL generators ───────────────────────────────────────────────────────────
+
+function sqlTypeMap(appType) {
+  const map = {
+    varchar:  'NVARCHAR(255)',
+    int:      'INT',
+    decimal:  'DECIMAL(18,2)',
+    date:     'DATE',
+    datetime: 'DATETIME2',
+    bit:      'BIT',
+    text:     'NVARCHAR(MAX)',
+    float:    'FLOAT',
+    enum:     'NVARCHAR(50)',
+  };
+  return map[appType] || 'NVARCHAR(255)';
+}
+
+function buildCreateTable({ entity, table, schema, fields, auditFields, pkField }) {
+  const TABLE    = toUpper(table || entity);
+  const SCHEMA   = schema || 'dbo';
+  const allCols  = [...(fields || []), ...(auditFields || [])];
+
+  const colLines = allCols.map(f => {
+    const nullable = f.pk ? 'NOT NULL' : 'NULL';
+    const identity = f.pk ? ' IDENTITY(1,1)' : '';
+    return `    [${f.field}]  ${sqlTypeMap(f.type)}${identity}  ${nullable}`;
+  });
+
+  const pkLine = `    CONSTRAINT [PK_${TABLE}] PRIMARY KEY ([${pkField || `${entity}_id`}])`;
+
+  return `-- Generated by eapp — ${new Date().toISOString().slice(0, 10)}
+-- Entity : ${toLower(entity)}
+-- Table  : [${SCHEMA}].[${TABLE}]
+
+CREATE TABLE [${SCHEMA}].[${TABLE}] (
+${[...colLines, pkLine].join(',\n')}
+);
+GO
+`;
+}
+
+function buildAlterTable({ entity, table, schema, fields }) {
+  const TABLE  = toUpper(table || entity);
+  const SCHEMA = schema || 'dbo';
+
+  const lines = (fields || []).map(f =>
+    `ALTER TABLE [${SCHEMA}].[${TABLE}]  ADD  [${f.field}]  ${sqlTypeMap(f.type)}  NULL;`
+  );
+
+  return `-- Alter: add missing columns to [${SCHEMA}].[${TABLE}]
+${lines.join('\n')}
+GO
+`;
+}
+
+// ─── Main generator ───────────────────────────────────────────────────────────
+
+export async function generateSql(args, rawArgs) {
+  assertProjectRoot();
+
+  const cwd      = process.cwd();
+  const registry = await loadEntityRegistry(cwd);
+
+  if (!registry.size) {
+    log.warn('No entities found. Run  eapp entity  first.');
+    return;
+  }
+
+  // Pick entity from registry
+  const entries = [...registry.entries()];
+  console.log('');
+  console.log(chalk.bold.white('  Generate SQL for entity'));
+  const key = await textInput('module/entity (or "all"):');
+
+  const targets = key.trim() === 'all'
+    ? entries
+    : entries.filter(([k]) => k.endsWith(key.trim().toLowerCase()) || k === key.trim().toLowerCase());
+
+  if (!targets.length) {
+    log.error(`Entity "${key}" not found in registry.`);
+    return;
+  }
+
+  // Pick statement type
+  console.log('');
+  console.log(chalk.bold.white('  Statement type'));
+  const stmtType = await radioLine('', [
+    { label: 'CREATE TABLE', value: 'create' },
+    { label: 'ALTER (add cols)', value: 'alter' },
+  ]);
+
+  const sqlDir = path.join(cwd, 'src', 'backend', 'sql');
+  await fs.ensureDir(sqlDir);
+
+  for (const [, meta] of targets) {
+    const { module, entity, table, schema, fields, auditFields, pkField } = meta;
+    const fileName  = stmtType === 'create'
+      ? `${schema}_${toUpper(table || entity)}_create.sql`
+      : `${schema}_${toUpper(table || entity)}_alter.sql`;
+    const filePath  = path.join(sqlDir, fileName);
+    const content   = stmtType === 'create'
+      ? buildCreateTable({ entity, table, schema, fields, auditFields, pkField })
+      : buildAlterTable({ entity, table, schema, fields });
+
+    await writeFile(filePath, content);
+    log.success(`${fileName}`);
+  }
+
+  log.info(`SQL files written to  src/backend/sql/`);
+}

package/src/generators/view.js

@@ -349,11 +349,19 @@ export async function generateView(args, rawArgs) {
     defaultComps,
     COMP_COLS,
     COMP_WIDTHS,
-    'Components  (+ add  - remove  ← → cols  space menu toggle  enter done)'
+    'Components  (+ add  - remove  \u2190 \u2192 cols  space menu toggle  enter done)'
   );
 
-  const hasRow  = compRows.some(r => r.render === 'row'  || r.render === 'table');
-  const hasCard = compRows.some(r => r.render === 'card');
+  // List render mode — explicit radio (table / card / both) so user can't mistype
+  console.log('');
+  console.log(chalk.bold.white('  List render'));
+  const listRender = await radioLine('', [
+    { label: 'Table (row)', value: 'table' },
+    { label: 'Card',        value: 'card'  },
+    { label: 'Both',        value: 'both'  },
+  ]);
+  const hasRow  = listRender === 'table' || listRender === 'both';
+  const hasCard = listRender === 'card'  || listRender === 'both';
 
   // ── Step 4: slaves ────────────────────────────────────────────────────────
   let slaveConfigs = [];

package/src/index.js

@@ -39,28 +39,74 @@ Options:
   --help, -h   Show this help
 `;
 
+const MAIN_MENU = [
+  { label: 'Entity',  value: 'entity'  },
+  { label: 'Pivot',   value: 'pivot'   },
+  { label: 'View',    value: 'view'    },
+  { label: 'Module',  value: 'module'  },
+  { label: 'Menu',    value: 'menu'    },
+  { label: 'Sql',     value: 'sql'     },
+  { label: 'Config',  value: 'config'  },
+  { label: 'Layout',  value: 'layout'  },
+  { label: 'List',    value: 'list'    },
+  { label: 'Quit',    value: 'quit'    },
+];
+
 async function launchInteractive() {
-  console.log('');
-  console.log(chalk.bold.cyan('  eapp') + chalk.dim(' — what do you want to do?'));
-  console.log('');
-  const chosen = await radioLine('', [
-    { label: 'Entity',  value: 'entity'  },
-    { label: 'View',    value: 'view'    },
-    { label: 'Module',  value: 'module'  },
-    { label: 'Menu',    value: 'menu'    },
-    { label: 'Config',  value: 'config'  },
-    { label: 'Pivot',   value: 'pivot'   },
-    { label: 'Layout',  value: 'layout'  },
-    { label: 'List',    value: 'list'    },
-  ]);
-  console.log('');
-  if (chosen === 'list') {
-    await listModules();
+  let lastIdx = 0;
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    // Clear screen so each iteration feels fresh
+    process.stdout.write('\x1B[2J\x1B[H');
+    console.log('');
+    console.log(chalk.bold.cyan('  eapp') + chalk.dim(' — what do you want to do?'));
+    console.log(chalk.dim('  ← → select   enter confirm   Quit to exit'));
+
+    const chosen = await radioLine('', MAIN_MENU, lastIdx);
+    lastIdx = MAIN_MENU.findIndex(m => m.value === chosen);
+
     console.log('');
-    await listEntities([]);
-    return;
+
+    if (chosen === 'quit') {
+      console.log(chalk.dim('  Bye.\n'));
+      break;
+    }
+
+    if (chosen === 'sql') {
+      const { generateSql } = await import('./generators/sql.js');
+      await generateSql([], []);
+    } else if (chosen === 'list') {
+      await listModules();
+      console.log('');
+      await listEntities([]);
+    } else {
+      await run(chosen, [], []);
+    }
+
+    // Pause briefly so the user can read the result before the menu redraws
+    console.log('');
+    console.log(chalk.dim('  Press enter to return to the menu…'));
+    await waitEnter();
   }
-  await run(chosen, [], process.argv.slice(2));
+}
+
+function waitEnter() {
+  return new Promise((resolve) => {
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    const onKey = (key) => {
+      if (key === '\r' || key === '\n' || key === '\x03') {
+        if (process.stdin.isTTY) process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener('data', onKey);
+        if (key === '\x03') process.exit(0);
+        resolve();
+      }
+    };
+    process.stdin.on('data', onKey);
+  });
 }
 
 async function run(command, args, rawArgs) {

package/src/tui/engine.js

@@ -10,42 +10,37 @@ import chalk from 'chalk';
 // ─── Raw input helpers ────────────────────────────────────────────────────────
 
 export function enableRawInput() {
-  if (process.stdin.isTTY) {
-    process.stdin.setRawMode(true);
-  }
+  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);
-  }
+  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');
-  }
+  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'); }
+export function clearScreen() { process.stdout.write('\x1B[2J\x1B[H'); }
+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',
+  UP:        '\x1B[A',
+  DOWN:      '\x1B[B',
+  RIGHT:     '\x1B[C',
+  LEFT:      '\x1B[D',
+  ENTER:     '\r',
+  SPACE:     ' ',
+  PLUS:      '+',
+  MINUS:     '-',
+  ESC:       '\x1B',
+  CTRL_C:    '\x03',
   BACKSPACE: '\x7F',
 };
 
@@ -65,8 +60,8 @@ export async function textInput(prompt, defaultVal = '') {
 // ─── Radio selector ───────────────────────────────────────────────────────────
 
 /**
- * Horizontal radio — one choice from options
- * Returns selected value
+ * Horizontal radio — one choice from options.
+ * Returns selected value.
  */
 export async function radioLine(prompt, options, defaultIdx = 0) {
   let selected = defaultIdx;
@@ -75,9 +70,7 @@ export async function radioLine(prompt, options, defaultIdx = 0) {
     process.stdout.clearLine?.(0);
     process.stdout.cursorTo?.(0);
     const opts = options.map((o, i) =>
-      i === selected
-        ? chalk.green(`◉ ${o.label}`)
-        : chalk.dim(`○ ${o.label}`)
+      i === selected ? chalk.green(`◉ ${o.label}`) : chalk.dim(`○ ${o.label}`)
     ).join('  ');
     process.stdout.write(`  ${chalk.cyan(prompt)}  ${opts}`);
   };
@@ -90,9 +83,9 @@ export async function radioLine(prompt, options, defaultIdx = 0) {
 
     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) {
+      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();
@@ -107,43 +100,46 @@ export async function radioLine(prompt, options, defaultIdx = 0) {
 // ─── Options toggles ──────────────────────────────────────────────────────────
 
 /**
- * One-line toggleable options
+ * 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));
+  // Lines: 1 (options row) + 1 (hint row) — always exactly 2
+  const RENDERED_LINES = 2;
+
+  const renderRow = () => {
+    return 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('  ' + renderRow());
     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.LEFT)   { cursor = (cursor - 1 + options.length) % options.length; }
+      if (key === KEYS.RIGHT)  { cursor = (cursor + 1) % options.length; }
+      if (key === KEYS.SPACE)  { state[options[cursor].key] = !state[options[cursor].key]; }
+      if (key === KEYS.LEFT || key === KEYS.RIGHT || key === KEYS.SPACE) {
+        clearLines(RENDERED_LINES);
+        console.log('  ' + renderRow());
+        console.log(chalk.dim('  ← → navigate   space toggle   enter confirm'));
+        return;
+      }
       if (key === KEYS.ENTER) {
         process.stdin.removeListener('data', onKey);
         showCursor();
@@ -157,72 +153,108 @@ export async function optionsLine(options) {
 
 // ─── 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 };
+// Columns where space toggles a boolean (rendered as ◼/◻ checkboxes)
+const BOOL_COLS = new Set(['pk', 'fk']);
+
+// Columns where space cycles between string values
+const CYCLE_COLS = {
+  vmenu: ['own', 'share'],
+  hmenu: ['own', 'share', 'none'],
+  home:  ['on', 'off'],
+  // 'grid' is free-text (NxM), not cycled
+};
 
+// Strip ANSI escape codes to get the true printable length of a string.
+const ANSI_RE = /\x1B\[[0-9;]*m/g;
+function visibleLen(s) { return String(s).replace(ANSI_RE, '').length; }
+
+/**
+ * Pad or truncate str to exactly len visible characters.
+ * Too-long strings are cut with a trailing ellipsis so column borders stay aligned.
+ */
 function pad(str, len) {
-  const s = String(str ?? '');
-  return s.length >= len ? s.slice(0, len - 1) + ' ' : s + ' '.repeat(len - s.length);
+  const s  = String(str ?? '');
+  const vl = visibleLen(s);
+  if (vl === len) return s;
+  if (vl >  len)  return s.replace(ANSI_RE, '').slice(0, len - 1) + '…';
+  return s + ' '.repeat(len - vl);
 }
 
 function renderTableHeader(cols, widths) {
-  const header = cols.map(c => chalk.bold.cyan(pad(c, widths[c] || 12))).join(chalk.dim('│'));
+  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 colW       = widths[col] || 12;
     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));
+
+    let cell;
+    if (BOOL_COLS.has(col)) {
+      // Boolean: pad the plain glyph first so width is exact, then colorize
+      const glyph = pad(row[col] ? '◼' : '◻', colW);
+      cell = isThisCell
+        ? chalk.bgBlue.white(glyph)
+        : (row[col] ? chalk.green(glyph) : chalk.dim(glyph));
+    } else {
+      // Text / cycle: pad plain text, then colorize — ANSI codes added after padding
+      const plain = pad(String(row[col] ?? ''), colW);
+      cell = isThisCell
+        ? chalk.bgBlue.white(plain)
+        : (isActive ? chalk.white(plain) : chalk.dim(plain));
+    }
+
+    return cell;
   }).join(chalk.dim('│'));
   return `  │${cells}│`;
 }
 
 /**
- * Interactive fields table
- * Returns array of field objects
+ * Count of lines the table currently occupies (for accurate clearLines).
+ *   1  blank line before title
+ *   1  title line
+ *   3  header block (top border + header row + divider)
+ *   N  data rows
+ *   1  bottom border
+ *   1  hint line
+ *   +  type menu lines (when open)
+ */
+function tableLineCount(rowCount, typeMenuOpen) {
+  return 1 + 1 + 3 + rowCount + 1 + 1 + (typeMenuOpen ? FIELD_TYPES.length + 2 : 0);
+}
+
+function cycleValue(col, current) {
+  const opts = CYCLE_COLS[col];
+  if (!opts) return current;
+  return opts[(opts.indexOf(current) + 1) % opts.length];
+}
+
+/**
+ * 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)
-  }
+  let typeMenuIdx  = 0;
 
   function render(initial = false) {
-    if (!initial) clearLines(totalLines() + (typeMenuOpen ? FIELD_TYPES.length + 2 : 0));
+    if (!initial) clearLines(tableLineCount(rows.length, typeMenuOpen));
 
     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'));
+    const totalW = cols.map(c => widths[c] || 12).reduce((a, b) => a + b + 1, -1);
+    console.log(`  └${'─'.repeat(totalW)}┘`);
+    console.log(chalk.dim('  ← → cols   ↑ ↓ rows   + add   - del   space toggle/cycle   enter done'));
 
     if (typeMenuOpen) {
       console.log('');
@@ -240,30 +272,29 @@ export async function fieldsTable(initialRows, cols, widths, title) {
     const onKey = (key) => {
       if (key === KEYS.CTRL_C) { showCursor(); disableRawInput(); process.exit(0); }
 
-      // Type menu open
+      // ── Type picker ─────────────────────────────────────────────────────────
       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; }
+        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; }
+      // ── Navigation ──────────────────────────────────────────────────────────
+      if (key === KEYS.UP)    { rowIdx = Math.max(0, rowIdx - 1); render(); return; }
+      if (key === KEYS.DOWN)  { rowIdx = Math.min(rows.length - 1, rowIdx + 1); render(); return; }
+      if (key === KEYS.LEFT)  { colIdx = Math.max(0, colIdx - 1); render(); return; }
+      if (key === KEYS.RIGHT) { colIdx = Math.min(cols.length - 1, colIdx + 1); render(); return; }
 
-      // Add / remove rows
+      // ── Add / remove rows ───────────────────────────────────────────────────
       if (key === KEYS.PLUS) {
         const newRow = {};
-        cols.forEach(c => { newRow[c] = c === 'pk' || c === 'fk' ? false : ''; });
+        cols.forEach(c => {
+          if (BOOL_COLS.has(c))       newRow[c] = false;
+          else if (CYCLE_COLS[c])     newRow[c] = CYCLE_COLS[c][0];
+          else                        newRow[c] = '';
+        });
         rows.splice(rowIdx + 1, 0, newRow);
         rowIdx++;
         render();
@@ -275,29 +306,35 @@ export async function fieldsTable(initialRows, cols, widths, title) {
         return;
       }
 
-      // Toggle pk/fk
+      // ── Space ───────────────────────────────────────────────────────────────
       if (key === KEYS.SPACE) {
         const col = cols[colIdx];
-        if (col === 'pk' || col === 'fk') {
+
+        if (BOOL_COLS.has(col)) {
           rows[rowIdx][col] = !rows[rowIdx][col];
-          // Only one PK allowed
+          // Enforce single PK
           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 (CYCLE_COLS[col]) {
+          rows[rowIdx][col] = cycleValue(col, rows[rowIdx][col]);
+          render();
+          return;
+        }
+
         if (col === 'type') {
           typeMenuOpen = true;
-          typeMenuIdx = FIELD_TYPES.indexOf(rows[rowIdx].type || 'varchar');
-          if (typeMenuIdx < 0) typeMenuIdx = 0;
+          typeMenuIdx  = Math.max(0, FIELD_TYPES.indexOf(rows[rowIdx].type || 'varchar'));
           render();
           return;
         }
       }
 
-      // Done
+      // ── Enter ────────────────────────────────────────────────────────────────
       if (key === KEYS.ENTER) {
         const col = cols[colIdx];
         if (col === 'type') { typeMenuOpen = true; typeMenuIdx = 0; render(); return; }
@@ -308,9 +345,9 @@ export async function fieldsTable(initialRows, cols, widths, title) {
         return;
       }
 
-      // Text editing for current cell
+      // ── Text editing ─────────────────────────────────────────────────────────
       const col = cols[colIdx];
-      if (col === 'pk' || col === 'fk') return;
+      if (BOOL_COLS.has(col) || CYCLE_COLS[col]) return;   // not typed
 
       if (key === KEYS.BACKSPACE) {
         rows[rowIdx][col] = String(rows[rowIdx][col] || '').slice(0, -1);
@@ -318,7 +355,6 @@ export async function fieldsTable(initialRows, cols, widths, title) {
         return;
       }
 
-      // Printable character
       if (key.length === 1 && key >= ' ') {
         rows[rowIdx][col] = (rows[rowIdx][col] || '') + key;
         render();

package/src/utils/naming.js

@@ -27,15 +27,25 @@ export function parseEntityPath(input) {
 
   let raw = input.trim();
 
-  // Handle old dot notation for backwards compat: rh.employee → rh/employee
+  // Handle dot notation ONLY when the part before the dot could be a module name
+  // and the part after is NOT a schema keyword (dbo, etc.) — i.e. "rh.employee" → "rh/employee"
+  // BUT "POLE.dbo" must NOT be rewritten — POLE is the entity, dbo is the schema.
+  // Rule: rewrite "x.y" only when x contains no uppercase and y is not a known schema.
+  const SCHEMA_NAMES = new Set(['dbo', 'dbo2', 'hr', 'rh', 'stk', 'fin', 'crm', 'adm', 'sec', 'shared']);
   if (!raw.includes('/') && raw.includes('.') && raw.split('.').length === 2) {
-    const [mod, ent] = raw.split('.');
-    raw = `${mod}/${ent}`;
+    const [left, right] = raw.split('.');
+    const looksLikeSchema = SCHEMA_NAMES.has(right.toLowerCase()) || /^[a-z]+$/.test(right);
+    const looksLikeModule = /^[a-z][a-z0-9_-]*$/.test(left);
+    // Only rewrite if left looks like a lowercase module AND right does NOT look like a schema
+    if (looksLikeModule && !looksLikeSchema) {
+      raw = `${left}/${right}`;
+    }
   }
 
   // No slash at all → shared
   if (!raw.includes('/')) {
-    return { module: 'shared', entity: toLower(raw), schema: 'dbo' };
+    const _e = toLower(raw);
+  return { module: 'shared', entity: _e, table: _e, schema: 'dbo' };
   }
 
   // Split on /
@@ -49,20 +59,34 @@ export function parseEntityPath(input) {
   const dotIdx = rest.indexOf('.');
   let entity, schema;
 
-  if (dotIdx === -1) {
-    // No dot → schema = module (or dbo for shared)
-    entity = toLower(rest);
+  // Also parse optional table alias: entity:tableName
+  // e.g.  rh/agent:agentx.dbo  →  entity=agent, table=agentx, schema=dbo
+  let tableAlias = null;
+  if (rest.includes(':')) {
+    const colonIdx = rest.indexOf(':');
+    tableAlias = rest.slice(colonIdx + 1).split('.')[0];  // strip schema part
+    // rewrite rest without the alias for further parsing
+    // keep the .schema part after the alias if any
+    const afterColon = rest.slice(colonIdx + 1);
+    const schemaInAlias = afterColon.includes('.') ? afterColon.slice(afterColon.indexOf('.')) : '';
+    // rest becomes "entity.schema"
+    // rest = rest.slice(0, colonIdx) + schemaInAlias; — handled below
+  }
+  const cleanRest = rest.replace(/:([^.]+)/, '');  // strip :alias for entity/schema parsing
+
+  const dotIdx2 = cleanRest.indexOf('.');
+  let entity, schema;
+  if (dotIdx2 === -1) {
+    entity = toLower(cleanRest);
     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);
-    }
+    entity = toLower(cleanRest.slice(0, dotIdx2));
+    const schemaPart = cleanRest.slice(dotIdx2 + 1);
+    schema = schemaPart === '' ? (module === 'shared' ? 'dbo' : module) : toLower(schemaPart);
   }
+  const table = tableAlias ? toLower(tableAlias) : entity;
+  // (keep legacy variable for code below that uses dotIdx)
+  const dotIdx = dotIdx2;
 
   if (!isValidName(entity)) {
     throw new Error(`Invalid entity name "${entity}". Use alphanumeric, hyphens, underscores only.`);
@@ -71,7 +95,7 @@ export function parseEntityPath(input) {
     throw new Error(`Invalid module name "${module}".`);
   }
 
-  return { module, entity, schema };
+  return { module, entity, table: table || entity, schema };
 }
 
 /**