novac 2.0.1 → 2.2.0

package/bin/novac

@@ -10,24 +10,112 @@ 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');
+program.name('novac').description('Nova Language v2').version('2.0.0').enablePositionalOptions();
 
 program
   .argument('[file]')
   .argument('[args...]')
-  .allowUnknownOption(true) // allow extra options
+  .allowUnknownOption(true)
   .passThroughOptions()
   .action((file, args, options, command) => {
-    const src = fs.readFileSync(path.resolve(file), 'utf8');
-    let cli = { 
-      args: args.filter((a) => !(a.startsWith('-')  || a.startsWith('@') || a.startsWith('+'))) || [],
+    // 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: {}, // @addr
-      additions: {}, // +feature
+      addrs: {},
+      additions: {},
       raw: process.argv,
-   };
-    const unknown = process.argv.slice(2).slice(options.length); // array
+    };
+    const unknown = process.argv.slice(2).slice(options.length);
     for (let i = 0; i < unknown.length; i++) {
       const arg = unknown[i];
       if (arg.startsWith('--')) {
@@ -35,13 +123,13 @@ program
         const next = unknown[i + 1];
         if (next && !next.startsWith('-')) {
           cli.options[key] = next;
-          i++; // skip next
+          i++;
         } else {
           if (key.includes('=')) {
             const [k, v] = key.split('=');
             cli.options[k] = v;
           } else {
-          cli.options[key] = true;
+            cli.options[key] = true;
           }
         }
       } else if (arg.startsWith('-')) {
@@ -55,38 +143,122 @@ program
         cli.additions[key] = true;
       }
     }
-    try { run(src, { cli }); }
-    catch (e) { console.error(e.message || e); process.exit(1); }
+    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 <file>')
-  .description('Test a Nova file by checking it\'s syntax')
-  .action((file) => {
-    const src = fs.readFileSync(path.resolve(file), 'utf8');
-    try { parse(src); console.log(chalk.green('Syntax OK')); }
-    catch (e) { console.error(chalk.red('Syntax Error:', e.message || e)); process.exit(1); }
+  .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);
   });
 
-program.command('format [file]')
-  .description('Format a Nova file')
-  .action((file) => {
-    if (file) {
-      const src = fs.readFileSync(path.resolve(file), 'utf8');
-      try { console.log(format(src)); }
-      catch (e) { console.error(e.message || e); 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 = '';
-      // a repl
-      const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-      });
-
-      rl.on('line', (line) => {
-        input += line + '\n';
-      });
-
+      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); }
@@ -94,6 +266,7 @@ program.command('format [file]')
     }
   });
 
+// ─── novac eval <code> ────────────────────────────────────────────────────────
 program.command('eval <code>')
   .description('Evaluate Nova code inline')
   .action((code) => {
@@ -101,22 +274,43 @@ program.command('eval <code>')
     catch (e) { console.error(e.message || e); process.exit(1); }
   });
 
-program.command('tokens <file>')
-  .description('Print token stream of a Nova file')
-  .action((file) => {
-    const src = fs.readFileSync(path.resolve(file), 'utf8');
-    try { console.log(JSON.stringify(tokenize(src), null, 2)); }
-    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); }
+    }
   });
 
-program.command('ast <file>')
-  .description('Print AST of a Nova file')
-  .action((file) => {
-    const src = fs.readFileSync(path.resolve(file), 'utf8');
-    try { console.log(JSON.stringify(parse(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(() => {
@@ -126,7 +320,6 @@ program.command('repl')
     console.log('Nova REPL v2.0.0');
     console.log('Type .exit to exit\n');
 
-    // Load history
     let history = [];
     try {
       const historyContent = fs.readFileSync(historyFile, 'utf8');
@@ -137,51 +330,86 @@ program.command('repl')
       input: process.stdin,
       output: process.stdout,
       prompt: 'nova> ',
-      history: history
+      history,
     });
 
     rl.prompt();
 
-    rl.on('line', (input) => {
+    rl.on('line', async (input) => {
       const trimmed = input.trim();
 
-      if (trimmed) {
-        fs.appendFileSync(historyFile, trimmed + '\n');
-      }
+      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);
-        }
+        } 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);
+        } 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('  .ast <code>   Show AST');
-        console.log('  .tokens <code> Show tokens');
-        console.log('  .help         Show this help');
+        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);
-          const result = executor.run(ast);
-          if (result !== undefined) console.log(result);
-        } catch (e) {
-          console.error('Error:', e.message || e);
-        }
+          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();
@@ -193,10 +421,12 @@ program.command('repl')
     });
   });
 
-program.command('new <project> ')
-  .option('--cd, cd into project directory after creation')
+// ─── novac new <project> ──────────────────────────────────────────────────────
+program
+  .command('new <project>')
   .description('Create a new Nova project')
-  .action((project, cd) => {
+  .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));
@@ -210,8 +440,7 @@ program.command('new <project> ')
     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'), ``, 'utf8');
-    // Write nova.config.json (project-local module config)
+    fs.writeFileSync(path.join(projectPath, '.gitignore'), `nova_modules/\n`, 'utf8');
     const projectConfig = {
       name: project,
       version: '1.0.0',
@@ -225,13 +454,19 @@ program.command('new <project> ')
       devDependencies: {},
     };
     fs.writeFileSync(path.join(projectPath, 'nova.config.json'), JSON.stringify(projectConfig, null, 2), 'utf8');
-    console.log(chalk.green('Project created at', projectPath));
-    if (cd.cd) {
-      execSync(`cd ${projectPath}`, { stdio: 'inherit', shell: true });
-      console.log(chalk.blue('Changed directory to', projectPath));
+    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)')
@@ -275,10 +510,11 @@ program
       process.exit(1);
     }
   });
-//extra commands: novac etc <cmd> to run extra nova commands like notices, describe, etc.
+
+// ─── novac etc <cmd> ─────────────────────────────────────────────────────────
 program
   .command('etc <cmd> [args...]')
-  .description('Run extra Nova commands (e.g., notices, describe)')
+  .description('Run extra Nova commands (e.g., notices, describe, kit)')
   .allowUnknownOption(true)
   .action((cmd, args) => {
     try {
@@ -288,42 +524,79 @@ program
           console.log(chalk.green('No notices'));
         } else {
           console.log(chalk.yellow('Notices:'));
-          notices.forEach((n, i) => {
-            console.log(chalk.yellow(`${i + 1}. ${n}`));
-          });
+          notices.forEach((n, i) => console.log(chalk.yellow(`${i + 1}. ${n}`)));
         }
       } else if (cmd === 'describe') {
-        const content = fs.readFileSync(args[0], 'utf8');
-        const ast = parse(content);
+        // 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');
-        const description = describer.describe(ast);
-        console.log(description);
+        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') {
-        // Install a built-in kit into nova_modules (local or global)
-        // Usage: novac etc kit <name>         -> ./nova_modules/<name>
-        //        novac etc kit <name> --global -> ~/.novac/nova_modules/<name>
-        const kitName = args[0];
+        // Supports multiple names and wildcards: novac etc kit math* utils --global
         const isGlobal = args.includes('--global') || args.includes('-g');
-        if (!kitName || kitName.startsWith('-')) { console.error(chalk.red('Usage: novac etc kit <kitname> [--global]')); process.exit(1); }
-        const kitsRoot = path.join(__dirname, '..', 'kits');
-        const kitDir = path.join(kitsRoot, kitName);
-        if (!fs.existsSync(kitDir) || !fs.statSync(kitDir).isDirectory()) {
-          console.error(chalk.red(`Kit "${kitName}" not found. Available: ${fs.readdirSync(kitsRoot).join(', ')}`));
+        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 baseDir = isGlobal ? path.join(os.homedir(), '.novac', 'nova_modules') : path.join(process.cwd(), 'nova_modules');
-        const destPath = path.join(baseDir, kitName);
-        if (isGlobal) console.log(chalk.blue(`Installing globally to ${destPath}`));
-        if (fs.existsSync(destPath)) {
-          console.error(chalk.red(`Kit "${kitName}" already installed at ${destPath}. Remove it first.`));
-          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++;
         }
-        const kitdefPath = path.join(kitDir, 'kitdef.js');
-        if (!fs.existsSync(kitdefPath)) { console.error(chalk.red(`Kit "${kitName}" has no kitdef.js`)); process.exit(1); }
-        fs.mkdirSync(destPath, { recursive: true });
-        fs.copyFileSync(kitdefPath, path.join(destPath, 'kitdef.js'));
-        console.log(chalk.green(`Kit "${kitName}" installed to ${destPath}`));
-        console.log(chalk.blue(`  Usage in Nova:  import "${kitName}"`));
+        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);
@@ -346,7 +619,6 @@ program
     }
     fs.mkdirSync(kitPath, { recursive: true });
 
-    // kitdef.js — the actual implementation
     const kitdefSrc = `// ${dirname} — Nova kit
 // Export all public API on the kitdef object.
 // Each key becomes accessible after: import "${dirname}"
@@ -362,7 +634,6 @@ module.exports = { kitdef: kit };
 `;
     fs.writeFileSync(path.join(kitPath, 'kitdef.js'), kitdefSrc, 'utf8');
 
-    // index.nova — Nova-facing wrapper (generated manually here as a template)
     const indexNova = `// ${dirname} kit — Nova wrapper
 // Import this file from Nova: import "${dirname}"
 // Then call: hello()
@@ -372,7 +643,6 @@ export hello = _kit.hello;
 `;
     fs.writeFileSync(path.join(kitPath, 'index.nova'), indexNova, 'utf8');
 
-    // nova.kit.json — kit manifest
     const manifest = {
       name: dirname,
       version: '1.0.0',
@@ -382,8 +652,6 @@ export hello = _kit.hello;
       license: 'MIT',
     };
     fs.writeFileSync(path.join(kitPath, 'nova.kit.json'), JSON.stringify(manifest, null, 2), 'utf8');
-
-    // README
     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}`));
@@ -391,16 +659,13 @@ export hello = _kit.hello;
     console.log(chalk.blue('  Update index.nova exports to match.'));
   });
 
-// ─── novac init build ─────────────────────────────────────────────────────────
-// Reads nova.config.json in cwd, bundles all .nova sources into a .novamod file
-// that can be dropped into another project's nova_modules/.
+// ─── 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') {
-      // ── 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.'));
@@ -413,7 +678,6 @@ program
       const main    = config.main    || 'src/main.nova';
       const srcDir  = config.srcDir  || 'src';
 
-      // Collect all .nova files under srcDir
       function collectNova(dir, base = dir) {
         const results = {};
         for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
@@ -435,7 +699,6 @@ program
 
       const sources = collectNova(srcAbsDir);
       if (!sources[main] && !sources[path.relative(srcAbsDir, path.join(process.cwd(), main))]) {
-        // Try to find main relative to srcDir
         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.`));
@@ -450,7 +713,6 @@ program
         buildTime: new Date().toISOString(),
       };
 
-      // Determine main key: prefer exact match, then first key
       const mainKey = sources[main] ? main
         : sources[path.relative(srcAbsDir, path.join(process.cwd(), main))]
           ? path.relative(srcAbsDir, path.join(process.cwd(), main))
@@ -473,7 +735,9 @@ program
           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 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.`));
@@ -492,18 +756,18 @@ program
 // ─── novac module <subcommand> ────────────────────────────────────────────────
 const moduleCmd = program.command('module').description('Manage Nova modules');
 
-// novac module install [path] [--global]
+// novac module install [path|glob] [path|glob ...] [--global]
 moduleCmd
-  .command('install [modpath]')
-  .description('Install a .novamod bundle, or install all dependencies from nova.config.json')
+  .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((modpath, opts) => {
+  .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 (!modpath) {
+    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)) {
@@ -520,20 +784,17 @@ moduleCmd
       console.log(chalk.blue(`Installing ${entries.length} dependency(ies)...`));
       let ok = 0, fail = 0;
       for (const [name, ref] of entries) {
-        // ref can be: a local path ("./path/to/foo.novamod"), or a built-in kit name
         const destDir = path.join(novaModulesDir, name);
         if (fs.existsSync(destDir)) {
           console.log(chalk.yellow(`  skip  ${name} (already installed)`));
           ok++; continue;
         }
-        // Try local path
         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 {
-          // Try as a built-in kit
           const kitDir = path.join(__dirname, '..', 'kits', name);
           if (fs.existsSync(kitDir)) {
             _installKit(kitDir, name, novaModulesDir);
@@ -547,48 +808,71 @@ moduleCmd
       }
       console.log(chalk.blue(`Done. ${ok} installed, ${fail} failed.`));
     } else {
-      // ── install single .novamod ──
-      const resolved = path.isAbsolute(modpath) ? modpath : path.resolve(process.cwd(), modpath);
-      if (!fs.existsSync(resolved)) {
-        console.error(chalk.red(`File not found: ${resolved}`));
-        process.exit(1);
-      }
-      if (!resolved.endsWith('.novamod')) {
-        console.error(chalk.red('Expected a .novamod file.'));
+      // ── 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);
       }
-      const bundle = JSON.parse(fs.readFileSync(resolved, 'utf8'));
-      const name = bundle.manifest.name;
-      if (!name) { console.error(chalk.red('Bundle has no manifest.name')); process.exit(1); }
-      const destDir = path.join(novaModulesDir, name);
-      if (fs.existsSync(destDir)) {
-        console.error(chalk.red(`Module "${name}" already installed. Remove nova_modules/${name} first.`));
-        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++;
       }
-      _installNovamod(resolved, name, novaModulesDir);
-      console.log(chalk.green(`Module "${name}" installed to nova_modules/${name}`));
-      console.log(chalk.blue(`  Usage: import "${name}"`));
+      if (resolved.length > 1) console.log(chalk.blue(`\nDone. ${ok} installed, ${fail} failed/skipped.`));
     }
   });
 
-// novac module list
+// novac module list [pattern]
 moduleCmd
-  .command('list')
-  .description('List installed modules in nova_modules/')
-  .action(() => {
-    const novaModulesDir = path.join(process.cwd(), 'nova_modules');
+  .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 nova_modules directory found.'));
+      console.log(chalk.yellow(`No ${scope} nova_modules directory found.`));
       return;
     }
-    const entries = fs.readdirSync(novaModulesDir, { withFileTypes: true }).filter(e => e.isDirectory());
+    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('No modules installed.'));
+      console.log(chalk.yellow(pattern ? `No ${scope} modules matching "${pattern}".` : `No ${scope} modules installed.`));
       return;
     }
-    console.log(chalk.blue('Installed modules:'));
+    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 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)) {
@@ -600,35 +884,48 @@ moduleCmd
     }
   });
 
-// novac module remove <name>
+// novac module remove <name|glob> [name|glob ...]
 moduleCmd
-  .command('remove <name>')
-  .description('Remove an installed module from nova_modules/')
-  .action((name) => {
-    const destDir = path.join(process.cwd(), 'nova_modules', name);
-    if (!fs.existsSync(destDir)) {
-      console.error(chalk.red(`Module "${name}" is not installed.`));
-      process.exit(1);
+  .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++;
     }
-    fs.rmSync(destDir, { recursive: true, force: true });
-    console.log(chalk.green(`Module "${name}" removed.`));
+    if (resolved.length > 1) console.log(chalk.blue(`\nDone. ${ok} removed, ${fail} not found.`));
+    if (fail > 0 && ok === 0) process.exit(1);
   });
 
-// ── helpers ──────────────────────────────────────────────────────────────────
+// ── 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 });
-  // Write each source file into the module dir (preserving sub-paths)
   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');
   }
-  // Write the .novamod itself so _loadModuleExports can use it directly
   fs.copyFileSync(resolved, path.join(destDir, `${name}.novamod`));
-  // Write manifest
   fs.writeFileSync(path.join(destDir, 'nova.mod.json'), JSON.stringify(bundle.manifest, null, 2), 'utf8');
 }