@nova-lang/cli 0.1.1 → 0.2.0

package/bin/nova.js

@@ -1,49 +1,5 @@
 #!/usr/bin/env node
 "use strict";
 
-const { spawnSync } = require("child_process");
-const path = require("path");
-const fs = require("fs");
-
-function findBinary() {
-  const binName = process.platform === "win32" ? "nova.exe" : "nova";
-
-  const candidates = [
-    path.join(__dirname, "..", "zig-out", "bin", binName),
-    path.join(__dirname, "..", "bin", binName),
-  ];
-
-  if (process.env.NOVA_BINARY) {
-    candidates.unshift(process.env.NOVA_BINARY);
-  }
-
-  for (const p of candidates) {
-    try {
-      if (fs.statSync(p).isFile()) {
-        return p;
-      }
-    } catch {}
-  }
-
-  return null;
-}
-
-function main() {
-  const binary = findBinary();
-  if (!binary) {
-    console.error(
-      "Nova Zig binary not found.\n" +
-        "  Build with: npm run build  (requires Zig compiler)\n" +
-        "  Or set:     NOVA_BINARY=/path/to/nova\n"
-    );
-    process.exit(1);
-  }
-
-  const result = spawnSync(binary, process.argv.slice(2), {
-    stdio: "inherit",
-  });
-
-  process.exit(result.status ?? 1);
-}
-
-main();
+const cli = require("../lib/cli");
+cli.run(process.argv);

package/lib/cli.js

@@ -0,0 +1,203 @@
+const fs = require("fs");
+const path = require("path");
+const { tokenize } = require("./lexer");
+const { parse } = require("./parser");
+const { interpret } = require("./interpreter");
+const { render } = require("./renderer");
+
+function formatTokens(tokens) {
+  const lines = [];
+  for (const tok of tokens) {
+    lines.push(`${tok.type}${tok.value ? " " + JSON.stringify(tok.value) : ""}`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+function formatAST(node, indent = 0) {
+  const pad = "  ".repeat(indent);
+  const tag = node.tag;
+  const data = node.data;
+  let result = pad + tag;
+
+  switch (tag) {
+    case "document":
+      result += ` (meta: ${JSON.stringify(data.meta)})`;
+      result += "\n";
+      for (const child of data.children) {
+        result += formatAST(child, indent + 1);
+      }
+      break;
+    case "text":
+      result += ` ${JSON.stringify(data.value)}`;
+      result += "\n";
+      break;
+    case "math_inline":
+      result += ` ${JSON.stringify(data.source)}`;
+      result += "\n";
+      break;
+    case "math_display":
+      result += ` ${JSON.stringify(data.source)}`;
+      result += "\n";
+      break;
+    case "interpolation":
+      result += ` ${JSON.stringify(data.expression)}`;
+      result += "\n";
+      break;
+    case "block":
+      result += ` @${data.name}`;
+      if (Object.keys(data.attrs).length > 0) {
+        result += ` attrs=${JSON.stringify(data.attrs)}`;
+      }
+      if (data.inline_content && data.inline_content.length > 0) {
+        result += "\n" + pad + "  inline:";
+        for (const c of data.inline_content) {
+          result += "\n" + formatAST(c, indent + 2).trimEnd();
+        }
+      }
+      result += "\n";
+      for (const child of data.children) {
+        result += formatAST(child, indent + 1);
+      }
+      break;
+    case "inline_block":
+      result += ` @${data.name}`;
+      if (Object.keys(data.attrs).length > 0) {
+        result += ` attrs=${JSON.stringify(data.attrs)}`;
+      }
+      if (data.content && data.content.length > 0) {
+        result += "\n" + pad + "  content:";
+        for (const c of data.content) {
+          result += "\n" + formatAST(c, indent + 2).trimEnd();
+        }
+      }
+      result += "\n";
+      break;
+    case "list_block":
+      result += ` ordered=${data.ordered}`;
+      result += "\n";
+      for (const item of data.items) {
+        result += pad + "  - item:\n";
+        result += formatAST(item, indent + 3);
+      }
+      break;
+    case "table_block":
+      result += "\n";
+      if (data.caption) result += pad + "  caption: " + JSON.stringify(data.caption) + "\n";
+      if (data.headers) result += pad + "  headers: " + JSON.stringify(data.headers) + "\n";
+      if (data.rows && data.rows.length > 0) {
+        for (const row of data.rows) {
+          result += pad + "  row: " + JSON.stringify(row) + "\n";
+        }
+      }
+      if (data.data && data.data.length > 0) {
+        result += pad + "  data: " + JSON.stringify(data.data) + "\n";
+      }
+      break;
+    case "macro_def":
+      result += ` name=${data.name}`;
+      result += ` params=${JSON.stringify(data.params)}`;
+      result += ` kwargs=${JSON.stringify(data.kwargs)}`;
+      result += ` hasBlockParam=${data.hasBlockParam}`;
+      result += ` blockParamName=${data.blockParamName}`;
+      result += ` body_len=${data.body.length}`;
+      result += "\n";
+      break;
+    case "schema_def":
+      result += ` name=${data.name}`;
+      result += "\n";
+      for (const f of data.fields) {
+        result += pad + "  field: " + JSON.stringify(f) + "\n";
+      }
+      break;
+    case "service_def":
+      result += ` name=${data.name}`;
+      result += "\n";
+      for (const m of data.methods) {
+        result += pad + "  method: " + JSON.stringify(m) + "\n";
+      }
+      break;
+    case "biblio_entry":
+      result += ` key=${data.key}`;
+      result += "\n";
+      break;
+    case "if_block":
+      result += ` condition=${JSON.stringify(data.condition)}`;
+      result += "\n";
+      result += pad + "  then:\n";
+      for (const c of data.then_body) {
+        result += formatAST(c, indent + 2);
+      }
+      if (data.else_body && data.else_body.length > 0) {
+        result += pad + "  else:\n";
+        for (const c of data.else_body) {
+          result += formatAST(c, indent + 2);
+        }
+      }
+      break;
+    case "for_block":
+      result += ` var=${data.var_name} iterable=${data.iterable}`;
+      result += "\n";
+      result += pad + "  body:\n";
+      for (const c of data.body) {
+        result += formatAST(c, indent + 2);
+      }
+      break;
+    case "meta_block":
+      result += ` ${JSON.stringify(data.pairs)}`;
+      result += "\n";
+      break;
+    case "use_block":
+      result += ` path=${data.path}`;
+      result += "\n";
+      break;
+    default:
+      result += ` ${JSON.stringify(data)}`;
+      result += "\n";
+  }
+
+  return result;
+}
+
+function run(argv) {
+  const args = argv.slice(2);
+  const command = args[0];
+
+  if (command === "lex") {
+    const filePath = args[1];
+    if (!filePath) {
+      console.error("Usage: nova lex <file>");
+      process.exit(1);
+    }
+    const source = fs.readFileSync(path.resolve(filePath), "utf-8");
+    const tokens = tokenize(source);
+    process.stdout.write(formatTokens(tokens));
+    return;
+  }
+
+  if (command === "ast") {
+    const filePath = args[1];
+    if (!filePath) {
+      console.error("Usage: nova ast <file>");
+      process.exit(1);
+    }
+    const source = fs.readFileSync(path.resolve(filePath), "utf-8");
+    const tokens = tokenize(source);
+    const ast = parse(tokens);
+    process.stdout.write(formatAST(ast));
+    return;
+  }
+
+  const filePath = command;
+  if (!filePath) {
+    console.error("Usage: nova [lex|ast] <file>");
+    process.exit(1);
+  }
+  const source = fs.readFileSync(path.resolve(filePath), "utf-8");
+  const tokens = tokenize(source);
+  const ast = parse(tokens);
+  const doc = interpret(ast);
+  const html = render(doc);
+  process.stdout.write(html);
+}
+
+module.exports = { run, formatAST, formatTokens };

package/lib/interpreter.js

@@ -0,0 +1,274 @@
+const { NodeTag, makeNode } = require("./types");
+
+class Env {
+  constructor(parent) {
+    this.vars = {};
+    this.macros = {};
+    this.parent = parent || null;
+  }
+
+  get(name) {
+    if (name in this.vars) return this.vars[name];
+    if (this.parent) return this.parent.get(name);
+    return null;
+  }
+
+  set(name, value) {
+    this.vars[name] = value;
+  }
+
+  defMacro(name, macro) {
+    if (this.parent) {
+      this.parent.defMacro(name, macro);
+    } else {
+      this.macros[name] = macro;
+    }
+  }
+
+  lookupMacro(name) {
+    if (name in this.macros) return this.macros[name];
+    if (this.parent) return this.parent.lookupMacro(name);
+    return null;
+  }
+
+  clone() {
+    const e = new Env(this);
+    return e;
+  }
+}
+
+class Interpreter {
+  constructor() {
+    this.globalEnv = new Env();
+  }
+
+  evalDocument(doc) {
+    const children = [];
+    for (const child of doc.data.children) {
+      const result = this.evalNode(child, this.globalEnv);
+      if (result != null) children.push(result);
+    }
+    doc.data.children = children;
+    return doc;
+  }
+
+  evalNode(node, env) {
+    switch (node.tag) {
+      case NodeTag.document:
+        return this.evalDocument(node);
+      case NodeTag.block:
+        return this.evalBlock(node.data, env);
+      case NodeTag.inline_block:
+        return this.evalInline(node.data, env);
+      case NodeTag.text:
+        return this.evalText(node.data, env);
+      case NodeTag.interpolation:
+        return this.evalInterpolation(node.data, env);
+      case NodeTag.math_inline:
+      case NodeTag.math_display:
+        return node;
+      case NodeTag.list_block:
+        return this.evalList(node.data, env);
+      case NodeTag.table_block:
+        return node;
+      case NodeTag.macro_def:
+        env.defMacro(node.data.name, node.data);
+        return null;
+      case NodeTag.schema_def:
+      case NodeTag.service_def:
+        return node;
+      case NodeTag.if_block:
+        return this.evalIf(node.data, env);
+      case NodeTag.for_block:
+        return this.evalFor(node.data, env);
+      case NodeTag.use_block:
+        console.warn(`Warning: @use "${node.data.path}" is not yet supported (module system not implemented)`);
+        return null;
+      case NodeTag.meta_block:
+        return node;
+      default:
+        return node;
+    }
+  }
+
+  evalBlock(block, env) {
+    if (!block.name || block.name.length === 0) {
+      block.children = this.evalChildren(block.children, env);
+      return makeNode(NodeTag.block, { ...block });
+    }
+    const macro = env.lookupMacro(block.name);
+    if (macro) {
+      return this.expandMacro(macro, block, env);
+    }
+    block.children = this.evalChildren(block.children, env);
+    block.inline_content = this.evalInlineList(block.inline_content, env);
+    return makeNode(NodeTag.block, { ...block });
+  }
+
+  evalInline(inl, env) {
+    inl.content = this.evalInlineList(inl.content, env);
+    return makeNode(NodeTag.inline_block, { ...inl });
+  }
+
+  evalText(_text, _env) {
+    return makeNode(NodeTag.text, { ..._text });
+  }
+
+  evalInterpolation(interp, _env) {
+    return makeNode(NodeTag.text, { value: interp.expression });
+  }
+
+  evalChildren(children, env) {
+    const result = [];
+    for (const child of children) {
+      const evaled = this.evalNode(child, env);
+      if (evaled != null) result.push(evaled);
+    }
+    return result;
+  }
+
+  evalInlineList(nodes, env) {
+    const result = [];
+    for (const node of nodes) {
+      const evaled = this.evalNode(node, env);
+      if (evaled != null) result.push(evaled);
+    }
+    return result;
+  }
+
+  evalList(list, env) {
+    const newItems = [];
+    for (const item of list.items) {
+      if (item.tag === NodeTag.block) {
+        const blk = { ...item.data };
+        blk.children = this.evalChildren(blk.children, env);
+        newItems.push(makeNode(NodeTag.block, blk));
+      } else {
+        newItems.push(item);
+      }
+    }
+    list.items = newItems;
+    return makeNode(NodeTag.list_block, { ...list });
+  }
+
+  evalIf(ifblk, env) {
+    const cond = this.evaluateCondition(ifblk.condition, env);
+    const result = cond
+      ? this.evalChildren(ifblk.then_body, env)
+      : this.evalChildren(ifblk.else_body, env);
+    if (result.length === 1) return result[0];
+    return makeNode(NodeTag.document, {
+      children: result,
+      meta: {},
+    });
+  }
+
+  evalFor(forblk, env) {
+    const childEnv = env.clone();
+    const resultNodes = [];
+
+    const iterableVal = env.get(forblk.iterable) || forblk.iterable;
+    const items = [];
+
+    if (iterableVal === "true" || iterableVal === "false" || iterableVal === "null") {
+    } else if (/^-?\d/.test(iterableVal)) {
+      const count = parseInt(iterableVal, 10) || 1;
+      for (let i = 0; i < count; i++) {
+        items.push(String(i));
+      }
+    } else {
+      const parts = iterableVal.split(",");
+      for (const part of parts) {
+        const trimmed = part.trim();
+        if (trimmed.length > 0) items.push(trimmed);
+      }
+    }
+
+    for (const itemVal of items) {
+      childEnv.set(forblk.var_name, itemVal);
+      const evaled = this.evalChildren(forblk.body, childEnv);
+      for (const n of evaled) resultNodes.push(n);
+    }
+
+    return makeNode(NodeTag.document, {
+      children: resultNodes,
+      meta: {},
+    });
+  }
+
+  evaluateCondition(condition, env) {
+    if (!condition || condition.length === 0) return true;
+    const trimmed = condition.trim();
+    if (trimmed === "true") return true;
+    if (trimmed === "false") return false;
+    if (trimmed === "null") return false;
+    if (trimmed.startsWith("@defined(")) {
+      const inner = trimmed.slice("@defined(".length, -1).trim();
+      return env.get(inner) != null;
+    }
+    if (trimmed.startsWith("!")) {
+      const rest = trimmed.slice(1).trim();
+      return !this.evaluateCondition(rest, env);
+    }
+    const val = env.get(trimmed);
+    if (val != null) {
+      return !(val.length === 0 || val === "false" || val === "null");
+    }
+    const num = parseInt(trimmed, 10);
+    if (!isNaN(num)) return num !== 0;
+    return condition.length > 0;
+  }
+
+  expandMacro(macro, call, env) {
+    const childEnv = env.clone();
+
+    let argIdx = 0;
+    for (const paramName of macro.params) {
+      let paramVal = "";
+      if (argIdx < call.inline_content.length) {
+        const argNode = call.inline_content[argIdx];
+        if (argNode.tag === NodeTag.text) {
+          paramVal = argNode.data.value;
+        }
+      }
+      childEnv.set(paramName, paramVal);
+      argIdx++;
+    }
+
+    for (const [kwName, defaultVal] of Object.entries(macro.kwargs)) {
+      const callVal = call.attrs[kwName] || defaultVal;
+      childEnv.set(kwName, callVal);
+    }
+
+    const evaledBody = [];
+    for (const bodyNode of macro.body) {
+      if (
+        bodyNode.tag === NodeTag.block &&
+        bodyNode.data.name === macro.blockParamName &&
+        macro.hasBlockParam
+      ) {
+        for (const callChild of call.children) {
+          const evaled = this.evalNode(callChild, childEnv);
+          if (evaled != null) evaledBody.push(evaled);
+        }
+      } else {
+        const evaled = this.evalNode(bodyNode, childEnv);
+        if (evaled != null) evaledBody.push(evaled);
+      }
+    }
+
+    return makeNode(NodeTag.block, {
+      name: macro.name,
+      attrs: {},
+      inline_content: [],
+      children: evaledBody,
+    });
+  }
+}
+
+function interpret(doc) {
+  const interp = new Interpreter();
+  return interp.evalDocument(doc);
+}
+
+module.exports = { Interpreter, Env, interpret };