novac 2.0.1 → 2.2.0

package/novac/bin/novac

@@ -0,0 +1,950 @@
+#!/usr/bin/env node
+const { Command } = require('commander');
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { run, tokenize, parse, format, Executor } = require('../src/index');
+const stdlib = require('../src/runtime/stdlib');
+const { execSync } = require('child_process');
+const os = require('os');
+const chalk = require('chalk').default;
+const { getConfig, setConfig, interactiveSetup } = require('../src/core/config');
+
+// ─── Wildcard helpers ─────────────────────────────────────────────────────────
+
+/**
+ * Expand a glob pattern (e.g. "src/*.nova", "**\/*.nv") into real file paths.
+ * Falls back gracefully: if the pattern matches no files and contains no glob
+ * characters it is returned as-is so exact paths still work.
+ */
+function expandGlob(pattern) {
+  if (!isGlobPattern(pattern)) return [pattern];
+  try {
+    const matches = fs.globSync(pattern, { cwd: process.cwd() });
+    return matches.length > 0 ? matches.map(m => path.resolve(m)) : [];
+  } catch {
+    return [pattern];
+  }
+}
+
+/**
+ * Expand an array of file arguments, resolving any wildcards in each entry.
+ * Returns a flat, deduplicated array of absolute paths.
+ */
+function expandFileArgs(args) {
+  const seen = new Set();
+  const out = [];
+  for (const arg of args) {
+    for (const f of expandGlob(arg)) {
+      const abs = path.resolve(f);
+      if (!seen.has(abs)) { seen.add(abs); out.push(abs); }
+    }
+  }
+  return out;
+}
+
+/** True when a string contains glob metacharacters */
+function isGlobPattern(str) {
+  return /[*?{}\[\]]/.test(str);
+}
+
+/**
+ * Expand a name list (module names, kit names) that may include wildcards
+ * against an installed directory.  A bare "*" expands to all entries.
+ */
+function expandNamesGlob(patterns, baseDir) {
+  if (!fs.existsSync(baseDir)) return patterns;
+  const installed = fs.readdirSync(baseDir, { withFileTypes: true })
+    .filter(e => e.isDirectory())
+    .map(e => e.name);
+  const out = [];
+  for (const pat of patterns) {
+    if (!isGlobPattern(pat)) { out.push(pat); continue; }
+    const re = globToRegex(pat);
+    const hits = installed.filter(n => re.test(n));
+    if (hits.length > 0) out.push(...hits);
+    else out.push(pat); // pass through so the caller gives a "not found" error
+  }
+  return [...new Set(out)];
+}
+
+/** Convert a simple shell-style glob (*, ?) to a RegExp */
+function globToRegex(pattern) {
+  const escaped = pattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*/g, '.*')
+    .replace(/\?/g, '.');
+  return new RegExp(`^${escaped}$`);
+}
+
+// ─── Program ──────────────────────────────────────────────────────────────────
+
+const program = new Command();
+program.name('novac').description('Nova Language v2').version('2.0.0').enablePositionalOptions();
+
+program
+  .argument('[file]')
+  .argument('[args...]')
+  .allowUnknownOption(true)
+  .passThroughOptions()
+  .action((file, args, options, command) => {
+    // No file given → start REPL
+    if (!file) {
+      console.log(chalk.gray('No file specified. Starting REPL. Type .help for commands, .exit to quit.\n'));
+      return program.commands.find(c => c.name() === 'repl')._actionHandler([]);
+    }
+
+    const filePath = path.resolve(file);
+    if (!fs.existsSync(filePath)) {
+      console.error(chalk.red(`Error: File not found: ${file}`));
+      process.exit(1);
+    }
+
+    let src;
+    try {
+      src = fs.readFileSync(filePath, 'utf8');
+    } catch (e) {
+      console.error(chalk.red(`Error reading file "${file}": ${e.message}`));
+      process.exit(1);
+    }
+
+    let cli = {
+      args: args.filter((a) => !(a.startsWith('-') || a.startsWith('@') || a.startsWith('+'))) || [],
+      options,
+      addrs: {},
+      additions: {},
+      raw: process.argv,
+    };
+    const unknown = process.argv.slice(2).slice(options.length);
+    for (let i = 0; i < unknown.length; i++) {
+      const arg = unknown[i];
+      if (arg.startsWith('--')) {
+        const key = arg.slice(2);
+        const next = unknown[i + 1];
+        if (next && !next.startsWith('-')) {
+          cli.options[key] = next;
+          i++;
+        } else {
+          if (key.includes('=')) {
+            const [k, v] = key.split('=');
+            cli.options[k] = v;
+          } else {
+            cli.options[key] = true;
+          }
+        }
+      } else if (arg.startsWith('-')) {
+        const key = arg.slice(1);
+        cli.options[key] = true;
+      } else if (arg.startsWith('@')) {
+        const key = arg.slice(1);
+        cli.addrs[key] = true;
+      } else if (arg.startsWith('+')) {
+        const key = arg.slice(1);
+        cli.additions[key] = true;
+      }
+    }
+    try { const _r = run(src, { cli }); if (_r instanceof Promise) _r.catch(e => { console.error(chalk.red(e.message || e)); process.exit(1); }); }
+    catch (e) { console.error(chalk.red(e.message || e)); process.exit(1); }
+  });
+
+// ─── novac run <file> [args...] ───────────────────────────────────────────────
+program
+  .command('run <file> [args...]')
+  .description('Run a Nova file (explicit alias for: novac <file>)')
+  .allowUnknownOption(true)
+  .action((file, args, options) => {
+    const filePath = path.resolve(file);
+    if (!fs.existsSync(filePath)) {
+      console.error(chalk.red(`Error: File not found: ${file}`));
+      process.exit(1);
+    }
+    let src;
+    try {
+      src = fs.readFileSync(filePath, 'utf8');
+    } catch (e) {
+      console.error(chalk.red(`Error reading file "${file}": ${e.message}`));
+      process.exit(1);
+    }
+    const cli = { args, options, addrs: {}, additions: {}, raw: process.argv };
+    try { const _r = run(src, { cli }); if (_r instanceof Promise) _r.catch(e => { console.error(chalk.red(e.message || e)); process.exit(1); }); }
+    catch (e) { console.error(chalk.red(e.message || e)); process.exit(1); }
+  });
+
+// ─── novac test <file|glob> [file|glob ...] ───────────────────────────────────
+program
+  .command('test <files...>')
+  .description('Test Nova file(s) by checking syntax — supports globs e.g. "src/*.nova"')
+  .action((files) => {
+    const resolved = expandFileArgs(files);
+    if (resolved.length === 0) {
+      console.error(chalk.red('No files matched:', files.join(', ')));
+      process.exit(1);
+    }
+    let ok = 0, fail = 0;
+    for (const file of resolved) {
+      let src;
+      try {
+        src = fs.readFileSync(file, 'utf8');
+      } catch (e) {
+        console.error(chalk.red('✗'), chalk.gray(path.relative(process.cwd(), file)),
+          chalk.red('— cannot read file:', e.message));
+        fail++; continue;
+      }
+      try {
+        parse(src);
+        console.log(chalk.green('✓'), chalk.gray(path.relative(process.cwd(), file)));
+        ok++;
+      } catch (e) {
+        console.error(chalk.red('✗'), chalk.gray(path.relative(process.cwd(), file)),
+          chalk.red('—', e.message || e));
+        fail++;
+      }
+    }
+    if (resolved.length > 1) {
+      console.log(chalk.blue(`\n${ok} passed, ${fail} failed`));
+    }
+    if (fail > 0) process.exit(1);
+  });
+
+// ─── novac format [file|glob ...] ────────────────────────────────────────────
+program.command('format [files...]')
+  .description('Format Nova file(s) — supports globs e.g. "src/**/*.nova"')
+  .option('-w, --write', 'Write formatted output back to files instead of printing')
+  .option('-c, --check', 'Check if files are formatted; exit non-zero if any need changes (useful for CI)')
+  .action((files, opts) => {
+    if (files && files.length > 0) {
+      const resolved = expandFileArgs(files);
+      if (resolved.length === 0) {
+        console.error(chalk.red('No files matched:', files.join(', ')));
+        process.exit(1);
+      }
+      let anyError = false;
+      let needsFormat = 0;
+      for (const file of resolved) {
+        let src;
+        try {
+          src = fs.readFileSync(file, 'utf8');
+        } catch (e) {
+          console.error(chalk.red(`Error reading "${path.relative(process.cwd(), file)}": ${e.message}`));
+          anyError = true; continue;
+        }
+        try {
+          const out = format(src);
+          if (opts.check) {
+            if (src !== out) {
+              console.log(chalk.red('✗ needs formatting:'), chalk.gray(path.relative(process.cwd(), file)));
+              needsFormat++;
+            } else {
+              console.log(chalk.green('✓'), chalk.gray(path.relative(process.cwd(), file)));
+            }
+          } else if (opts.write) {
+            fs.writeFileSync(file, out, 'utf8');
+            console.log(chalk.green('formatted'), chalk.gray(path.relative(process.cwd(), file)));
+          } else {
+            if (resolved.length > 1) console.log(chalk.bold(`\n// ── ${path.relative(process.cwd(), file)} ──`));
+            console.log(out);
+          }
+        } catch (e) {
+          console.error(chalk.red('Error in', path.relative(process.cwd(), file) + ':'), e.message || e);
+          anyError = true;
+        }
+      }
+      if (opts.check && needsFormat > 0) {
+        console.log(chalk.red(`\n${needsFormat} file(s) need formatting. Run: novac format --write`));
+        process.exit(1);
+      }
+      if (anyError) process.exit(1);
+    } else {
+      // stdin REPL mode
+      let input = '';
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      rl.on('line', (line) => { input += line + '\n'; });
+      rl.on('close', () => {
+        try { console.log(format(input)); }
+        catch (e) { console.error(e.message || e); process.exit(1); }
+      });
+    }
+  });
+
+// ─── novac eval <code> ────────────────────────────────────────────────────────
+program.command('eval <code>')
+  .description('Evaluate Nova code inline')
+  .action((code) => {
+    try { run(code); }
+    catch (e) { console.error(e.message || e); process.exit(1); }
+  });
+
+// ─── novac tokens <file|glob> [file|glob ...] ─────────────────────────────────
+program.command('tokens <files...>')
+  .description('Print token stream of Nova file(s) — supports globs e.g. "src/*.nova"')
+  .action((files) => {
+    const resolved = expandFileArgs(files);
+    if (resolved.length === 0) {
+      console.error(chalk.red('No files matched:', files.join(', ')));
+      process.exit(1);
+    }
+    for (const file of resolved) {
+      const src = fs.readFileSync(file, 'utf8');
+      try {
+        if (resolved.length > 1) console.log(chalk.bold(`\n// ── ${path.relative(process.cwd(), file)} ──`));
+        console.log(JSON.stringify(tokenize(src), null, 2));
+      } catch (e) { console.error(e.message || e); process.exit(1); }
+    }
+  });
+
+// ─── novac ast <file|glob> [file|glob ...] ────────────────────────────────────
+program.command('ast <files...>')
+  .description('Print AST of Nova file(s) — supports globs e.g. "src/*.nova"')
+  .action((files) => {
+    const resolved = expandFileArgs(files);
+    if (resolved.length === 0) {
+      console.error(chalk.red('No files matched:', files.join(', ')));
+      process.exit(1);
+    }
+    for (const file of resolved) {
+      const src = fs.readFileSync(file, 'utf8');
+      try {
+        if (resolved.length > 1) console.log(chalk.bold(`\n// ── ${path.relative(process.cwd(), file)} ──`));
+        console.log(JSON.stringify(parse(src), null, 2));
+      } catch (e) { console.error(e.message || e); process.exit(1); }
+    }
+  });
+
+// ─── novac repl ───────────────────────────────────────────────────────────────
+program.command('repl')
+  .description('Start interactive REPL')
+  .action(() => {
+    const executor = new Executor('', stdlib);
+    const historyFile = path.join(process.env.HOME || process.env.USERPROFILE || '.', '.nova_repl_history');
+
+    console.log('Nova REPL v2.0.0');
+    console.log('Type .exit to exit\n');
+
+    let history = [];
+    try {
+      const historyContent = fs.readFileSync(historyFile, 'utf8');
+      history = historyContent.split('\n').filter(line => line.trim().length > 0);
+    } catch (e) { }
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: 'nova> ',
+      history,
+    });
+
+    rl.prompt();
+
+    rl.on('line', async (input) => {
+      const trimmed = input.trim();
+
+      if (trimmed) fs.appendFileSync(historyFile, trimmed + '\n');
+
+      if (trimmed === '.exit') {
+        rl.close();
+      } else if (trimmed === '.clear') {
+        console.clear();
+      } else if (trimmed === '.reset') {
+        // Re-create executor to wipe all defined variables/functions
+        Object.keys(executor).forEach(k => delete executor[k]);
+        Object.assign(executor, new Executor('', stdlib));
+        console.log(chalk.green('REPL state reset.'));
+      } else if (trimmed.startsWith('.format')) {
+        const code = trimmed.slice(7).trim();
+        if (!code) { console.error('Usage: .format <code>'); rl.prompt(); return; }
+        try {
+          console.log(format(code));
+        } catch (e) { console.error('Error:', e.message || e); }
+      } else if (trimmed.startsWith('.ast')) {
+        try {
+          const ast = parse(trimmed.slice(4).trim());
+          console.log(JSON.stringify(ast, null, 2));
+        } catch (e) { console.error('Error:', e.message || e); }
+      } else if (trimmed.startsWith('.tokens')) {
+        try {
+          const toks = tokenize(trimmed.slice(7).trim());
+          console.log(JSON.stringify(toks, null, 2));
+        } catch (e) { console.error('Error:', e.message || e); }
+      } else if (trimmed.startsWith('.load')) {
+        // .load <file|glob>  — load one or more Nova files into REPL
+        const pattern = trimmed.slice(5).trim();
+        if (!pattern) { console.error('Usage: .load <file|glob>'); rl.prompt(); return; }
+        const files = expandFileArgs([pattern]);
+        if (files.length === 0) { console.error(chalk.red('No files matched:', pattern)); rl.prompt(); return; }
+        for (const file of files) {
+          try {
+            const src = fs.readFileSync(file, 'utf8');
+            const ast = parse(src);
+            let result = executor.run(ast);
+            if (result instanceof Promise) result = await result;
+            console.log(chalk.green('loaded'), chalk.gray(path.relative(process.cwd(), file)));
+          } catch (e) { console.error(chalk.red('Error loading', path.basename(file) + ':'), e.message || e); }
+        }
+      } else if (trimmed.startsWith('.help')) {
+        console.log('Nova REPL Commands:');
+        console.log('  .exit               Exit REPL');
+        console.log('  .clear              Clear screen');
+        console.log('  .reset              Reset all variables and definitions');
+        console.log('  .ast <code>         Show AST for code');
+        console.log('  .tokens <code>      Show token stream for code');
+        console.log('  .format <code>      Show formatted version of code');
+        console.log('  .load <file|glob>   Load Nova file(s) into REPL — supports wildcards');
+        console.log('  .help               Show this help');
+      } else if (trimmed !== '') {
+        try {
+          const ast = parse(trimmed);
+          let result = executor.run(ast);
+          // Top-level await / async fn call — resolve the Promise before printing
+          if (result instanceof Promise) {
+            rl.pause();
+            try {
+              result = await result;
+            } catch (e) {
+              console.error(chalk.red('Async error:'), e && e.message ? e.message.split('\n')[0] : e);
+              rl.resume();
+              rl.prompt();
+              return;
+            }
+            rl.resume();
+          }
+          if (result !== undefined && result !== null && result !== '')
+            console.log(executor.stringify(result));
+        } catch (e) { console.error('Error:', e.message ? e.message.split('\n')[0] : e.message || e); }
+      }
+
+      rl.prompt();
+    });
+
+    rl.on('close', () => {
+      console.log('\nGoodbye!');
+      process.exit(0);
+    });
+  });
+
+// ─── novac new <project> ──────────────────────────────────────────────────────
+program
+  .command('new <project>')
+  .description('Create a new Nova project')
+  .option('--cd', 'Print the cd command to enter the new project directory')
+  .action((project, opts) => {
+    const projectPath = path.resolve(project);
+    if (fs.existsSync(projectPath)) {
+      console.error(chalk.red('Directory already exists:', projectPath));
+      process.exit(1);
+    }
+    fs.mkdirSync(projectPath);
+    fs.mkdirSync(path.join(projectPath, 'src'));
+    fs.mkdirSync(path.join(projectPath, 'bin'));
+    fs.mkdirSync(path.join(projectPath, 'nova_modules'));
+    fs.writeFileSync(path.join(projectPath, 'src', 'main.nova'), `// Welcome to Nova!\n\nprint("Hello, Nova!");\n`, 'utf8');
+    const runFile = path.join(projectPath, 'bin', `${project}.nv`);
+    fs.writeFileSync(runFile, ``, { encoding: 'utf8', mode: 0o755 });
+    fs.writeFileSync(path.join(projectPath, 'README.md'), `# ${project}\n\nThis is a Nova project.`, 'utf8');
+    fs.writeFileSync(path.join(projectPath, '.gitignore'), `nova_modules/\n`, 'utf8');
+    const projectConfig = {
+      name: project,
+      version: '1.0.0',
+      description: '',
+      author: '',
+      license: 'MIT',
+      main: 'src/main.nova',
+      srcDir: 'src',
+      scripts: { run: `novac src/main.nova` },
+      dependencies: {},
+      devDependencies: {},
+    };
+    fs.writeFileSync(path.join(projectPath, 'nova.config.json'), JSON.stringify(projectConfig, null, 2), 'utf8');
+    console.log(chalk.green(`✓ Project created: ${projectPath}`));
+    console.log(chalk.gray(`  src/main.nova  — entry point`));
+    console.log(chalk.gray(`  nova.config.json  — project config`));
+    if (opts.cd) {
+      // Note: a CLI child process cannot change the parent shell's directory.
+      // We print the command for the user to run instead.
+      console.log(chalk.blue(`\nRun: cd ${project}`));
+    } else {
+      console.log(chalk.blue(`\nGet started:\n  cd ${project}\n  novac src/main.nova`));
+    }
+  });
+
+// ─── novac config ─────────────────────────────────────────────────────────────
+program
+  .command('config <action>')
+  .argument('[key]', 'Configuration key (e.g., name, version, scripts.build)')
+  .argument('[value...]', 'Configuration value (optional)')
+  .description('Manage Nova configuration')
+  .action((action, key, value) => {
+    try {
+      if (action === 'get') {
+        if (!key) {
+          const allConfig = getConfig();
+          console.log(JSON.stringify(allConfig, null, 2));
+        } else {
+          const val = getConfig(key);
+          if (val === undefined) {
+            console.log(chalk.yellow(`Config key "${key}" not found`));
+          } else {
+            if (typeof val === 'object') {
+              console.log(JSON.stringify(val, null, 2));
+            } else {
+              console.log(val);
+            }
+          }
+        }
+      } else if (action === 'set') {
+        if (!key || value.length === 0) {
+          console.error(chalk.red('Usage: novac config set <key> <value>'));
+          process.exit(1);
+        }
+        const valueStr = value.join(' ');
+        setConfig(key, valueStr);
+        console.log(chalk.green(`Config updated: ${key} = ${valueStr}`));
+      } else if (action === 'init') {
+        console.log('Initializing Nova configuration...\n');
+        interactiveSetup();
+      } else {
+        console.error(chalk.red(`Unknown action: ${action}. Use "get", "set", or "init".`));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('Config error:', error.message));
+      process.exit(1);
+    }
+  });
+
+// ─── novac etc <cmd> ─────────────────────────────────────────────────────────
+program
+  .command('etc <cmd> [args...]')
+  .description('Run extra Nova commands (e.g., notices, describe, kit)')
+  .allowUnknownOption(true)
+  .action((cmd, args) => {
+    try {
+      if (cmd === 'notices') {
+        const notices = stdlib.getNotices();
+        if (notices.length === 0) {
+          console.log(chalk.green('No notices'));
+        } else {
+          console.log(chalk.yellow('Notices:'));
+          notices.forEach((n, i) => console.log(chalk.yellow(`${i + 1}. ${n}`)));
+        }
+      } else if (cmd === 'describe') {
+        // describe supports globs: novac etc describe src/*.nova
+        const pattern = args[0];
+        if (!pattern) { console.error(chalk.red('Usage: novac etc describe <file|glob>')); process.exit(1); }
+        const files = expandFileArgs([pattern]);
+        if (files.length === 0) { console.error(chalk.red('No files matched:', pattern)); process.exit(1); }
+        const describer = require('../src/core/describe');
+        for (const file of files) {
+          if (files.length > 1) console.log(chalk.bold(`\n── ${path.relative(process.cwd(), file)} ──`));
+          const content = fs.readFileSync(file, 'utf8');
+          const ast = parse(content);
+          console.log(describer.describe(ast));
+        }
+      } else if (cmd === 'kit') {
+        // Supports multiple names and wildcards: novac etc kit math* utils --global
+        const isGlobal = args.includes('--global') || args.includes('-g');
+        const kitNames = args.filter(a => a !== '--global' && a !== '-g');
+        if (kitNames.length === 0) {
+          console.error(chalk.red('Usage: novac etc kit <kitname|glob> [...] [--global]'));
+          process.exit(1);
+        }
+        const kitsRoot = path.join(__dirname, '..', 'kits');
+        const availableKits = fs.existsSync(kitsRoot)
+          ? fs.readdirSync(kitsRoot, { withFileTypes: true }).filter(e => e.isDirectory()).map(e => e.name)
+          : [];
+
+        // Expand wildcards against available kits
+        const resolvedKits = [];
+        for (const pat of kitNames) {
+          if (isGlobPattern(pat)) {
+            const re = globToRegex(pat);
+            const hits = availableKits.filter(n => re.test(n));
+            if (hits.length === 0) {
+              console.error(chalk.red(`No kits matched pattern "${pat}". Available: ${availableKits.join(', ')}`));
+              process.exit(1);
+            }
+            resolvedKits.push(...hits);
+          } else {
+            resolvedKits.push(pat);
+          }
+        }
+
+        const baseDir = isGlobal
+          ? path.join(os.homedir(), '.novac', 'nova_modules')
+          : path.join(process.cwd(), 'nova_modules');
+
+        let ok = 0, fail = 0;
+        for (const kitName of [...new Set(resolvedKits)]) {
+          const kitDir = path.join(kitsRoot, kitName);
+          if (!fs.existsSync(kitDir) || !fs.statSync(kitDir).isDirectory()) {
+            console.error(chalk.red(`  fail  "${kitName}" — not found. Available: ${availableKits.join(', ')}`));
+            fail++; continue;
+          }
+          const destPath = path.join(baseDir, kitName);
+          if (isGlobal) console.log(chalk.blue(`Installing globally to ${destPath}`));
+          if (fs.existsSync(destPath)) {
+            console.error(chalk.red(`  skip  "${kitName}" — already installed at ${destPath}`));
+            fail++; continue;
+          }
+          const kitdefPath = path.join(kitDir, 'kitdef.js');
+          if (!fs.existsSync(kitdefPath)) {
+            console.error(chalk.red(`  fail  "${kitName}" — no kitdef.js`));
+            fail++; continue;
+          }
+          fs.mkdirSync(destPath, { recursive: true });
+          fs.copyFileSync(kitdefPath, path.join(destPath, 'kitdef.js'));
+          console.log(chalk.green(`  ok    "${kitName}" → ${destPath}`));
+          console.log(chalk.blue(`         Usage in Nova:  import "${kitName}"`));
+          ok++;
+        }
+        if (resolvedKits.length > 1) console.log(chalk.blue(`\nDone. ${ok} installed, ${fail} failed/skipped.`));
+      } else {
+        console.error(chalk.red(`Unknown command: ${cmd}. Use "notices", "describe", or "kit".`));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:', error.message));
+      process.exit(1);
+    }
+  });
+
+// ─── novac new-kit <dirname> ──────────────────────────────────────────────────
+program
+  .command('new-kit <dirname>')
+  .description('Scaffold a new Nova kit in the current directory')
+  .action((dirname) => {
+    const kitPath = path.resolve(dirname);
+    if (fs.existsSync(kitPath)) {
+      console.error(chalk.red(`Directory already exists: ${kitPath}`));
+      process.exit(1);
+    }
+    fs.mkdirSync(kitPath, { recursive: true });
+
+    const kitdefSrc = `// ${dirname} — Nova kit
+// Export all public API on the kitdef object.
+// Each key becomes accessible after: import "${dirname}"
+
+const kit = {
+  // TODO: implement your kit API here
+  hello() {
+    return 'Hello from ${dirname}!';
+  },
+};
+
+module.exports = { kitdef: kit };
+`;
+    fs.writeFileSync(path.join(kitPath, 'kitdef.js'), kitdefSrc, 'utf8');
+
+    const indexNova = `// ${dirname} kit — Nova wrapper
+// Import this file from Nova: import "${dirname}"
+// Then call: hello()
+
+let _kit = __js_require("./${dirname}/kitdef.js").kitdef;
+export hello = _kit.hello;
+`;
+    fs.writeFileSync(path.join(kitPath, 'index.nova'), indexNova, 'utf8');
+
+    const manifest = {
+      name: dirname,
+      version: '1.0.0',
+      description: '',
+      main: 'index.nova',
+      author: '',
+      license: 'MIT',
+    };
+    fs.writeFileSync(path.join(kitPath, 'nova.kit.json'), JSON.stringify(manifest, null, 2), 'utf8');
+    fs.writeFileSync(path.join(kitPath, 'README.md'), `# ${dirname}\n\nA Nova kit.\n\n## Usage\n\n\`\`\`nova\nimport "${dirname}"\nhello()\n\`\`\`\n`, 'utf8');
+
+    console.log(chalk.green(`Kit scaffolded at ${kitPath}`));
+    console.log(chalk.blue('  Edit kitdef.js to implement your API.'));
+    console.log(chalk.blue('  Update index.nova exports to match.'));
+  });
+
+// ─── novac init build | PATH ──────────────────────────────────────────────────
+program
+  .command('init')
+  .description('Initialize novac settings or build project module')
+  .argument('<option>', 'Option: PATH | build')
+  .action((option) => {
+    if (option.toUpperCase() === 'BUILD') {
+      const configFile = path.join(process.cwd(), 'nova.config.json');
+      if (!fs.existsSync(configFile)) {
+        console.error(chalk.red('No nova.config.json found in current directory.'));
+        console.error(chalk.yellow('Run: novac config init  to create one, or create nova.config.json manually.'));
+        process.exit(1);
+      }
+      const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+      const name    = config.name    || path.basename(process.cwd());
+      const version = config.version || '1.0.0';
+      const main    = config.main    || 'src/main.nova';
+      const srcDir  = config.srcDir  || 'src';
+
+      function collectNova(dir, base = dir) {
+        const results = {};
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+          const full = path.join(dir, entry.name);
+          const rel  = path.relative(base, full);
+          if (entry.isDirectory()) Object.assign(results, collectNova(full, base));
+          else if (entry.name.endsWith('.nova') || entry.name.endsWith('.nv')) {
+            results[rel] = fs.readFileSync(full, 'utf8');
+          }
+        }
+        return results;
+      }
+
+      const srcAbsDir = path.join(process.cwd(), srcDir);
+      if (!fs.existsSync(srcAbsDir)) {
+        console.error(chalk.red(`Source directory not found: ${srcDir}`));
+        process.exit(1);
+      }
+
+      const sources = collectNova(srcAbsDir);
+      if (!sources[main] && !sources[path.relative(srcAbsDir, path.join(process.cwd(), main))]) {
+        const mainRel = path.relative(srcAbsDir, path.join(process.cwd(), main));
+        if (!sources[mainRel] && !sources[main]) {
+          console.error(chalk.red(`Main entry "${main}" not found in collected sources.`));
+          console.error(chalk.yellow('Sources found: ' + Object.keys(sources).join(', ')));
+          process.exit(1);
+        }
+      }
+
+      const bundle = {
+        manifest: { name, version, main: Object.keys(sources)[0], ...config },
+        sources,
+        buildTime: new Date().toISOString(),
+      };
+
+      const mainKey = sources[main] ? main
+        : sources[path.relative(srcAbsDir, path.join(process.cwd(), main))]
+          ? path.relative(srcAbsDir, path.join(process.cwd(), main))
+          : Object.keys(sources)[0];
+      bundle.manifest.main = mainKey;
+
+      const outFile = path.join(process.cwd(), `${name}.novamod`);
+      fs.writeFileSync(outFile, JSON.stringify(bundle, null, 2), 'utf8');
+      console.log(chalk.green(`Built module: ${name}.novamod`));
+      console.log(chalk.blue(`  ${Object.keys(sources).length} source file(s) bundled`));
+      console.log(chalk.blue(`  Entry: ${mainKey}`));
+      console.log(chalk.blue(`  Install in another project: novac module install ./${name}.novamod`));
+    } else if (option.toUpperCase() === 'PATH') {
+      const platform = os.platform();
+      const npmPrefix = execSync('npm config get prefix', { encoding: 'utf8' }).trim();
+      const binPath = path.join(npmPrefix, 'bin');
+      console.log(chalk.blue(`Adding ${binPath} to PATH for ${platform}...`));
+      try {
+        if (platform === 'win32') {
+          execSync(`setx PATH "%PATH%;${binPath}"`, { stdio: 'inherit' });
+          console.log(chalk.green('PATH updated on Windows. Restart your terminal.'));
+        } else if (['darwin','linux','freebsd','openbsd','sunos','aix','android'].includes(platform)) {
+          const shellRc = platform === 'darwin'
+            ? path.join(process.env.HOME, '.zshrc')
+            : path.join(process.env.HOME, '.bashrc');
+          const exportCmd = `export PATH="$PATH:${binPath}"`;
+          execSync(`echo '${exportCmd}' >> ${shellRc}`, { stdio: 'inherit' });
+          console.log(chalk.green(`Added to ${shellRc}. Run 'source ${shellRc}' or restart your shell.`));
+        } else {
+          console.log(chalk.red('Unsupported platform. Manually add to PATH.'));
+        }
+      } catch (error) {
+        console.error(chalk.red('Failed to update PATH:', error.message));
+        console.log(chalk.yellow('Please manually add to PATH or run with admin/sudo.'));
+      }
+    } else {
+      console.log(chalk.red(`Unknown option: ${option}. Use 'PATH' or 'build'.`));
+    }
+  });
+
+// ─── novac module <subcommand> ────────────────────────────────────────────────
+const moduleCmd = program.command('module').description('Manage Nova modules');
+
+// novac module install [path|glob] [path|glob ...] [--global]
+moduleCmd
+  .command('install [modpaths...]')
+  .description('Install .novamod bundle(s) or all deps from nova.config.json — supports globs e.g. "dist/*.novamod"')
+  .option('-g, --global', 'Install into global nova_modules (~/.novac/nova_modules)')
+  .action((modpaths, opts) => {
+    const globalDir = path.join(os.homedir(), '.novac', 'nova_modules');
+    const novaModulesDir = opts.global ? globalDir : path.join(process.cwd(), 'nova_modules');
+    if (opts.global) console.log(chalk.blue(`Installing globally to ${novaModulesDir}`));
+    fs.mkdirSync(novaModulesDir, { recursive: true });
+
+    if (!modpaths || modpaths.length === 0) {
+      // ── install all deps from nova.config.json ──
+      const configFile = path.join(process.cwd(), 'nova.config.json');
+      if (!fs.existsSync(configFile)) {
+        console.error(chalk.red('No nova.config.json found. Nothing to install.'));
+        process.exit(1);
+      }
+      const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+      const deps = { ...(config.dependencies || {}), ...(config.devDependencies || {}) };
+      const entries = Object.entries(deps);
+      if (entries.length === 0) {
+        console.log(chalk.yellow('No dependencies listed in nova.config.json.'));
+        return;
+      }
+      console.log(chalk.blue(`Installing ${entries.length} dependency(ies)...`));
+      let ok = 0, fail = 0;
+      for (const [name, ref] of entries) {
+        const destDir = path.join(novaModulesDir, name);
+        if (fs.existsSync(destDir)) {
+          console.log(chalk.yellow(`  skip  ${name} (already installed)`));
+          ok++; continue;
+        }
+        const resolved = path.isAbsolute(ref) ? ref : path.resolve(process.cwd(), ref);
+        if (fs.existsSync(resolved) && resolved.endsWith('.novamod')) {
+          _installNovamod(resolved, name, novaModulesDir);
+          console.log(chalk.green(`  ok    ${name}`));
+          ok++;
+        } else {
+          const kitDir = path.join(__dirname, '..', 'kits', name);
+          if (fs.existsSync(kitDir)) {
+            _installKit(kitDir, name, novaModulesDir);
+            console.log(chalk.green(`  ok    ${name} (built-in kit)`));
+            ok++;
+          } else {
+            console.error(chalk.red(`  fail  ${name}: cannot resolve "${ref}"`));
+            fail++;
+          }
+        }
+      }
+      console.log(chalk.blue(`Done. ${ok} installed, ${fail} failed.`));
+    } else {
+      // ── install one or more .novamod files (supports globs) ──
+      const resolved = expandFileArgs(modpaths);
+      if (resolved.length === 0) {
+        console.error(chalk.red('No .novamod files matched:', modpaths.join(', ')));
+        process.exit(1);
+      }
+      let ok = 0, fail = 0;
+      for (const modpath of resolved) {
+        if (!fs.existsSync(modpath)) {
+          console.error(chalk.red(`  fail  File not found: ${modpath}`));
+          fail++; continue;
+        }
+        if (!modpath.endsWith('.novamod')) {
+          console.error(chalk.red(`  fail  Expected a .novamod file: ${modpath}`));
+          fail++; continue;
+        }
+        const bundle = JSON.parse(fs.readFileSync(modpath, 'utf8'));
+        const name = bundle.manifest.name;
+        if (!name) {
+          console.error(chalk.red(`  fail  Bundle has no manifest.name: ${modpath}`));
+          fail++; continue;
+        }
+        const destDir = path.join(novaModulesDir, name);
+        if (fs.existsSync(destDir)) {
+          console.error(chalk.red(`  skip  "${name}" already installed (remove nova_modules/${name} first)`));
+          fail++; continue;
+        }
+        _installNovamod(modpath, name, novaModulesDir);
+        console.log(chalk.green(`  ok    "${name}" → nova_modules/${name}`));
+        console.log(chalk.blue(`         Usage: import "${name}"`));
+        ok++;
+      }
+      if (resolved.length > 1) console.log(chalk.blue(`\nDone. ${ok} installed, ${fail} failed/skipped.`));
+    }
+  });
+
+// novac module list [pattern]
+moduleCmd
+  .command('list [pattern]')
+  .description('List installed modules — optional wildcard filter e.g. "math*"')
+  .option('-g, --global', 'List globally installed modules (~/.novac/nova_modules)')
+  .action((pattern, opts) => {
+    const localDir = path.join(process.cwd(), 'nova_modules');
+    const globalDir = path.join(os.homedir(), '.novac', 'nova_modules');
+    const novaModulesDir = opts.global ? globalDir : localDir;
+    const scope = opts.global ? 'global' : 'local';
+
+    if (!fs.existsSync(novaModulesDir)) {
+      console.log(chalk.yellow(`No ${scope} nova_modules directory found.`));
+      return;
+    }
+    let entries = fs.readdirSync(novaModulesDir, { withFileTypes: true }).filter(e => e.isDirectory());
+    if (pattern && isGlobPattern(pattern)) {
+      const re = globToRegex(pattern);
+      entries = entries.filter(e => re.test(e.name));
+    } else if (pattern) {
+      entries = entries.filter(e => e.name.includes(pattern));
+    }
+    if (entries.length === 0) {
+      console.log(chalk.yellow(pattern ? `No ${scope} modules matching "${pattern}".` : `No ${scope} modules installed.`));
+      return;
+    }
+    console.log(chalk.blue(`Installed ${scope} modules${pattern ? ` matching "${pattern}"` : ''}:`));
+    for (const e of entries) {
+      const manifestPath  = path.join(novaModulesDir, e.name, 'nova.kit.json');
+      const bundleManifest = path.join(novaModulesDir, e.name, 'nova.mod.json');
+      let version = '?';
+      if (fs.existsSync(manifestPath)) {
+        try { version = JSON.parse(fs.readFileSync(manifestPath, 'utf8')).version || '?'; } catch {}
+      } else if (fs.existsSync(bundleManifest)) {
+        try { version = JSON.parse(fs.readFileSync(bundleManifest, 'utf8')).version || '?'; } catch {}
+      }
+      console.log(`  ${chalk.green(e.name)}  ${chalk.gray(version)}`);
+    }
+  });
+
+// novac module remove <name|glob> [name|glob ...]
+moduleCmd
+  .command('remove <names...>')
+  .description('Remove installed module(s) — supports wildcards e.g. "math*" or "*"')
+  .option('-y, --yes', 'Skip confirmation when removing multiple modules')
+  .action((names, opts) => {
+    const novaModulesDir = path.join(process.cwd(), 'nova_modules');
+    const resolved = expandNamesGlob(names, novaModulesDir);
+
+    if (resolved.length > 1 && !opts.yes) {
+      console.log(chalk.yellow(`About to remove ${resolved.length} module(s): ${resolved.join(', ')}`));
+      console.log(chalk.yellow('Re-run with --yes to confirm, or remove them one by one.'));
+      process.exit(0);
+    }
+
+    let ok = 0, fail = 0;
+    for (const name of resolved) {
+      const destDir = path.join(novaModulesDir, name);
+      if (!fs.existsSync(destDir)) {
+        console.error(chalk.red(`  fail  "${name}" is not installed.`));
+        fail++; continue;
+      }
+      fs.rmSync(destDir, { recursive: true, force: true });
+      console.log(chalk.green(`  ok    "${name}" removed.`));
+      ok++;
+    }
+    if (resolved.length > 1) console.log(chalk.blue(`\nDone. ${ok} removed, ${fail} not found.`));
+    if (fail > 0 && ok === 0) process.exit(1);
+  });
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+function _installNovamod(resolved, name, novaModulesDir) {
+  const bundle = JSON.parse(fs.readFileSync(resolved, 'utf8'));
+  const destDir = path.join(novaModulesDir, name);
+  fs.mkdirSync(destDir, { recursive: true });
+  for (const [relPath, content] of Object.entries(bundle.sources)) {
+    const fileDest = path.join(destDir, relPath);
+    fs.mkdirSync(path.dirname(fileDest), { recursive: true });
+    fs.writeFileSync(fileDest, content, 'utf8');
+  }
+  fs.copyFileSync(resolved, path.join(destDir, `${name}.novamod`));
+  fs.writeFileSync(path.join(destDir, 'nova.mod.json'), JSON.stringify(bundle.manifest, null, 2), 'utf8');
+}
+
+function _installKit(kitDir, name, novaModulesDir) {
+  const kitdefPath = path.join(kitDir, 'kitdef.js');
+  if (!fs.existsSync(kitdefPath)) throw new Error(`Kit ${name} has no kitdef.js`);
+  const { kitdef } = require(kitdefPath);
+  const destDir = path.join(novaModulesDir, name);
+  fs.mkdirSync(destDir, { recursive: true });
+  fs.copyFileSync(kitdefPath, path.join(destDir, 'kitdef.js'));
+  const members = Object.keys(kitdef);
+  const novaLines = [
+    `// Auto-generated kit wrapper for ${name}`,
+    `let _kit = __js_require("${path.join(destDir, 'kitdef.js')}").kitdef;`,
+    ...members.map(m => `export ${m} = _kit.${m};`),
+  ].join('\n') + '\n';
+  fs.writeFileSync(path.join(destDir, 'index.nova'), novaLines, 'utf8');
+  const manifest = { name, version: '1.0.0', main: 'index.nova', type: 'kit' };
+  fs.writeFileSync(path.join(destDir, 'nova.kit.json'), JSON.stringify(manifest, null, 2), 'utf8');
+}
+
+program.parse();