novac 1.0.0

package/bin/nv+

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+const { Command } = require('commander');
+const chalk = require('chalk').default;
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+let registery = '@nvplus/'
+
+const program = new Command();
+
+program
+  .name('nv+')
+  .description('Nova package manager')
+  .version('1.0.0');
+
+function publishPackage(tag) {
+  try {
+    console.log(chalk.cyanBright('📦 Preparing to publish Nova package...'));
+
+    const pkgPath = fs.existsSync('package.json')
+      ? 'package.json'
+      : fs.existsSync('nova.json')
+      ? 'nova.json'
+      : null;
+
+    if (!pkgPath) {
+      console.log(chalk.red('No package.json or nova.json found in this directory.'));
+      process.exit(1);
+    }
+
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const name = pkg.name || path.basename(process.cwd());
+
+    if (!name.startsWith(registery)) {
+      pkg.name = `${registery}${name}`;
+      fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+    }
+
+    console.log(chalk.green(`🚀 Publishing ${name}@${pkg.version || '0.0.1'} ...`));
+    execSync(`npm publish --access public --tag ${tag}`, { stdio: 'inherit' });
+
+    console.log(chalk.greenBright('✅ Published successfully!'));
+  } catch (err) {
+    console.error(chalk.red('❌ Publish failed:\n'), err.message);
+  }
+}
+
+function installPackage(pkg, globalInstall = false) {
+  try {
+    let scoped = pkg.startsWith(registery) ? pkg : `${registery}${pkg}`;
+    console.log(chalk.cyan(`⬇️ Installing ${pkg} ...`));
+
+    const cmd = globalInstall
+      ? `npm install -g ${scoped}`
+      : `npm install ${scoped}`;
+    execSync(cmd, { stdio: 'inherit' });
+
+    console.log(chalk.greenBright(`✅ Installed ${pkg} successfully!`));
+  } catch (err) {
+    console.error(chalk.red('❌ Installation failed:\n'), err.message);
+  }
+}
+
+// ---- Commands ----
+
+program
+  .command('publish')
+  .description('Publish current Nova package')
+  .option('-t, --tag <tag>', 'Optional release tag', 'latest')
+  .action((opts) => publishPackage(opts.tag));
+
+program
+  .command('install <pkg>')
+  .description('Install a Nova package')
+  .option('-g, --global', 'Install globally', false)
+  .action((pkg, opts) => installPackage(pkg, opts.global));
+
+// Parse args (Commander auto-handles --help and --version)
+program.parse(process.argv);
+
+// If no subcommand is passed, show help
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/cli.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+/**
+ * Nova CLI — built by Wix ⚙️
+ * Provides both REPL and file execution support.
+ */
+
+const { Command } = require("commander");
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+
+// Core modules
+const { Parser } = require("./src/core/parser.js");
+const { Executor } = require("./src/core/executor.js");
+let StdLib = require('./src/runtime/stdlib.js');
+const BStd = require('./src/core/bstd.js');
+StdLib = { ...StdLib, ...BStd };
+
+// ──────────────────────────────────────────────────────────────
+// Utility helpers
+// ──────────────────────────────────────────────────────────────
+function runCode(source, filename = "<repl>") {
+  const parser = new Parser(source);
+  const ast = parser.parse();
+
+  const executor = new Executor(source, StdLib);
+  return executor.run(ast);
+}
+
+async function startRepl() {
+  console.log("Nova REPL — type 'exit' or Ctrl+C to quit\n");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: "nova> ",
+  });
+
+  rl.prompt();
+  for await (const line of rl) {
+    const input = line.trim();
+    if (input === ".exit" || input === ".quit") break;
+    if (!input) {
+      rl.prompt();
+      continue;
+    }
+
+    try {
+      const executor = new Executor(line, StdLib);
+      const parser = new Parser(input);
+      const ast = parser.parse();
+      const result = executor.run(ast);
+      if (result !== undefined) console.log(executor.stringify(result));
+    } catch (err) {
+      console.error('Error: ', err);
+    }
+
+    rl.prompt();
+  }
+
+  rl.close();
+}
+
+// ──────────────────────────────────────────────────────────────
+// CLI definition
+// ──────────────────────────────────────────────────────────────
+const program = new Command();
+
+program
+  .name("nova")
+  .description("The Nova language CLI — run, build, and explore your code.")
+  .version("1.0.0");
+
+program
+  .argument("[file]", "Nova source file to execute")
+  .option("-r, --repl", "Start interactive REPL mode")
+  .action(async (file, options) => {
+    if (options.repl || !file) {
+      await startRepl();
+      return;
+    }
+
+    const filepath = path.resolve(process.cwd(), file);
+    if (!fs.existsSync(filepath)) {
+      console.error(`Error: file not found: ${filepath}`);
+      process.exit(1);
+    }
+
+    const source = fs.readFileSync(filepath, "utf8");
+    try {
+      runCode(source, filepath);
+    } catch (err) {
+      console.error(`RuntimeError: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "novac",
+  "version": "1.0.0",
+  "description": "a rewrite version of my package nvlang",
+  "license": "MIT",
+  "author": "purcwix",
+  "type": "commonjs",
+  "main": "cli.js",
+  "bin": {
+    "nv+": "bin/nv+"
+  },
+  "directories": {
+    "example": "examples",
+    "test": "tests"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.1"
+  },
+  "devDependencies": {}
+}

package/scripts/update-bin.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+
+const pkgPath = path.join(__dirname, '..', 'package.json');
+const binDir = path.join(__dirname, '..', 'bin');
+
+const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+pkg.bin = pkg.bin || {};
+
+if (fs.existsSync(binDir)) {
+  const files = fs.readdirSync(binDir);
+  for (const file of files) {
+    const fullPath = `./bin/${file}`;
+    const name = path.parse(file).name;
+    pkg.bin[name] = fullPath;
+  }
+}
+
+// sort keys (optional, just for tidiness)
+pkg.bin = Object.fromEntries(Object.entries(pkg.bin).sort(([a], [b]) => a.localeCompare(b)));
+
+fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+console.log('✅ package.json bin field updated automatically.');

package/src/core/bstd.js

@@ -0,0 +1,14 @@
+const fs = require('fs');
+const path = require('path');
+
+let Air = {};
+
+// read all .js files in the current directory
+fs.readdirSync(__dirname)
+  .filter(file => file !== 'bstd.js' && file.endsWith('.js'))
+  .forEach(file => {
+    const name = path.basename(file, '.js');
+    Air[name] = require(path.join(__dirname, file));
+  });
+
+module.exports = { Air };

package/src/core/describe.js

@@ -0,0 +1,187 @@
+/**
+ * describe.js
+ * Converts Nova Air AST into natural-language explanations.
+ * Style: clear, rhythmic, and human — with natural punctuation.
+ */
+
+function describe(node, depth = 0) {
+  const indent = "  ".repeat(depth);
+  if (!node) return "";
+  if (Array.isArray(node))
+    return node.map(n => describe(n, depth)).join("\n");
+
+  switch (node.kind) {
+    // ─────────── ROOT ───────────
+    case "program":
+      return node.nodes.map(n => describe(n, depth)).join("\n");
+
+    // ─────────── DECLARATION ───────────
+    case "declare": {
+      const kind = node.isConst ? "constant" : "variable";
+      const pointer = node.isPointer ? "pointer to " : "";
+      if (node.destructure)
+        return `${indent}Create a ${kind} pattern: unpack into { ${node.destructure.props
+          .map(p => p.alias)
+          .join(", ")} }${node.value ? `, using ${describe(node.value)}` : ""}.`;
+      if (node.value)
+        return `${indent}Declare ${kind}: ${pointer}${node.name}, and set it to ${describe(node.value)}.`;
+      return `${indent}Declare ${kind}: ${pointer}${node.name}.`;
+    }
+
+    // ─────────── ASSIGNMENT ───────────
+    case "assign":
+      return `${indent}Set ${describe(node.name)} to ${describe(node.value)}.`;
+
+    // ─────────── REFERENCES ───────────
+    case "ref":
+      return node.name;
+
+    // ─────────── VALUES ───────────
+    case "value":
+      return JSON.stringify(node.value);
+
+    // ─────────── FUNCTIONS ───────────
+    case "function": {
+      const args = node.args.length
+        ? node.args.map(a => describe(a)).join(", ")
+        : "no arguments";
+      return `${indent}${node.isAsync ? "Async " : ""}function '${node.name}': takes (${args}), and ${summarizeBody(node.body)}.`;
+    }
+
+    case "arrowfunc": {
+      const args = node.args.length
+        ? node.args.map(a => describe(a)).join(", ")
+        : "no arguments";
+      return `${indent}Arrow function: takes (${args}), and ${summarizeBody(node.body)}.`;
+    }
+
+    // ─────────── RETURN ───────────
+    case "return":
+      return `${indent}Return ${node.value ? describe(node.value) : "nothing"}${node.terminate ? ", immediately" : ""}.`;
+
+    // ─────────── CLASS ───────────
+    case "class":
+      return `${indent}Define a class '${node.name}'${node.superClass ? `, extending ${describe(node.superClass)}` : ""}: \n${node.members
+        .map(m => describe(m, depth + 1))
+        .join("\n")}`;
+
+    // ─────────── BRANCHING ───────────
+    case "branch": {
+      const base = `${indent}${capitalize(node.type)} statement: ${
+        node.args ? `when (${describe(node.args)})` : ""
+      }, then:\n${describe(node.body, depth + 1)}`;
+      const next = node.next
+        ? `\n${indent}else:\n${describe(node.next.body, depth + 1)}`
+        : "";
+      return base + next;
+    }
+
+    // ─────────── LOOPS ───────────
+    case "while":
+    case "repeat":
+    case "for":
+    case "do":
+    case "until":
+      return `${indent}${capitalize(node.kind)} loop: ${
+        node.args ? `condition is ${describe(node.args)},` : ""
+      } running:\n${describe(node.body, depth + 1)}`;
+
+    // ─────────── CALLS ───────────
+    case "call": {
+      const name = typeof node.name === "string" ? node.name : describe(node.name);
+      const args = node.args.length
+        ? `, with arguments: ${node.args.map(a => describe(a)).join(", ")}`
+        : "";
+      return `${indent}Call ${name}${args}.`;
+    }
+
+    // ─────────── PROPERTY ACCESS ───────────
+    case "prop":
+      return `${describe(node.object)}.${node.name}`;
+
+    // ─────────── INDEX ACCESS ───────────
+    case "subscript":
+      return `${describe(node.object)}[${describe(node.index)}]`;
+
+    // ─────────── ASYNC / AWAIT ───────────
+    case "await":
+      return `${indent}Await: wait for ${describe(node.operand)} to complete.`;
+
+    // ─────────── ERROR HANDLING ───────────
+    case "throw":
+      return `${indent}Throw ${describe(node.value)}.`;
+
+    case "try":
+      return `${indent}Try block:\n${describe(node.tryBody, depth + 1)}${
+        node.catchBody
+          ? `\n${indent}If an error occurs: catch it as '${node.catchName}', then:\n${describe(node.catchBody, depth + 1)}`
+          : ""
+      }${node.finallyBody ? `\n${indent}Finally: always run\n${describe(node.finallyBody, depth + 1)}` : ""}`;
+
+    // ─────────── EXPRESSIONS ───────────
+    case "binary":
+      return `${describe(node.left)} ${node.operator} ${describe(node.right)}.`;
+
+    case "unary":
+      return `${node.operator}${describe(node.operand)}.`;
+
+    case "postfix":
+      return `${describe(node.operand)}${node.operator}.`;
+
+    // ─────────── MEMORY / POINTERS ───────────
+    case "deref":
+      return `the value pointed to by ${describe(node.operand)}.`;
+
+    case "currency":
+      return `${describe(node.operand)} (in ${node.name}).`;
+
+    // ─────────── STRUCTURES ───────────
+    case "object":
+      return `object: { ${Object.entries(node.props)
+        .map(([k, v]) => `${k}: ${describe(v)}`)
+        .join(", ")} }.`;
+
+    case "array":
+      return `array: [${node.elements.map(e => describe(e)).join(", ")}].`;
+
+    // ─────────── PATTERNS ───────────
+    case "objpattern":
+      return `{ ${node.props
+        .map(p => `${p.key}${p.key !== p.alias ? ` as ${p.alias}` : ""}`)
+        .join(", ")} }`;
+
+    case "arrpattern":
+      return `[${node.elements.map(e => describe(e)).join(", ")}]`;
+
+    // ─────────── TEMPLATES ───────────
+    case "template":
+      return node.parts.map(p => describe(p)).join("");
+
+    // ─────────── EXECUTION ───────────
+    case "exec":
+      return `${indent}Execute: ${describe(node.expr)}.`;
+
+    // ─────────── FALLBACK ───────────
+    case "EOF":
+      return "";
+    default:
+      return `${indent}(Unknown node type: '${node.kind}')`;
+  }
+}
+
+// ─────────── HELPERS ───────────
+function summarizeBody(body) {
+  if (!body || !body.length) return "does nothing";
+  const first = describe(body[0]);
+  if (body.length === 1) {
+    if (first.startsWith("Return")) return `returns ${first.replace(/^Return /, "").trim()}`;
+    return `does: ${first.toLowerCase()}`;
+  }
+  return "runs several steps in order";
+}
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+module.exports = { describe };