tova 0.5.0 → 0.7.0

package/bin/tova.js

@@ -3,7 +3,7 @@
 import { resolve, basename, dirname, join, relative } from 'path';
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, copyFileSync, rmSync, chmodSync, renameSync, watch as fsWatch } from 'fs';
 import { spawn } from 'child_process';
-// Bun.hash used instead of crypto.createHash for faster hashing
+import { createHash as _cryptoHash } from 'crypto';
 import { Lexer } from '../src/lexer/lexer.js';
 import { Parser } from '../src/parser/parser.js';
 import { Analyzer } from '../src/analyzer/analyzer.js';
@@ -36,9 +36,9 @@ const color = {
 };
 
 const HELP = `
-  ╦  ╦ ╦═╗ ╦
-  ║  ║ ║ ║ ╠╣
-  ╩═╝╚═╝╩═╝╩  v${VERSION}
+  ╔╦╗╔═╗╦  ╦╔═╗
+   ║ ║ ║╚╗╔╝╠═╣
+   ╩ ╚═╝ ╚╝ ╩ ╩  v${VERSION}
 
   Created by Enoch Kujem Abassey
   A modern full-stack language that transpiles to JavaScript
@@ -601,6 +601,18 @@ async function runFile(filePath, options = {}) {
     const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
     const stdlib = getRunStdlib();
 
+    // CLI mode: execute the cli code directly
+    if (output.isCli) {
+      let code = stdlib + '\n' + output.cli;
+      code = code.replace(/^export /gm, '');
+      // Override process.argv for cli dispatch
+      const scriptArgs = options.scriptArgs || [];
+      code = `process.argv = ["node", ${JSON.stringify(resolved)}, ...${JSON.stringify(scriptArgs)}];\n` + code;
+      const fn = new AsyncFunction('__tova_args', '__tova_filename', '__tova_dirname', code);
+      await fn(scriptArgs, resolved, dirname(resolved));
+      return;
+    }
+
     // Compile .tova dependencies and inline them
     let depCode = '';
     if (hasTovaImports) {
@@ -616,7 +628,7 @@ async function runFile(filePath, options = {}) {
       }
     }
 
-    let code = stdlib + '\n' + depCode + (output.shared || '') + '\n' + (output.server || output.client || '');
+    let code = stdlib + '\n' + depCode + (output.shared || '') + '\n' + (output.server || output.browser || '');
     // Strip 'export ' keywords — not valid inside AsyncFunction (used in tova build only)
     code = code.replace(/^export /gm, '');
     // Strip import lines for local modules (already inlined above)
@@ -766,8 +778,29 @@ async function buildProject(args) {
       const outSubDir = dirname(join(outDir, outBaseName));
       if (outSubDir !== outDir) mkdirSync(outSubDir, { recursive: true });
 
+      // CLI files: write single executable <name>.js with shebang
+      if (output.isCli) {
+        if (output.cli && output.cli.trim()) {
+          const cliPath = join(outDir, `${outBaseName}.js`);
+          const shebang = '#!/usr/bin/env node\n';
+          writeFileSync(cliPath, shebang + output.cli);
+          try { chmodSync(cliPath, 0o755); } catch (e) { /* ignore on Windows */ }
+          if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', cliPath)} [cli]${timing}`);
+        }
+        if (!noCache) {
+          const outputPaths = {};
+          if (output.cli && output.cli.trim()) outputPaths.cli = join(outDir, `${outBaseName}.js`);
+          if (single) {
+            const absFile = files[0];
+            const sourceContent = readFileSync(absFile, 'utf-8');
+            buildCache.set(absFile, sourceContent, outputPaths);
+          } else {
+            buildCache.setGroup(`dir:${dir}`, files, outputPaths);
+          }
+        }
+      }
       // Module files: write single <name>.js (not .shared.js)
-      if (output.isModule) {
+      else if (output.isModule) {
         if (output.shared && output.shared.trim()) {
           const modulePath = join(outDir, `${outBaseName}.js`);
           writeFileSync(modulePath, generateSourceMap(output.shared, modulePath));
@@ -800,11 +833,18 @@ async function buildProject(args) {
           if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', serverPath)}${timing}`);
         }
 
-        // Write default client
-        if (output.client) {
-          const clientPath = join(outDir, `${outBaseName}.client.js`);
-          writeFileSync(clientPath, generateSourceMap(output.client, clientPath));
-          if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', clientPath)}${timing}`);
+        // Write default browser
+        if (output.browser) {
+          const browserPath = join(outDir, `${outBaseName}.browser.js`);
+          writeFileSync(browserPath, generateSourceMap(output.browser, browserPath));
+          if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', browserPath)}${timing}`);
+        }
+
+        // Write default edge
+        if (output.edge) {
+          const edgePath = join(outDir, `${outBaseName}.edge.js`);
+          writeFileSync(edgePath, generateSourceMap(output.edge, edgePath));
+          if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', edgePath)} [edge]${timing}`);
         }
 
         // Write named server blocks (multi-block)
@@ -817,13 +857,23 @@ async function buildProject(args) {
           }
         }
 
-        // Write named client blocks (multi-block)
-        if (output.multiBlock && output.clients) {
-          for (const [name, code] of Object.entries(output.clients)) {
+        // Write named edge blocks (multi-block)
+        if (output.multiBlock && output.edges) {
+          for (const [name, code] of Object.entries(output.edges)) {
+            if (name === 'default') continue;
+            const path = join(outDir, `${outBaseName}.edge.${name}.js`);
+            writeFileSync(path, code);
+            if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', path)} [edge:${name}]${timing}`);
+          }
+        }
+
+        // Write named browser blocks (multi-block)
+        if (output.multiBlock && output.browsers) {
+          for (const [name, code] of Object.entries(output.browsers)) {
             if (name === 'default') continue;
-            const path = join(outDir, `${outBaseName}.client.${name}.js`);
+            const path = join(outDir, `${outBaseName}.browser.${name}.js`);
             writeFileSync(path, code);
-            if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', path)} [client:${name}]${timing}`);
+            if (!isQuiet) console.log(`  ✓ ${relLabel} → ${relative('.', path)} [browser:${name}]${timing}`);
           }
         }
 
@@ -832,7 +882,7 @@ async function buildProject(args) {
           const outputPaths = {};
           if (output.shared && output.shared.trim()) outputPaths.shared = join(outDir, `${outBaseName}.shared.js`);
           if (output.server) outputPaths.server = join(outDir, `${outBaseName}.server.js`);
-          if (output.client) outputPaths.client = join(outDir, `${outBaseName}.client.js`);
+          if (output.browser) outputPaths.browser = join(outDir, `${outBaseName}.browser.js`);
           if (single) {
             const absFile = files[0];
             const sourceContent = readFileSync(absFile, 'utf-8');
@@ -1083,10 +1133,10 @@ async function devServer(args) {
         writeFileSync(join(outDir, `${outBaseName}.shared.js`), output.shared);
       }
 
-      if (output.client) {
-        const p = join(outDir, `${outBaseName}.client.js`);
-        writeFileSync(p, output.client);
-        clientHTML = await generateDevHTML(output.client, srcDir, actualReloadPort);
+      if (output.browser) {
+        const p = join(outDir, `${outBaseName}.browser.js`);
+        writeFileSync(p, output.browser);
+        clientHTML = await generateDevHTML(output.browser, srcDir, actualReloadPort);
         writeFileSync(join(outDir, 'index.html'), clientHTML);
         hasClient = true;
       }
@@ -1117,10 +1167,10 @@ async function devServer(args) {
       }
     }
 
-    if (output.multiBlock && output.clients) {
-      for (const [name, code] of Object.entries(output.clients)) {
+    if (output.multiBlock && output.browsers) {
+      for (const [name, code] of Object.entries(output.browsers)) {
         if (name === 'default') continue;
-        const p = join(outDir, `${outBaseName}.client.${name}.js`);
+        const p = join(outDir, `${outBaseName}.browser.${name}.js`);
         writeFileSync(p, code);
       }
     }
@@ -1231,9 +1281,9 @@ async function devServer(args) {
         if (output.shared && output.shared.trim()) {
           writeFileSync(join(outDir, `${outBaseName}.shared.js`), output.shared);
         }
-        if (output.client) {
-          writeFileSync(join(outDir, `${outBaseName}.client.js`), output.client);
-          rebuildClientHTML = await generateDevHTML(output.client, srcDir, actualReloadPort);
+        if (output.browser) {
+          writeFileSync(join(outDir, `${outBaseName}.browser.js`), output.browser);
+          rebuildClientHTML = await generateDevHTML(output.browser, srcDir, actualReloadPort);
           writeFileSync(join(outDir, 'index.html'), rebuildClientHTML);
         }
         if (output.server) {
@@ -2507,7 +2557,7 @@ async function startRepl() {
     'in', 'return', 'match', 'type', 'import', 'from', 'and', 'or', 'not',
     'try', 'catch', 'finally', 'break', 'continue', 'async', 'await',
     'guard', 'interface', 'derive', 'pub', 'impl', 'trait', 'defer',
-    'yield', 'extern', 'is', 'with', 'as', 'export', 'server', 'client', 'shared',
+    'yield', 'extern', 'is', 'with', 'as', 'export', 'server', 'client', 'browser', 'shared',
   ]);
 
   const TYPE_NAMES = new Set([
@@ -3007,7 +3057,7 @@ async function binaryBuild(srcDir, outputName, outDir) {
   // Step 1: Compile all .tova files to JS
   const sharedParts = [];
   const serverParts = [];
-  const clientParts = [];
+  const browserParts = [];
 
   for (const file of tovaFiles) {
     try {
@@ -3015,7 +3065,7 @@ async function binaryBuild(srcDir, outputName, outDir) {
       const output = compileTova(source, file);
       if (output.shared) sharedParts.push(output.shared);
       if (output.server) serverParts.push(output.server);
-      if (output.client) clientParts.push(output.client);
+      if (output.browser) browserParts.push(output.browser);
     } catch (err) {
       console.error(`  Error in ${relative(srcDir, file)}: ${err.message}`);
       process.exit(1);
@@ -3085,7 +3135,7 @@ async function productionBuild(srcDir, outDir) {
 
   console.log(`\n  Production build...\n`);
 
-  const clientParts = [];
+  const browserParts = [];
   const serverParts = [];
   const sharedParts = [];
   let cssContent = '';
@@ -3097,14 +3147,14 @@ async function productionBuild(srcDir, outDir) {
 
       if (output.shared) sharedParts.push(output.shared);
       if (output.server) serverParts.push(output.server);
-      if (output.client) clientParts.push(output.client);
+      if (output.browser) browserParts.push(output.browser);
     } catch (err) {
       console.error(`  Error in ${relative(srcDir, file)}: ${err.message}`);
       process.exit(1);
     }
   }
 
-  const allClientCode = clientParts.join('\n');
+  const allClientCode = browserParts.join('\n');
   const allServerCode = serverParts.join('\n');
   const allSharedCode = sharedParts.join('\n');
 
@@ -3452,7 +3502,8 @@ class BuildCache {
   }
 
   _hashContent(content) {
-    return Bun.hash(content).toString(16);
+    if (typeof Bun !== 'undefined' && Bun.hash) return Bun.hash(content).toString(16);
+    return _cryptoHash('md5').update(content).digest('hex');
   }
 
   load() {
@@ -3493,7 +3544,8 @@ class BuildCache {
     for (const f of files.slice().sort()) {
       combined += f + readFileSync(f, 'utf-8');
     }
-    return Bun.hash(combined).toString(16);
+    if (typeof Bun !== 'undefined' && Bun.hash) return Bun.hash(combined).toString(16);
+    return _cryptoHash('md5').update(combined).digest('hex');
   }
 
   // Store compiled output for a multi-file group
@@ -3565,7 +3617,7 @@ function getCompiledExtension(tovaPath) {
       const lexer = new Lexer(src, tovaPath);
       const tokens = lexer.tokenize();
       // Check if any top-level token is a block keyword (shared/server/client/test/bench/data)
-      const BLOCK_KEYWORDS = new Set(['shared', 'server', 'client', 'test', 'bench', 'data']);
+      const BLOCK_KEYWORDS = new Set(['shared', 'server', 'client', 'browser', 'test', 'bench', 'data']);
       let depth = 0;
       for (const tok of tokens) {
         if (tok.type === 'LBRACE') depth++;
@@ -3692,7 +3744,7 @@ function collectExports(ast, filename) {
 
   for (const node of ast.body) {
     // Also collect exports from inside shared/server/client blocks
-    if (node.type === 'SharedBlock' || node.type === 'ServerBlock' || node.type === 'ClientBlock') {
+    if (node.type === 'SharedBlock' || node.type === 'ServerBlock' || node.type === 'BrowserBlock') {
       if (node.body) {
         for (const inner of node.body) {
           collectFromNode(inner);
@@ -3722,7 +3774,7 @@ function compileWithImports(source, filename, srcDir) {
     const ast = parser.parse();
 
     // Cache module type from AST (avoids regex heuristic on subsequent lookups)
-    const hasBlocks = ast.body.some(n => n.type === 'SharedBlock' || n.type === 'ServerBlock' || n.type === 'ClientBlock' || n.type === 'TestBlock' || n.type === 'BenchBlock' || n.type === 'DataBlock');
+    const hasBlocks = ast.body.some(n => n.type === 'SharedBlock' || n.type === 'ServerBlock' || n.type === 'BrowserBlock' || n.type === 'TestBlock' || n.type === 'BenchBlock' || n.type === 'DataBlock');
     moduleTypeCache.set(filename, hasBlocks ? '.shared.js' : '.js');
 
     // Collect this module's exports for validation
@@ -3820,32 +3872,32 @@ function validateMergedAST(mergedBlocks, sourceFiles) {
     );
   }
 
-  // Check client blocks — top-level declarations only
-  const clientDecls = { component: new Map(), state: new Map(), computed: new Map(), store: new Map(), fn: new Map() };
-  for (const block of mergedBlocks.clientBlocks) {
+  // Check browser blocks — top-level declarations only
+  const browserDecls = { component: new Map(), state: new Map(), computed: new Map(), store: new Map(), fn: new Map() };
+  for (const block of mergedBlocks.browserBlocks) {
     for (const stmt of block.body) {
       const loc = stmt.loc || block.loc;
       if (stmt.type === 'ComponentDeclaration') {
-        if (clientDecls.component.has(stmt.name)) addDup('component', stmt.name, clientDecls.component.get(stmt.name), loc);
-        else clientDecls.component.set(stmt.name, loc);
+        if (browserDecls.component.has(stmt.name)) addDup('component', stmt.name, browserDecls.component.get(stmt.name), loc);
+        else browserDecls.component.set(stmt.name, loc);
       } else if (stmt.type === 'StateDeclaration') {
         const name = stmt.name || (stmt.targets && stmt.targets[0]);
         if (name) {
-          if (clientDecls.state.has(name)) addDup('state', name, clientDecls.state.get(name), loc);
-          else clientDecls.state.set(name, loc);
+          if (browserDecls.state.has(name)) addDup('state', name, browserDecls.state.get(name), loc);
+          else browserDecls.state.set(name, loc);
         }
       } else if (stmt.type === 'ComputedDeclaration') {
         const name = stmt.name;
         if (name) {
-          if (clientDecls.computed.has(name)) addDup('computed', name, clientDecls.computed.get(name), loc);
-          else clientDecls.computed.set(name, loc);
+          if (browserDecls.computed.has(name)) addDup('computed', name, browserDecls.computed.get(name), loc);
+          else browserDecls.computed.set(name, loc);
         }
       } else if (stmt.type === 'StoreDeclaration') {
-        if (clientDecls.store.has(stmt.name)) addDup('store', stmt.name, clientDecls.store.get(stmt.name), loc);
-        else clientDecls.store.set(stmt.name, loc);
+        if (browserDecls.store.has(stmt.name)) addDup('store', stmt.name, browserDecls.store.get(stmt.name), loc);
+        else browserDecls.store.set(stmt.name, loc);
       } else if (stmt.type === 'FunctionDeclaration') {
-        if (clientDecls.fn.has(stmt.name)) addDup('function', stmt.name, clientDecls.fn.get(stmt.name), loc);
-        else clientDecls.fn.set(stmt.name, loc);
+        if (browserDecls.fn.has(stmt.name)) addDup('function', stmt.name, browserDecls.fn.get(stmt.name), loc);
+        else browserDecls.fn.set(stmt.name, loc);
       }
     }
   }
@@ -3989,7 +4041,7 @@ function mergeDirectory(dir, srcDir, options = {}) {
   const mergedBody = [];
   const sharedBlocks = [];
   const serverBlocks = [];
-  const clientBlocks = [];
+  const browserBlocks = [];
 
   for (const { file, ast } of parsedFiles) {
     for (const node of ast.body) {
@@ -4010,14 +4062,14 @@ function mergeDirectory(dir, srcDir, options = {}) {
 
       if (node.type === 'SharedBlock') sharedBlocks.push(node);
       else if (node.type === 'ServerBlock') serverBlocks.push(node);
-      else if (node.type === 'ClientBlock') clientBlocks.push(node);
+      else if (node.type === 'BrowserBlock') browserBlocks.push(node);
 
       mergedBody.push(node);
     }
   }
 
   // Validate for duplicate declarations across files
-  validateMergedAST({ sharedBlocks, serverBlocks, clientBlocks }, tovaFiles);
+  validateMergedAST({ sharedBlocks, serverBlocks, browserBlocks }, tovaFiles);
 
   // Build merged Program AST
   const mergedAST = new Program(mergedBody);
@@ -4655,9 +4707,9 @@ async function infoCommand() {
   const config = resolveConfig(process.cwd());
   const hasTOML = config._source === 'tova.toml';
 
-  console.log(`\n  ╦  ╦ ╦═╗ ╦`);
-  console.log(`  ║  ║ ║ ║ ╠╣`);
-  console.log(`  ╩═╝╚═╝╩═╝╩  v${VERSION}\n`);
+  console.log(`\n  ╔╦╗╔═╗╦  ╦╔═╗`);
+  console.log(`   ║ ║ ║╚╗╔╝╠═╣`);
+  console.log(`   ╩ ╚═╝ ╚╝ ╩ ╩  v${VERSION}\n`);
 
   // Bun version
   let bunVersion = 'not found';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tova",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Tova — a modern programming language that transpiles to JavaScript, unifying frontend and backend",
   "type": "module",
   "main": "src/index.js",
@@ -36,7 +36,12 @@
     "url": "https://github.com/tova-lang/tova-lang/issues"
   },
   "author": "Enoch Kujem Abassey",
-  "keywords": ["language", "transpiler", "fullstack", "javascript"],
+  "keywords": [
+    "language",
+    "transpiler",
+    "fullstack",
+    "javascript"
+  ],
   "license": "MIT",
   "devDependencies": {
     "@codemirror/autocomplete": "^6.20.0",