tova 0.7.0 → 0.8.2

package/bin/tova.js

@@ -70,6 +70,8 @@ Commands:
   info             Show Tova version, Bun version, project config, and installed dependencies
   doctor           Check your development environment
   completions <sh> Generate shell completions (bash, zsh, fish)
+  deploy <env>     Deploy to a server (--plan, --rollback, --logs, --status)
+  env <env> <cmd>  Manage secrets (list, set KEY=value)
   explain <code>   Show detailed explanation for an error/warning code (e.g., tova explain E202)
 
 Options:
@@ -143,6 +145,74 @@ async function main() {
     case 'remove':
       await removeDep(args[1]);
       break;
+    case 'update': {
+      const updatePkg = args[1] || null;
+      const updateConfig = resolveConfig(process.cwd());
+      const updateDeps = updatePkg
+        ? { [updatePkg]: updateConfig.dependencies?.[updatePkg] || '*' }
+        : updateConfig.dependencies || {};
+
+      if (Object.keys(updateDeps).length === 0) {
+        console.log('  No Tova dependencies to update.');
+        break;
+      }
+
+      console.log('  Checking for updates...');
+      // Delete lock file to force fresh resolution
+      const lockPath = join(process.cwd(), 'tova.lock');
+      if (existsSync(lockPath)) {
+        rmSync(lockPath);
+      }
+      await installDeps();
+      break;
+    }
+    case 'cache': {
+      const subCmd = args[1] || 'list';
+      const { getCacheDir } = await import('../src/config/module-cache.js');
+      const cacheDir = getCacheDir();
+
+      if (subCmd === 'path') {
+        console.log(cacheDir);
+      } else if (subCmd === 'list') {
+        console.log(`  Cache: ${cacheDir}\n`);
+        if (existsSync(cacheDir)) {
+          try {
+            const hosts = readdirSync(cacheDir).filter(h => !h.startsWith('.'));
+            let found = false;
+            for (const host of hosts) {
+              const hostPath = join(cacheDir, host);
+              if (!statSync(hostPath).isDirectory()) continue;
+              const owners = readdirSync(hostPath);
+              for (const owner of owners) {
+                const ownerPath = join(hostPath, owner);
+                if (!statSync(ownerPath).isDirectory()) continue;
+                const repos = readdirSync(ownerPath);
+                for (const repo of repos) {
+                  const repoPath = join(ownerPath, repo);
+                  if (!statSync(repoPath).isDirectory()) continue;
+                  const versions = readdirSync(repoPath).filter(v => v.startsWith('v'));
+                  console.log(`  ${host}/${owner}/${repo}: ${versions.join(', ') || '(empty)'}`);
+                  found = true;
+                }
+              }
+            }
+            if (!found) console.log('  (empty)');
+          } catch { console.log('  (empty)'); }
+        } else {
+          console.log('  (empty)');
+        }
+      } else if (subCmd === 'clean') {
+        if (existsSync(cacheDir)) {
+          rmSync(cacheDir, { recursive: true, force: true });
+        }
+        console.log('  Cache cleared.');
+      } else {
+        console.error(`  Unknown cache subcommand: ${subCmd}`);
+        console.error('  Usage: tova cache [list|path|clean]');
+        process.exit(1);
+      }
+      break;
+    }
     case 'fmt':
       formatFile(args.slice(1));
       break;
@@ -173,6 +243,9 @@ async function main() {
     case 'migrate:status':
       await migrateStatus(args.slice(1));
       break;
+    case 'deploy':
+      await deployCommand(args.slice(1));
+      break;
     case 'explain': {
       const code = args[1];
       if (!code) {
@@ -546,6 +619,22 @@ function findTovaFiles(dir) {
   return files;
 }
 
+// ─── Deploy ──────────────────────────────────────────────────
+
+async function deployCommand(args) {
+  const { parseDeployArgs } = await import('../src/deploy/deploy.js');
+  const deployArgs = parseDeployArgs(args);
+
+  if (!deployArgs.envName && !deployArgs.list) {
+    console.error(color.red('Error: deploy requires an environment name (e.g., tova deploy prod)'));
+    process.exit(1);
+  }
+
+  // For now, just parse and build — full SSH deployment is wired in integration
+  console.log(color.cyan('Deploy feature is being implemented...'));
+  console.log('Parsed args:', deployArgs);
+}
+
 // ─── Run ────────────────────────────────────────────────────
 
 async function runFile(filePath, options = {}) {
@@ -1912,6 +2001,62 @@ async function installDeps() {
     return;
   }
 
+  // Resolve Tova module dependencies (if any)
+  const tovaDeps = config.dependencies || {};
+  const { isTovModule: _isTovMod } = await import('../src/config/module-path.js');
+  const tovModuleKeys = Object.keys(tovaDeps).filter(k => _isTovMod(k));
+
+  if (tovModuleKeys.length > 0) {
+    const { resolveDependencies } = await import('../src/config/resolver.js');
+    const { listRemoteTags, fetchModule, getCommitSha } = await import('../src/config/git-resolver.js');
+    const { isVersionCached, getModuleCachePath } = await import('../src/config/module-cache.js');
+    const { readLockFile, writeLockFile } = await import('../src/config/lock-file.js');
+
+    console.log('  Resolving Tova dependencies...');
+
+    const lock = readLockFile(cwd);
+    const tovaModuleDeps = {};
+    for (const k of tovModuleKeys) {
+      tovaModuleDeps[k] = tovaDeps[k];
+    }
+
+    try {
+      const { resolved, npmDeps } = await resolveDependencies(tovaModuleDeps, {
+        getAvailableVersions: async (mod) => {
+          if (lock?.modules?.[mod]) return [lock.modules[mod].version];
+          const tags = await listRemoteTags(mod);
+          return tags.map(t => t.version);
+        },
+        getModuleConfig: async (mod, version) => {
+          if (!isVersionCached(mod, version)) {
+            console.log(`  Fetching ${mod}@v${version}...`);
+            await fetchModule(mod, version);
+          }
+          const modPath = getModuleCachePath(mod, version);
+          try {
+            return resolveConfig(modPath);
+          } catch { return null; }
+        },
+        getVersionSha: async (mod, version) => {
+          if (lock?.modules?.[mod]?.sha) return lock.modules[mod].sha;
+          return await getCommitSha(mod, version);
+        },
+      });
+
+      writeLockFile(cwd, resolved, npmDeps);
+      console.log(`  Resolved ${Object.keys(resolved).length} Tova module(s)`);
+
+      // Merge transitive npm deps into config for package.json generation
+      if (Object.keys(npmDeps).length > 0) {
+        if (!config.npm) config.npm = {};
+        if (!config.npm.prod) config.npm.prod = {};
+        Object.assign(config.npm.prod, npmDeps);
+      }
+    } catch (err) {
+      console.error(`  Failed to resolve Tova dependencies: ${err.message}`);
+    }
+  }
+
   // Generate shadow package.json from tova.toml
   const wrote = writePackageJson(config, cwd);
   if (wrote) {
@@ -1920,7 +2065,9 @@ async function installDeps() {
     const code = await new Promise(res => proc.on('close', res));
     process.exit(code);
   } else {
-    console.log('  No npm dependencies in tova.toml. Nothing to install.\n');
+    if (tovModuleKeys.length === 0) {
+      console.log('  No npm dependencies in tova.toml. Nothing to install.\n');
+    }
   }
 }
 
@@ -1985,21 +2132,56 @@ async function addDep(args) {
     await installDeps();
   } else {
     // Tova native dependency
-    let name = actualPkg;
-    let source = actualPkg;
+    const { isTovModule: isTovMod } = await import('../src/config/module-path.js');
+
+    // Parse potential @version suffix
+    let pkgName = actualPkg;
+    let versionConstraint = null;
+    if (pkgName.includes('@') && !pkgName.startsWith('@')) {
+      const atIdx = pkgName.lastIndexOf('@');
+      versionConstraint = pkgName.slice(atIdx + 1);
+      pkgName = pkgName.slice(0, atIdx);
+    }
+
+    if (isTovMod(pkgName)) {
+      // Tova module: fetch tags, pick version, add to [dependencies]
+      const { listRemoteTags, pickLatestTag } = await import('../src/config/git-resolver.js');
+      try {
+        const tags = await listRemoteTags(pkgName);
+        if (tags.length === 0) {
+          console.error(`  No version tags found for ${pkgName}`);
+          process.exit(1);
+        }
+        if (!versionConstraint) {
+          const latest = pickLatestTag(tags);
+          versionConstraint = `^${latest.version}`;
+        }
+        addToSection(tomlPath, 'dependencies', `"${pkgName}"`, versionConstraint);
+        console.log(`  Added ${pkgName}@${versionConstraint} to [dependencies] in tova.toml`);
+        await installDeps();
+      } catch (err) {
+        console.error(`  Failed to add ${pkgName}: ${err.message}`);
+        process.exit(1);
+      }
+      return;
+    }
+
+    // Local path or generic dependency
+    let name = pkgName;
+    let source = pkgName;
 
     // Detect source type
-    if (actualPkg.startsWith('file:') || actualPkg.startsWith('./') || actualPkg.startsWith('../') || actualPkg.startsWith('/')) {
+    if (pkgName.startsWith('file:') || pkgName.startsWith('./') || pkgName.startsWith('../') || pkgName.startsWith('/')) {
       // Local path dependency
-      source = actualPkg.startsWith('file:') ? actualPkg : `file:${actualPkg}`;
-      name = basename(actualPkg.replace(/^file:/, ''));
-    } else if (actualPkg.startsWith('git:') || actualPkg.includes('github.com/') || actualPkg.includes('.git')) {
+      source = pkgName.startsWith('file:') ? pkgName : `file:${pkgName}`;
+      name = basename(pkgName.replace(/^file:/, ''));
+    } else if (pkgName.startsWith('git:') || pkgName.includes('.git')) {
       // Git dependency
-      source = actualPkg.startsWith('git:') ? actualPkg : `git:${actualPkg}`;
-      name = basename(actualPkg.replace(/\.git$/, '').replace(/^git:/, ''));
+      source = pkgName.startsWith('git:') ? pkgName : `git:${pkgName}`;
+      name = basename(pkgName.replace(/\.git$/, '').replace(/^git:/, ''));
     } else {
       // Tova registry package (future: for now, just store the name)
-      source = `*`;
+      source = versionConstraint || `*`;
     }
 
     addToSection(tomlPath, 'dependencies', name, source);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tova",
-  "version": "0.7.0",
+  "version": "0.8.2",
   "description": "Tova — a modern programming language that transpiles to JavaScript, unifying frontend and backend",
   "type": "module",
   "main": "src/index.js",
@@ -36,12 +36,7 @@
     "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",

package/src/analyzer/analyzer.js

@@ -900,6 +900,19 @@ export class Analyzer {
         }
         this.visitExpression(node.argument);
         return;
+      case 'SpawnExpression':
+        if (!this._concurrentDepth) {
+          this.warn("'spawn' should be used inside a 'concurrent' block", node.loc, null, {
+            code: 'W_SPAWN_OUTSIDE_CONCURRENT',
+          });
+        }
+        if (node.callee) this.visitExpression(node.callee);
+        if (node.arguments) {
+          for (const arg of node.arguments) {
+            this.visitExpression(arg);
+          }
+        }
+        return;
       case 'YieldExpression':
         if (node.argument) this.visitExpression(node.argument);
         return;
@@ -1019,6 +1032,123 @@ export class Analyzer {
     }
   }
 
+  visitConcurrentBlock(node) {
+    // Validate mode
+    const validModes = new Set(['all', 'cancel_on_error', 'first', 'timeout']);
+    if (!validModes.has(node.mode)) {
+      this.warn(`Unknown concurrent block mode '${node.mode}'`, node.loc, null, {
+        code: 'W_UNKNOWN_CONCURRENT_MODE',
+      });
+    }
+
+    // Validate timeout
+    if (node.mode === 'timeout' && !node.timeout) {
+      this.warn("concurrent timeout mode requires a timeout value", node.loc, null, {
+        code: 'W_MISSING_TIMEOUT',
+      });
+    }
+
+    // Warn on empty block
+    if (node.body.length === 0) {
+      this.warn("Empty concurrent block", node.loc, null, {
+        code: 'W_EMPTY_CONCURRENT',
+      });
+    }
+
+    // Track concurrent depth for spawn validation
+    this._concurrentDepth = (this._concurrentDepth || 0) + 1;
+
+    // Visit body statements (concurrent block does NOT create a new scope —
+    // variables assigned inside should be visible after the block)
+    for (const stmt of node.body) {
+      this.visitNode(stmt);
+    }
+
+    // Check spawned functions for WASM compatibility — warn if mixed WASM/non-WASM
+    let hasWasm = false;
+    let hasNonWasm = false;
+    for (const stmt of node.body) {
+      const spawn = (stmt.type === 'Assignment' && stmt.values && stmt.values[0] && stmt.values[0].type === 'SpawnExpression')
+        ? stmt.values[0]
+        : (stmt.type === 'ExpressionStatement' && stmt.expression && stmt.expression.type === 'SpawnExpression')
+          ? stmt.expression
+          : null;
+      if (!spawn) continue;
+      const calleeName = spawn.callee && spawn.callee.type === 'Identifier' ? spawn.callee.name : null;
+      if (calleeName) {
+        const sym = this.currentScope.lookup(calleeName);
+        if (sym && sym.isWasm) {
+          hasWasm = true;
+        } else {
+          hasNonWasm = true;
+        }
+      } else {
+        // Lambda or complex expression — always non-WASM
+        hasNonWasm = true;
+      }
+    }
+    if (hasWasm && hasNonWasm) {
+      this.warn(
+        "concurrent block mixes @wasm and non-WASM tasks — non-WASM tasks will fall back to async JS execution",
+        node.loc, null, { code: 'W_SPAWN_WASM_FALLBACK' }
+      );
+    }
+
+    this._concurrentDepth--;
+  }
+
+  visitSelectStatement(node) {
+    if (node.cases.length === 0) {
+      this.warn("Empty select block", node.loc, null, {
+        code: 'W_EMPTY_SELECT',
+      });
+    }
+
+    let defaultCount = 0;
+    let timeoutCount = 0;
+    for (const c of node.cases) {
+      if (c.kind === 'default') defaultCount++;
+      if (c.kind === 'timeout') timeoutCount++;
+    }
+
+    if (defaultCount > 1) {
+      this.warn("select block has multiple default cases", node.loc, null, {
+        code: 'W_DUPLICATE_SELECT_DEFAULT',
+      });
+    }
+    if (timeoutCount > 1) {
+      this.warn("select block has multiple timeout cases", node.loc, null, {
+        code: 'W_DUPLICATE_SELECT_TIMEOUT',
+      });
+    }
+    if (defaultCount > 0 && timeoutCount > 0) {
+      this.warn("select block has both default and timeout — default makes timeout unreachable", node.loc, null, {
+        code: 'W_SELECT_DEFAULT_TIMEOUT',
+      });
+    }
+
+    // Visit each case's expressions and body
+    for (const c of node.cases) {
+      if (c.channel) this.visitNode(c.channel);
+      if (c.value) this.visitNode(c.value);
+
+      if (c.kind === 'receive' && c.binding) {
+        // Create scope for the binding variable
+        this.pushScope('select-case');
+        this.currentScope.define(c.binding,
+          new Symbol(c.binding, 'variable', null, false, c.loc));
+        for (const stmt of c.body) {
+          this.visitNode(stmt);
+        }
+        this.popScope();
+      } else {
+        for (const stmt of c.body) {
+          this.visitNode(stmt);
+        }
+      }
+    }
+  }
+
   _validateCliCrossBlock() {
     const cliBlocks = this.ast.body.filter(n => n.type === 'CliBlock');
     if (cliBlocks.length === 0) return;
@@ -1614,9 +1744,10 @@ export class Analyzer {
     } else if (node.pattern.type === 'ArrayPattern' || node.pattern.type === 'TuplePattern') {
       for (const el of node.pattern.elements) {
         if (el) {
+          const varName = el.startsWith('...') ? el.slice(3) : el;
           try {
-            this.currentScope.define(el,
-              new Symbol(el, 'variable', null, false, node.loc));
+            this.currentScope.define(varName,
+              new Symbol(varName, 'variable', null, false, node.loc));
           } catch (e) {
             this.error(e.message);
           }
@@ -1634,6 +1765,7 @@ export class Analyzer {
       sym._paramTypes = node.params.map(p => p.typeAnnotation || null);
       sym._typeParams = node.typeParams || [];
       sym.isPublic = node.isPublic || false;
+      sym.isWasm = !!(node.decorators && node.decorators.some(d => d.name === 'wasm'));
       this.currentScope.define(node.name, sym);
     } catch (e) {
       this.error(e.message);

package/src/analyzer/deploy-analyzer.js

@@ -0,0 +1,44 @@
+// Deploy-specific analyzer methods for the Tova language
+// Extracted from analyzer.js for lazy loading — only loaded when deploy { } blocks are encountered.
+
+const KNOWN_DEPLOY_FIELDS = new Set([
+  'server', 'domain', 'instances', 'memory', 'branch',
+  'health', 'health_interval', 'health_timeout',
+  'restart_on_failure', 'keep_releases',
+]);
+
+const REQUIRED_DEPLOY_FIELDS = ['server', 'domain'];
+
+export function installDeployAnalyzer(AnalyzerClass) {
+  if (AnalyzerClass.prototype._deployAnalyzerInstalled) return;
+  AnalyzerClass.prototype._deployAnalyzerInstalled = true;
+
+  AnalyzerClass.prototype.visitDeployBlock = function(node) {
+    // Collect config field keys present in the deploy block body
+    const presentFields = new Set();
+    for (const stmt of node.body) {
+      if (stmt.type === 'DeployConfigField') {
+        // Validate unknown fields
+        if (!KNOWN_DEPLOY_FIELDS.has(stmt.key)) {
+          this.error(
+            `Unknown deploy config field "${stmt.key}"`,
+            stmt.loc,
+            `Known fields: ${[...KNOWN_DEPLOY_FIELDS].join(', ')}`
+          );
+        }
+        presentFields.add(stmt.key);
+      }
+      // DeployEnvBlock and DeployDbBlock are valid sub-blocks — no additional validation needed
+    }
+
+    // Validate required fields
+    for (const required of REQUIRED_DEPLOY_FIELDS) {
+      if (!presentFields.has(required)) {
+        this.error(
+          `Deploy block "${node.name}" is missing required field "${required}"`,
+          node.loc
+        );
+      }
+    }
+  };
+}