@nova-lang/cli 0.1.1 → 0.2.0

package/lib/renderer.js

@@ -0,0 +1,564 @@
+const { NodeTag } = require("./types");
+
+const DEFAULT_STYLES = `
+body { font-family: 'Georgia', 'Noto Serif CJK', serif; line-height: 1.7; color: #333; max-width: 900px; margin: 0 auto; padding: 2rem; background: #fafafa; }
+.nova-document { background: #fff; padding: 2.5rem; border-radius: 4px; box-shadow: 0 1px 4px rgba(0,0,0,0.1); }
+h1, h2, h3, h4 { color: #1a1a1a; margin-top: 1.5em; margin-bottom: 0.5em; font-weight: 600; }
+h1 { font-size: 2em; border-bottom: 2px solid #eee; padding-bottom: 0.3em; }
+h2 { font-size: 1.5em; border-bottom: 1px solid #eee; padding-bottom: 0.2em; }
+p { margin: 0.8em 0; text-align: justify; }
+em { font-style: italic; }
+strong { font-weight: bold; }
+code { font-family: 'Fira Code', 'Consolas', monospace; background: #f0f0f0; padding: 0.15em 0.3em; border-radius: 3px; font-size: 0.9em; }
+pre { background: #f5f5f5; padding: 1em; border-radius: 4px; overflow-x: auto; }
+a { color: #0366d6; text-decoration: none; }
+a:hover { text-decoration: underline; }
+table { border-collapse: collapse; width: 100%; margin: 1em 0; }
+th, td { border: 1px solid #ddd; padding: 8px 12px; text-align: left; }
+th { background: #f5f5f5; font-weight: 600; }
+tr:nth-child(even) { background: #fafafa; }
+ul, ol { padding-left: 2em; margin: 0.5em 0; }
+li { margin: 0.3em 0; }
+blockquote { border-left: 4px solid #ddd; margin: 1em 0; padding: 0.5em 1em; color: #666; }
+.math { font-family: 'STIX', 'Latin Modern Math', serif; }
+.math-display { display: block; text-align: center; margin: 1em 0; overflow-x: auto; }
+.nova-meta { font-size: 0.9em; color: #888; margin: 1em 0; padding: 0.5em; background: #f9f9f9; border-radius: 4px; }
+.nova-meta-key { font-weight: bold; }
+.nova-schema, .nova-service { background: #f8f8ff; border: 1px solid #dde; padding: 1em; margin: 1em 0; border-radius: 4px; font-family: 'Fira Code', monospace; font-size: 0.9em; }
+.nova-field { margin: 0.3em 0; }
+.nova-tag { color: #888; }
+.nova-def { color: #444; }
+.nova-type { color: #b44; }
+.nova-ref { color: #0366d6; cursor: pointer; border-bottom: 1px dotted #0366d6; }
+.footnotes { margin-top: 2em; padding-top: 1em; border-top: 1px solid #ddd; font-size: 0.9em; color: #666; }
+.nova-config dt { font-weight: bold; margin-top: 0.5em; }
+.nova-config dd { margin-left: 1.5em; color: #555; }
+`;
+
+function escape(s) {
+  return s
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+const MATHJAX_SCRIPT = `
+<script>
+MathJax = {tex: {inlineMath: [['$','$'],['\\\\\\(','\\\\\\)']],displayMath:[['$$','$$'],['\\\\[','\\\\]']]},svg:{fontCache:'global'}};
+</script>
+<script src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-svg.js" async></script>
+`;
+
+function render(doc) {
+  const out = [];
+  let indentLevel = 0;
+
+  function emit(s) {
+    out.push(s, "\n");
+  }
+
+  function emitIndent(n) {
+    out.push("  ".repeat(n));
+  }
+
+  function emitLine(s) {
+    out.push(s, "\n");
+  }
+
+  function renderNode(node, indent) {
+    switch (node.tag) {
+      case NodeTag.block:
+        renderBlock(node.data, indent);
+        break;
+      case NodeTag.inline_block: {
+        const html = renderInline(node.data);
+        out.push(html);
+        break;
+      }
+      case NodeTag.text:
+        out.push(escape(node.data.value));
+        break;
+      case NodeTag.math_inline:
+        emitIndent(indent);
+        out.push(`<span class="math">\\(${escape(node.data.source)}\\)</span>`);
+        break;
+      case NodeTag.math_display:
+        emitIndent(indent);
+        out.push(`<div class="math-display">\\[${escape(node.data.source)}\\]</div>`);
+        break;
+      case NodeTag.interpolation:
+        out.push(`<code>#{${escape(node.data.expression)}}</code>`);
+        break;
+      case NodeTag.list_block:
+        renderList(node.data, indent);
+        break;
+      case NodeTag.table_block:
+        renderTable(node.data, indent);
+        break;
+      case NodeTag.schema_def:
+        renderSchema(node.data);
+        break;
+      case NodeTag.service_def:
+        renderService(node.data);
+        break;
+      case NodeTag.biblio_entry:
+        renderBiblioEntry(node.data);
+        break;
+      case NodeTag.if_block:
+        for (const c of node.data.then_body) renderNode(c, indent);
+        break;
+      case NodeTag.for_block:
+        for (const c of node.data.body) renderNode(c, indent);
+        break;
+      case NodeTag.document:
+        for (const c of node.data.children) renderNode(c, indent);
+        break;
+      case NodeTag.macro_def:
+      case NodeTag.meta_block:
+        break;
+    }
+  }
+
+  function renderBlock(block, indent) {
+    const name = block.name;
+
+    if (name === "page" || name === "header" || name === "body") {
+      for (const child of block.children) renderNode(child, indent);
+      return;
+    }
+
+    if (name === "else") {
+      for (const child of block.children) renderNode(child, indent);
+      return;
+    }
+
+    if (name === "title") {
+      emitIndent(indent);
+      out.push('<h1 class="nova-title">');
+      renderInlineList(block.inline_content);
+      emitLine("</h1>");
+      return;
+    }
+
+    if (name === "abstract") {
+      emitIndent(indent);
+      emitLine('<blockquote class="abstract">');
+      emitIndent(indent + 1);
+      emitLine("<strong>Abstract</strong>");
+      for (const child of block.children) renderNode(child, indent + 1);
+      emitIndent(indent);
+      emitLine("</blockquote>");
+      return;
+    }
+
+    if (name === "chapter" || name === "section") {
+      const level = name === "chapter" ? 2 : 3;
+      const tag = `h${level}`;
+
+      let titleText = "";
+      for (const child of block.children) {
+        if (child.tag === NodeTag.block && child.data.name === "title") {
+          titleText = collectText(child.data.inline_content);
+        }
+      }
+
+      emitIndent(indent);
+      out.push(`<${tag}`);
+      if (block.attrs.id) {
+        out.push(` id="${escape(block.attrs.id)}"`);
+      }
+      out.push(">");
+      emitLine("");
+      if (titleText) {
+        emitIndent(indent + 1);
+        out.push(escape(titleText));
+        emitLine("");
+      }
+      emitIndent(indent);
+      out.push(`</${tag}>`);
+      emitLine("");
+
+      for (const child of block.children) {
+        if (child.tag === NodeTag.block && child.data.name === "title") continue;
+        renderNode(child, indent);
+      }
+      return;
+    }
+
+    if (name === "p" || name === "para") {
+      emitIndent(indent);
+      out.push("<p>");
+      renderInlineList(block.inline_content);
+      renderChildrenInline(block.children);
+      emitLine("</p>");
+      return;
+    }
+
+    if (name === "div") {
+      emitIndent(indent);
+      emitLine("<div>");
+      for (const child of block.children) renderNode(child, indent + 1);
+      emitIndent(indent);
+      emitLine("</div>");
+      return;
+    }
+
+    if (name === "meta") {
+      emitIndent(indent);
+      emitLine('<div class="nova-meta">');
+      for (const [k, v] of Object.entries(block.attrs)) {
+        emitIndent(indent + 1);
+        out.push(`<span class="nova-meta-key">${escape(k)}</span>: <span class="nova-meta-val">${escape(v)}</span>`);
+        emitLine("");
+      }
+      emitIndent(indent);
+      emitLine("</div>");
+      return;
+    }
+
+    if (name === "config") {
+      emitIndent(indent);
+      emitLine('<dl class="nova-config">');
+      for (const [k, v] of Object.entries(block.attrs)) {
+        emitIndent(indent + 1);
+        out.push(`<dt>${escape(k)}</dt>`);
+        emitLine("");
+        emitIndent(indent + 1);
+        out.push(`<dd>${escape(v)}</dd>`);
+        emitLine("");
+      }
+      emitIndent(indent);
+      emitLine("</dl>");
+      return;
+    }
+
+    if (name === "note" || name === "warn") {
+      emitIndent(indent);
+      out.push(`<blockquote class="${name}">`);
+      emitLine("");
+      for (const child of block.children) renderNode(child, indent + 1);
+      emitIndent(indent);
+      emitLine("</blockquote>");
+      return;
+    }
+
+    if (name === "bibliography") {
+      emitIndent(indent);
+      emitLine("<hr>");
+      emitIndent(indent);
+      emitLine("<h2>References</h2>");
+      for (const child of block.children) {
+        if (child.tag === NodeTag.biblio_entry) renderBiblioEntry(child.data);
+      }
+      return;
+    }
+
+    if (name === "equation") {
+      let mathText = "";
+      for (const c of block.inline_content) {
+        if (c.tag === NodeTag.text) mathText += c.data.value;
+      }
+      for (const c of block.children) {
+        if (c.tag === NodeTag.text) mathText += c.data.value;
+      }
+      emitIndent(indent);
+      out.push(`<div class="math-display">\\[${escape(mathText)}\\]</div>`);
+      emitLine("");
+      return;
+    }
+
+    if (name === "img" || name === "image") {
+      const src = block.attrs.src || "";
+      const alt = block.attrs.alt || "image";
+      emitIndent(indent);
+      out.push(`<img src="${escape(src)}" alt="${escape(alt)}">`);
+      emitLine("");
+      return;
+    }
+
+    // fallback: generic block
+    emitIndent(indent);
+    out.push(`<div class="nova-${name}">`);
+    emitLine("");
+    for (const child of block.children) renderNode(child, indent + 1);
+    emitIndent(indent);
+    emitLine("</div>");
+  }
+
+  function renderInline(inl) {
+    const name = inl.name;
+    const content = renderInlineListText(inl.content);
+    const attrs = inl.attrs;
+
+    switch (name) {
+      case "em":
+        return `<em>${content}</em>`;
+      case "strong":
+        return `<strong>${content}</strong>`;
+      case "code":
+        return `<code>${content}</code>`;
+      case "a": {
+        const href = attrs.href || "";
+        return `<a href="${escape(href)}">${content}</a>`;
+      }
+      case "ref": {
+        const key = attrs.key || attrs.id || "";
+        return `<span class="nova-ref">[${escape(key)}]</span>`;
+      }
+      case "cite": {
+        const key = attrs.key || "";
+        return `<span class="nova-cite">[${escape(key)}]</span>`;
+      }
+      case "label": {
+        const key = attrs.id || attrs.key || "";
+        return `<span id="${escape(key)}" class="nova-label"></span>`;
+      }
+      default:
+        if (content) {
+          return `<span class="${escape(name)}">${content}</span>`;
+        }
+        return "";
+    }
+  }
+
+  function renderInlineList(nodes) {
+    for (const node of nodes) {
+      switch (node.tag) {
+        case NodeTag.text:
+          out.push(escape(node.data.value));
+          break;
+        case NodeTag.inline_block:
+          out.push(renderInline(node.data));
+          break;
+        case NodeTag.math_inline:
+          out.push(`<span class="math">\\(${escape(node.data.source)}\\)</span>`);
+          break;
+        case NodeTag.math_display:
+          out.push(`<div class="math-display">\\[${escape(node.data.source)}\\]</div>`);
+          break;
+        case NodeTag.interpolation:
+          out.push(escape(node.data.expression));
+          break;
+      }
+    }
+  }
+
+  function renderInlineListText(nodes) {
+    let buf = "";
+    for (const node of nodes) {
+      switch (node.tag) {
+        case NodeTag.text:
+          buf += escape(node.data.value);
+          break;
+        case NodeTag.inline_block:
+          buf += renderInline(node.data);
+          break;
+        case NodeTag.math_inline:
+          buf += `<span class="math">\\(${escape(node.data.source)}\\)</span>`;
+          break;
+        case NodeTag.interpolation:
+          buf += `<code>#{${escape(node.data.expression)}}</code>`;
+          break;
+      }
+    }
+    return buf;
+  }
+
+  function renderChildrenInline(children) {
+    for (const child of children) {
+      if (child.tag === NodeTag.text) out.push(escape(child.data.value));
+    }
+  }
+
+  function collectText(nodes) {
+    let buf = "";
+    for (const node of nodes) {
+      switch (node.tag) {
+        case NodeTag.text:
+          buf += node.data.value;
+          break;
+        case NodeTag.inline_block:
+          buf += collectText(node.data.content);
+          break;
+      }
+    }
+    return buf;
+  }
+
+  function renderList(list, indent) {
+    const tag = list.ordered ? "ol" : "ul";
+    emitIndent(indent);
+    out.push(`<${tag}>`);
+    emitLine("");
+    for (const item of list.items) {
+      emitIndent(indent + 1);
+      emitLine("<li>");
+      if (item.tag === NodeTag.block) {
+        for (const child of item.data.children) renderNode(child, indent + 2);
+        renderInlineList(item.data.inline_content);
+      } else {
+        renderNode(item, indent + 2);
+      }
+      emitIndent(indent + 1);
+      emitLine("</li>");
+    }
+    emitIndent(indent);
+    out.push(`</${tag}>`);
+    emitLine("");
+  }
+
+  function renderTable(table, indent) {
+    if (table.caption) {
+      emitIndent(indent);
+      out.push(`<p><strong>${escape(table.caption)}</strong></p>`);
+      emitLine("");
+    }
+    emitIndent(indent);
+    emitLine("<table>");
+
+    if (table.headers) {
+      emitIndent(indent + 1);
+      emitLine("<thead>");
+      emitIndent(indent + 2);
+      emitLine("<tr>");
+      for (const h of table.headers) {
+        out.push(`<th>${escape(h)}</th>`);
+      }
+      emitLine("");
+      emitIndent(indent + 2);
+      emitLine("</tr>");
+      emitIndent(indent + 1);
+      emitLine("</thead>");
+    }
+
+    if (table.rows && table.rows.length > 0) {
+      emitIndent(indent + 1);
+      emitLine("<tbody>");
+      for (const row of table.rows) {
+        emitIndent(indent + 2);
+        emitLine("<tr>");
+        for (const cell of row) {
+          out.push(`<td>${escape(cell)}</td>`);
+        }
+        emitLine("");
+        emitIndent(indent + 2);
+        emitLine("</tr>");
+      }
+      emitIndent(indent + 1);
+      emitLine("</tbody>");
+    }
+
+    if (table.data) {
+      emitIndent(indent + 1);
+      emitLine("<tbody>");
+      for (const row of table.data) {
+        emitIndent(indent + 2);
+        emitLine("<tr>");
+        for (const cell of row) {
+          out.push(`<td>${escape(cell)}</td>`);
+        }
+        emitLine("");
+        emitIndent(indent + 2);
+        emitLine("</tr>");
+      }
+      emitIndent(indent + 1);
+      emitLine("</tbody>");
+    }
+
+    emitIndent(indent);
+    emitLine("</table>");
+  }
+
+  function renderSchema(schema) {
+    emitLine('<div class="nova-schema">');
+    out.push(`<strong>schema</strong> ${escape(schema.name)} {`);
+    emitLine("");
+    for (const field of schema.fields) {
+      out.push(`  <span class="nova-field">${escape(field.name)}: <span class="nova-type">${escape(field.type_name)}`);
+      if (field.optional) out.push("?");
+      out.push("</span>");
+      if (field.tag > 0) out.push(` <span class="nova-tag">@${field.tag}</span>`);
+      if (field.default != null) out.push(` = ${escape(field.default)}`);
+      emitLine("</span>");
+    }
+    emitLine("}");
+    emitLine("</div>");
+  }
+
+  function renderService(service) {
+    emitLine('<div class="nova-service">');
+    out.push(`<strong>service</strong> ${escape(service.name)} {`);
+    emitLine("");
+    for (const method of service.methods) {
+      out.push(`  <span class="nova-method">${escape(method.name)}(`);
+      for (let i = 0; i < method.params.length; i++) {
+        if (i > 0) out.push(", ");
+        out.push(`${escape(method.params[i].name)}: ${escape(method.params[i].type_name)}`);
+      }
+      out.push(")");
+      if (method.returns) out.push(` \u2192 ${escape(method.returns)}`);
+      emitLine("</span>");
+    }
+    emitLine("}");
+    emitLine("</div>");
+  }
+
+  function renderBiblioEntry(entry) {
+    const author = entry.attrs.author || "";
+    const title = entry.attrs.title || "";
+    const year = entry.attrs.year || "";
+    out.push(`<p id="bib-${escape(entry.key)}">[${escape(entry.key)}] ${escape(author)}, <em>${escape(title)}</em>, ${escape(year)}.</p>`);
+    emitLine("");
+  }
+
+  // Main render function body
+  emit('<!DOCTYPE html>');
+  emit('<html lang="en">');
+  emit("<head>");
+  emit('<meta charset="UTF-8">');
+  emit('<meta name="viewport" content="width=device-width, initial-scale=1.0">');
+
+  let title = "Nova Document";
+  if (doc.tag === NodeTag.document) {
+    if (doc.data.meta.title) title = doc.data.meta.title;
+  }
+  emitLine("<title>");
+  out.push(escape(title));
+  emitLine("</title>");
+
+  emit("<style>");
+  out.push(DEFAULT_STYLES);
+  emit("</style>");
+  out.push(MATHJAX_SCRIPT);
+  emit("</head>");
+  emit("<body>");
+  emitLine('<div class="nova-document">');
+
+  if (doc.tag === NodeTag.document) {
+    const meta = doc.data.meta;
+    if (Object.keys(meta).length > 0) {
+      emitIndent(1);
+      emitLine('<div class="nova-meta">');
+      for (const [k, v] of Object.entries(meta)) {
+        emitIndent(2);
+        out.push(`<span class="nova-meta-key">${escape(k)}</span>: <span class="nova-meta-val">${escape(v)}</span>`);
+        emitLine("");
+      }
+      emitIndent(1);
+      emitLine("</div>");
+    }
+    for (const child of doc.data.children) {
+      renderNode(child, 1);
+    }
+  }
+
+  emitLine("</div>");
+  emit("</body>");
+  emit("</html>");
+
+  return out.join("");
+}
+
+module.exports = { render };

package/lib/types.js

@@ -0,0 +1,73 @@
+const TokenType = Object.freeze({
+  command: "command",
+  ident: "ident",
+  lparen: "lparen",
+  rparen: "rparen",
+  lbrace: "lbrace",
+  rbrace: "rbrace",
+  lbracket: "lbracket",
+  rbracket: "rbracket",
+  colon: "colon",
+  comma: "comma",
+  dash: "dash",
+  star: "star",
+  plus: "plus",
+  pipe: "pipe",
+  string: "string",
+  number: "number",
+  bool: "bool",
+  null: "null",
+  text: "text",
+  indent: "indent",
+  dedent: "dedent",
+  newline: "newline",
+  math_inline: "math_inline",
+  math_display: "math_display",
+  interp_start: "interp_start",
+  interp_end: "interp_end",
+  at: "at",
+  equals: "equals",
+  dot: "dot",
+  hash: "hash",
+  question: "question",
+  lt: "lt",
+  gt: "gt",
+  eof: "eof",
+});
+
+class Token {
+  constructor(type, value = "", line = 0, col = 0) {
+    this.type = type;
+    this.value = value;
+    this.line = line;
+    this.col = col;
+  }
+}
+
+const NodeTag = Object.freeze({
+  document: "document",
+  text: "text",
+  math_inline: "math_inline",
+  math_display: "math_display",
+  interpolation: "interpolation",
+  block: "block",
+  inline_block: "inline_block",
+  list_block: "list_block",
+  table_block: "table_block",
+  macro_def: "macro_def",
+  field_def: "field_def",
+  schema_def: "schema_def",
+  method_def: "method_def",
+  service_def: "service_def",
+  biblio_entry: "biblio_entry",
+  if_block: "if_block",
+  for_block: "for_block",
+  use_block: "use_block",
+  meta_block: "meta_block",
+});
+
+function makeNode(tag, data) {
+  return { tag, data };
+}
+
+module.exports = { TokenType, Token, NodeTag, makeNode };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nova-lang/cli",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Nova: Nested Ordered Versatile Architecture — a programmable markup language CLI",
   "license": "MIT",
   "keywords": [
@@ -15,21 +15,13 @@
     "nova": "bin/nova.js"
   },
   "scripts": {
-    "postinstall": "node install.js",
-    "build": "zig build",
-    "build-release": "zig build -Doptimize=ReleaseSafe",
-    "clean": "rm -rf zig-out zig-cache .zig-cache",
-    "test": "nova lex examples/basics.nv && nova ast examples/basics.nv"
+    "test": "node bin/nova.js lex examples/math.nv && node bin/nova.js ast examples/math.nv && node bin/nova.js examples/math.nv > /dev/null"
   },
   "files": [
     "bin/",
-    "install.js",
-    "build.zig",
-    "src/"
+    "lib/"
   ],
   "engines": {
     "node": ">=16"
-  },
-  "os": ["darwin", "linux", "win32"],
-  "cpu": ["x64", "arm64"]
+  }
 }

package/build.zig

@@ -1,25 +0,0 @@
-const std = @import("std");
-
-pub fn build(b: *std.Build) void {
-    const target = b.standardTargetOptions(.{});
-    const optimize = b.standardOptimizeOption(.{});
-
-    const exe_mod = b.createModule(.{
-        .root_source_file = b.path("src/main.zig"),
-        .target = target,
-        .optimize = optimize,
-    });
-
-    const exe = b.addExecutable(.{
-        .name = "nova",
-        .root_module = exe_mod,
-    });
-
-    b.installArtifact(exe);
-
-    const run_cmd = b.addRunArtifact(exe);
-    run_cmd.step.dependOn(b.getInstallStep());
-
-    const run_step = b.step("run", "Run Nova");
-    run_step.dependOn(&run_cmd.step);
-}