novac 2.0.1 → 2.2.0

package/novac/bin/nvml

@@ -0,0 +1,542 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * nvml — NVML CLI
+ * Part of the novac toolchain.
+ *
+ * Usage:
+ *   nvml <port> <file.nvml> [route]   Serve file.nvml on localhost:<port>
+ *   nvml compile <file.nvml>          Compile to HTML (stdout)
+ *   nvml ast <file.nvml>              Print AST as JSON
+ *   nvml tokens <file.nvml>           Print token stream as JSON
+ *   nvml check <file.nvml>            Check syntax
+ *   nvml --help                       Show help
+ *   nvml --version                    Show version
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const http = require('http');
+const os   = require('os');
+const url  = require('url');
+
+const chalk = (() => {
+  try { return require('chalk').default ?? require('chalk'); } catch { return null; }
+})();
+
+const VERSION = '1.0.0';
+
+// ── colour helpers (graceful fallback if chalk absent) ────────
+const c = {
+  green:  s => chalk ? chalk.green(s)  : s,
+  red:    s => chalk ? chalk.red(s)    : s,
+  cyan:   s => chalk ? chalk.cyan(s)   : s,
+  bold:   s => chalk ? chalk.bold(s)   : s,
+  dim:    s => chalk ? chalk.dim(s)    : s,
+  yellow: s => chalk ? chalk.yellow(s) : s,
+};
+
+function die(msg) {
+  process.stderr.write(c.red('[nvml] ' + msg) + '\n');
+  process.exit(1);
+}
+
+// ── locate kitnovacweb/nvml/index.js ─────────────────────────
+function resolveNvmlKit() {
+  const candidates = [
+    path.join(__dirname, '..', 'kits', 'kitnovacweb', 'nvml', 'index.js'),
+    path.join(process.cwd(), 'nova_modules', 'kitnovacweb', 'nvml', 'index.js'),
+    path.join(os.homedir(), '.novac', 'nova_modules', 'kitnovacweb', 'nvml', 'index.js'),
+    path.join(__dirname, '..', 'node_modules', 'kitnovacweb', 'nvml', 'index.js'),
+  ];
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+function loadKit() {
+  const kitPath = resolveNvmlKit();
+  if (!kitPath) {
+    die(
+      'kitnovacweb not found.\n\n' +
+      '  Install it with:\n' +
+      '    novac etc kit kitnovacweb\n\n' +
+      '  Or put it in nova_modules/kitnovacweb/'
+    );
+  }
+  return require(kitPath);
+}
+
+function loadLexer() {
+  const kitPath = resolveNvmlKit();
+  if (!kitPath) die('kitnovacweb not found.');
+  return require(path.join(path.dirname(kitPath), 'lexer.js'));
+}
+
+// ── Nova runtime loader ───────────────────────────────────────
+// Finds src/index.js and returns the `run` function, or null if not found.
+function resolveNovaRun() {
+  const searchPaths = [
+    path.join(__dirname, '..', 'src', 'index.js'),
+    path.join(process.cwd(), 'src', 'index.js'),
+    path.join(os.homedir(), '.novac', 'node_modules', 'novac', 'src', 'index.js'),
+    path.resolve(process.cwd(), 'node_modules', 'novac', 'src', 'index.js'),
+  ];
+  for (const p of searchPaths) {
+    if (fs.existsSync(p)) {
+      try {
+        const m = require(p);
+        return m.run || m.default?.run || null;
+      } catch (e) {
+        process.stderr.write(`[nvml] Warning: failed to load novac runtime from ${p}: ${e.message}\n`);
+        return null;
+      }
+    }
+  }
+  return null;
+}
+
+// ── document proxy for server-side Nova scripts ───────────────
+function findElementById(elements, id) {
+  for (const el of elements) {
+    if (el.props && el.props.id === id) return el;
+    if (el.children) {
+      const found = findElementById(el.children, id);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+function makeDocumentProxy(doc) {
+  return {
+    setConfig: (k, v)    => { doc.config[k] = v; },
+    getConfig: (k)       => doc.config[k],
+    setTitle:  (t)       => { doc.config.title = t; },
+    setMeta:   (k, v)    => { doc.config[k] = v; },
+    set: (id, content)   => {
+      const el = findElementById(doc.visual, id);
+      if (el) el.textValue = String(content);
+    },
+    get: (id) => {
+      const el = findElementById(doc.visual, id);
+      return el ? (el.textValue || null) : null;
+    },
+    setProp: (id, key, value) => {
+      const el = findElementById(doc.visual, id);
+      if (el) el.props[String(key)] = String(value);
+    },
+    getProp: (id, key) => {
+      const el = findElementById(doc.visual, id);
+      return el ? (el.props[String(key)] || null) : null;
+    },
+    addClass: (id, cls) => {
+      const el = findElementById(doc.visual, id);
+      if (!el) return;
+      const existing = el.props.class || '';
+      el.props.class = (existing ? existing + ' ' : '') + cls;
+    },
+    setClass: (id, cls) => {
+      const el = findElementById(doc.visual, id);
+      if (el) el.props.class = String(cls);
+    },
+    addElementStyle: (id, css) => {
+      const el = findElementById(doc.visual, id);
+      if (el) el.ss = (el.ss ? el.ss + '\n' : '') + css;
+    },
+    addStyle: (css) => { doc.globalStyles += '\n' + css; },
+    hide: (id) => {
+      const el = findElementById(doc.visual, id);
+      if (el) el.ss = (el.ss ? el.ss + '\n' : '') + 'display: none;';
+    },
+    show: (id, display) => {
+      const el = findElementById(doc.visual, id);
+      if (el) el.ss = (el.ss ? el.ss + '\n' : '') + `display: ${display || 'block'};`;
+    },
+    alert: (_msg) => {},
+    config: doc.config,
+    _doc:   doc,
+  };
+}
+
+// ── error page (served when compile fails during --serve) ─────
+function errorPage(file, err) {
+  const esc = s => String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
+  return `<!DOCTYPE html>
+<html><head><meta charset="UTF-8"><title>NVML Error</title>
+<style>
+  body{font-family:monospace;background:#1a1a1a;color:#eee;padding:2rem;margin:0}
+  h1{color:#f87171;font-size:1.1rem;margin:0 0 .75rem}
+  .file{color:#94a3b8;font-size:.8rem;margin-bottom:1.5rem}
+  pre{background:#111;border:1px solid #333;padding:1rem;border-radius:6px;
+      white-space:pre-wrap;word-break:break-word;font-size:.85rem;line-height:1.6}
+  .msg{color:#fca5a5}
+  .stack{color:#475569;font-size:.75rem;margin-top:.75rem}
+</style></head><body>
+<h1>NVML Error</h1>
+<div class="file">${esc(file)}</div>
+<pre class="msg">${esc(err.message)}</pre>
+<pre class="stack">${esc(err.stack || '')}</pre>
+</body></html>`;
+}
+
+// ── serve ─────────────────────────────────────────────────────
+function cmdServe(port, nvmlFile, route) {
+  const nvml    = loadKit();
+  const absFile = path.resolve(process.cwd(), nvmlFile);
+
+  if (!fs.existsSync(absFile)) die(`File not found: ${absFile}`);
+  if (!route.startsWith('/')) route = '/' + route;
+
+  // Load the Nova runtime once — used for every server-side script block
+  const novaRun = resolveNovaRun();
+  if (!novaRun) {
+    process.stderr.write(
+      c.yellow('[nvml] Warning: novac runtime not found — server-side Nova scripts will not run.\n') +
+      c.dim('  Searched: src/index.js relative to bin/ and cwd\n\n')
+    );
+  }
+
+  // Build a novaRunner for a given NvmlDocument + request context
+  function makeNovaRunner(reqCtx) {
+    if (!novaRun) return null;
+    return (code, doc) => {
+      const scope = {
+        document: makeDocumentProxy(doc),
+        request:  reqCtx || {},
+      };
+      novaRun(code, scope);
+    };
+  }
+
+  // Build a mutation-capturing proxy for /_nvml/run
+  const _sseClients = new Set(); // Server-Sent Events connections
+
+  function makeMutationProxy(mutations, live) {
+    return {
+      // config
+      setConfig:      (k, v)       => mutations.push({ type: 'setConfig',    key: String(k), value: v }),
+      setTitle:       (t)          => mutations.push({ type: 'setConfig',    key: 'title', value: t }),
+      setMeta:        (k, v)       => mutations.push({ type: 'setConfig',    key: String(k), value: v }),
+      // text / html
+      set:            (id, val)    => mutations.push({ type: 'setText',      id: String(id), value: String(val) }),
+      setHTML:        (id, val)    => mutations.push({ type: 'setHTML',      id: String(id), value: String(val) }),
+      // props / attrs
+      setProp:        (id, k, v)   => mutations.push({ type: 'setProp',      id: String(id), key: String(k), value: String(v) }),
+      setAttr:        (id, k, v)   => mutations.push({ type: 'setAttr',      id: String(id), key: String(k), value: String(v) }),
+      removeAttr:     (id, k)      => mutations.push({ type: 'removeAttr',   id: String(id), key: String(k) }),
+      // classes
+      addClass:       (id, cls)    => mutations.push({ type: 'addClass',     id: String(id), value: String(cls) }),
+      removeClass:    (id, cls)    => mutations.push({ type: 'removeClass',  id: String(id), value: String(cls) }),
+      toggleClass:    (id, cls, f) => mutations.push({ type: 'toggleClass',  id: String(id), value: String(cls), force: f }),
+      setClass:       (id, cls)    => mutations.push({ type: 'setClass',     id: String(id), value: String(cls) }),
+      // style
+      addStyle:       (css)        => mutations.push({ type: 'addStyle',     value: String(css) }),
+      addElementStyle:(id, css)    => mutations.push({ type: 'addStyle',     id: String(id), value: String(css) }),
+      setStyle:       (id, k, v)   => mutations.push({ type: 'setStyle',     id: String(id), key: String(k), value: String(v) }),
+      setCSSVar:      (name, val)  => mutations.push({ type: 'setCSSVar',    name: String(name), value: String(val) }),
+      // visibility
+      hide:           (id, t)      => mutations.push({ type: 'hide',         id: String(id), transition: t || null }),
+      show:           (id, d, t)   => mutations.push({ type: 'show',         id: String(id), value: d || 'block', transition: t || null }),
+      // DOM manipulation
+      remove:         (id, t)      => mutations.push({ type: 'remove',       id: String(id), transition: t || null }),
+      appendChild:    (id, html)   => mutations.push({ type: 'appendChild',  id: String(id), html: String(html) }),
+      insertBefore:   (id, html)   => mutations.push({ type: 'insertBefore', id: String(id), html: String(html) }),
+      insertAfter:    (id, html)   => mutations.push({ type: 'insertAfter',  id: String(id), html: String(html) }),
+      // focus / scroll
+      focus:          (id)         => mutations.push({ type: 'focus',        id: String(id) }),
+      blur:           (id)         => mutations.push({ type: 'blur',         id: String(id) }),
+      scroll:         (id, beh)    => mutations.push({ type: 'scroll',       id: String(id), behavior: beh || 'smooth' }),
+      // signals
+      setSignal:      (name, val)  => mutations.push({ type: 'setSignal',    name: String(name), value: val }),
+      // list patch
+      patchList:      (id, items, tpl, key) => mutations.push({ type: 'patchList', id: String(id), items, template: String(tpl), key: key || null }),
+      // navigation
+      navigate:       (path)       => mutations.push({ type: 'navigate',     path: String(path) }),
+      reload:         ()           => mutations.push({ type: 'reload' }),
+      redirect:       (url)        => mutations.push({ type: 'redirect',     url: String(url) }),
+      // feedback
+      alert:          (msg)        => mutations.push({ type: 'alert',        value: String(msg) }),
+      toast:          (msg, d, t)  => mutations.push({ type: 'toast',        value: String(msg), duration: d || 3000, type: t || 'info' }),
+      console:        (msg, lvl)   => mutations.push({ type: 'console',      value: String(msg), level: lvl || 'log' }),
+      // reads from live snapshot
+      get:            (id)         => (live.elements && live.elements[id]) ? live.elements[id].text : null,
+      getValue:       (id)         => (live.elements && live.elements[id]) ? live.elements[id].value : null,
+      getClass:       (id)         => (live.elements && live.elements[id]) ? live.elements[id].class : null,
+      getConfig:      (k)          => live[k] ?? null,
+      getSignal:      (n)          => (live.state && live.state[n]) ?? null,
+      config:         live,
+      // SSE push (server → all connected clients)
+      push:           (name, val)  => {
+        const msg = `event: signal\ndata: ${JSON.stringify({ name, value: val })}\n\n`;
+        _sseClients.forEach(c => { try { c.write(msg); } catch(_) {} });
+      },
+      pushMutations:  (muts)       => {
+        const msg = `event: mutations\ndata: ${JSON.stringify(muts)}\n\n`;
+        _sseClients.forEach(c => { try { c.write(msg); } catch(_) {} });
+      },
+    };
+  }
+
+  const server = http.createServer((req, res) => {
+    const parsed  = url.parse(req.url || '/');
+    const urlPath = parsed.pathname || '/';
+
+    // CORS
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+    if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
+
+    // ── /_nvml/sse — Server-Sent Events for server-push signal updates ──
+    if (urlPath === '/_nvml/sse' && req.method === 'GET') {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'X-Accel-Buffering': 'no',
+      });
+      res.write('retry: 3000\n\n'); // tell client to reconnect after 3s if disconnected
+      _sseClients.add(res);
+      req.on('close', () => _sseClients.delete(res));
+      return;
+    }
+
+    // ── /_nvml/run — triggered server-side Nova scripts ──────
+    if (urlPath === '/_nvml/run' && req.method === 'POST') {
+      let rawBody = '';
+      req.on('data', chunk => { rawBody += chunk; });
+      req.on('end', () => {
+        let code, live;
+        try {
+          const body = JSON.parse(rawBody);
+          code = String(body.code || '');
+          live = body.live || {};
+        } catch (e) {
+          return sendJSON(res, 400, { error: 'Invalid JSON body' });
+        }
+
+        if (!code.trim()) return sendJSON(res, 200, { mutations: [] });
+
+        if (!novaRun) {
+          return sendJSON(res, 503, { error: 'Nova runtime not available' });
+        }
+
+        const mutations = [];
+        const docProxy  = makeMutationProxy(mutations, live);
+        try {
+          novaRun(code, { document: docProxy, request: live });
+          return sendJSON(res, 200, { mutations });
+        } catch (e) {
+          process.stderr.write(c.red(`[nvml] /_nvml/run error: ${e.message}`) + '\n');
+          return sendJSON(res, 500, { error: e.message, mutations });
+        }
+      });
+      return;
+    }
+
+    // ── main route ───────────────────────────────────────────
+    if (urlPath !== route) {
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end(`404 — this server only handles: ${route}`);
+      return;
+    }
+
+    let source;
+    try { source = fs.readFileSync(absFile, 'utf8'); }
+    catch (e) { res.writeHead(500); res.end(e.message); return; }
+
+    // Build request context
+    const reqContext = {
+      method:  req.method,
+      url:     req.url,
+      path:    urlPath,
+      query:   Object.fromEntries(new URLSearchParams(parsed.query || '')),
+      headers: req.headers,
+      params:  {},
+      body:    null,
+    };
+
+    const compileAndSend = () => {
+      let html;
+      try {
+        html = nvml.compile(source, {
+          novaRunner:  makeNovaRunner(reqContext),
+          novaEmitter: null,
+        });
+      } catch (e) {
+        process.stderr.write(c.red(`[nvml] compile error: ${e.message}`) + '\n');
+        const errHtml = errorPage(nvmlFile, e);
+        res.writeHead(500, {
+          'Content-Type':   'text/html; charset=UTF-8',
+          'Content-Length': Buffer.byteLength(errHtml),
+        });
+        res.end(errHtml);
+        return;
+      }
+
+      res.writeHead(200, {
+        'Content-Type':   'text/html; charset=UTF-8',
+        'Content-Length': Buffer.byteLength(html),
+        'Cache-Control':  'no-store',
+        'X-Powered-By':   `nvml/${VERSION}`,
+      });
+      res.end(html);
+      process.stdout.write(c.dim(`  ${req.method} ${urlPath} → 200`) + '\n');
+    };
+
+    // Collect body for POST/PUT/PATCH before compiling
+    if (['POST', 'PUT', 'PATCH'].includes(req.method)) {
+      let rawBody = '';
+      req.on('data', chunk => { rawBody += chunk; });
+      req.on('end', () => {
+        try { reqContext.body = JSON.parse(rawBody); } catch { reqContext.body = rawBody; }
+        compileAndSend();
+      });
+    } else {
+      compileAndSend();
+    }
+  });
+
+  server.on('error', e => {
+    if (e.code === 'EADDRINUSE') die(`Port ${port} is already in use.`);
+    die(`Server error: ${e.message}`);
+  });
+
+  server.listen(port, '127.0.0.1', () => {
+    process.stdout.write(
+      c.green('\n  nvml server running') + '\n' +
+      c.cyan(`  http://localhost:${port}${route}`) + '\n\n' +
+      c.dim(`  file   : ${absFile}`) + '\n' +
+      c.dim(`  route  : ${route}`) + '\n' +
+      c.dim(`  reload : automatic (re-reads file on every request)`) + '\n\n' +
+      `  Press ${c.bold('Ctrl+C')} to stop.\n\n`
+    );
+  });
+
+  process.on('SIGINT',  () => { process.stdout.write('\n'); process.exit(0); });
+  process.on('SIGTERM', () => process.exit(0));
+}
+
+// ── helpers ───────────────────────────────────────────────────
+function sendJSON(res, code, obj) {
+  const body = JSON.stringify(obj);
+  res.writeHead(code, {
+    'Content-Type':                'application/json; charset=UTF-8',
+    'Content-Length':              Buffer.byteLength(body),
+    'Access-Control-Allow-Origin': '*',
+  });
+  res.end(body);
+}
+
+// ── compile ───────────────────────────────────────────────────
+function cmdCompile(nvmlFile) {
+  const nvml    = loadKit();
+  const absFile = path.resolve(process.cwd(), nvmlFile);
+  if (!fs.existsSync(absFile)) die(`File not found: ${absFile}`);
+  const novaRun = resolveNovaRun();
+  const novaRunner = novaRun
+    ? (code, doc) => novaRun(code, { document: makeDocumentProxy(doc), request: {} })
+    : null;
+  try {
+    process.stdout.write(nvml.compile(fs.readFileSync(absFile, 'utf8'), { novaRunner, novaEmitter: null }));
+  } catch (e) {
+    die(`Compile error: ${e.message}`);
+  }
+}
+
+// ── ast ───────────────────────────────────────────────────────
+function cmdAst(nvmlFile) {
+  const nvml    = loadKit();
+  const absFile = path.resolve(process.cwd(), nvmlFile);
+  if (!fs.existsSync(absFile)) die(`File not found: ${absFile}`);
+  try {
+    process.stdout.write(JSON.stringify(nvml.parse(fs.readFileSync(absFile, 'utf8')), null, 2) + '\n');
+  } catch (e) {
+    die(`Parse error: ${e.message}`);
+  }
+}
+
+// ── tokens ────────────────────────────────────────────────────
+function cmdTokens(nvmlFile) {
+  const { Lexer } = loadLexer();
+  const absFile   = path.resolve(process.cwd(), nvmlFile);
+  if (!fs.existsSync(absFile)) die(`File not found: ${absFile}`);
+  try {
+    process.stdout.write(JSON.stringify(new Lexer(fs.readFileSync(absFile, 'utf8')).tokenize(), null, 2) + '\n');
+  } catch (e) {
+    die(`Lex error: ${e.message}`);
+  }
+}
+
+// ── check ─────────────────────────────────────────────────────
+function cmdCheck(nvmlFile) {
+  const nvml    = loadKit();
+  const absFile = path.resolve(process.cwd(), nvmlFile);
+  if (!fs.existsSync(absFile)) die(`File not found: ${absFile}`);
+  try {
+    nvml.parse(fs.readFileSync(absFile, 'utf8'));
+    process.stdout.write(c.green(`  Syntax OK`) + c.dim(` — ${nvmlFile}`) + '\n');
+  } catch (e) {
+    die(`Syntax error: ${e.message}`);
+  }
+}
+
+// ── help ──────────────────────────────────────────────────────
+function printHelp() {
+  process.stdout.write(`
+${c.bold('nvml')} v${VERSION} — NVML CLI  ${c.dim('(part of novac)')}
+
+${c.bold('Usage:')}
+  nvml ${c.cyan('<port>')} ${c.cyan('<file.nvml>')}             Serve file on localhost:<port> (route: /)
+  nvml ${c.cyan('<port>')} ${c.cyan('<file.nvml>')} ${c.cyan('<route>')}   Serve on a specific route
+  nvml compile ${c.cyan('<file.nvml>')}         Compile to HTML and print to stdout
+  nvml ast     ${c.cyan('<file.nvml>')}         Print parsed AST as JSON
+  nvml tokens  ${c.cyan('<file.nvml>')}         Print token stream as JSON
+  nvml check   ${c.cyan('<file.nvml>')}         Validate NVML syntax
+  nvml --help                        Show this help
+  nvml --version                     Show version
+
+${c.bold('Examples:')}
+  nvml 3000 index.nvml
+  nvml 8080 about.nvml /about
+  nvml compile index.nvml > index.html
+  nvml check index.nvml
+  nvml ast index.nvml | head -30
+
+${c.bold('Notes:')}
+  The server re-reads the NVML file on every request — no restart needed.
+  CORS headers are set so nvml-browser can connect without issues.
+
+`);
+}
+
+// ── entry point ───────────────────────────────────────────────
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+  printHelp(); process.exit(0);
+}
+
+if (args[0] === '--version' || args[0] === '-v') {
+  process.stdout.write(`nvml v${VERSION}\n`); process.exit(0);
+}
+
+// subcommands
+switch (args[0]) {
+  case 'compile': if (!args[1]) die('Usage: nvml compile <file.nvml>'); cmdCompile(args[1]); break;
+  case 'ast':     if (!args[1]) die('Usage: nvml ast <file.nvml>');     cmdAst(args[1]);     break;
+  case 'tokens':  if (!args[1]) die('Usage: nvml tokens <file.nvml>');  cmdTokens(args[1]);  break;
+  case 'check':   if (!args[1]) die('Usage: nvml check <file.nvml>');   cmdCheck(args[1]);   break;
+  default: {
+    // nvml <port> <file> [route]
+    const port  = parseInt(args[0], 10);
+    const file  = args[1];
+    const route = args[2] || '/';
+    if (!port || port < 1 || port > 65535) die(`Invalid port: "${args[0]}"\nUsage: nvml <port> <file.nvml>`);
+    if (!file) die('Usage: nvml <port> <file.nvml> [route]');
+    cmdServe(port, file, route);
+  }
+}