tova 0.7.0 → 0.8.2

package/src/codegen/codegen.js

@@ -36,6 +36,12 @@ function getEdgeCodegen() {
   return _EdgeCodegen;
 }
 
+let _DeployCodegen;
+function getDeployCodegen() {
+  if (!_DeployCodegen) _DeployCodegen = _require('./deploy-codegen.js').DeployCodegen;
+  return _DeployCodegen;
+}
+
 export class CodeGenerator {
   constructor(ast, filename = '<stdin>', options = {}) {
     this.ast = ast;
@@ -87,6 +93,7 @@ export class CodeGenerator {
     const dataBlocks = getBlocks('data');
     const securityBlocks = getBlocks('security');
     const edgeBlocks = getBlocks('edge');
+    const deployBlocks = getBlocks('deploy');
 
     // Detect module mode: no blocks, only top-level statements
     const hasAnyBlocks = BlockRegistry.all().some(p => getBlocks(p.name).length > 0);
@@ -232,6 +239,17 @@ export class CodeGenerator {
       }
     }
 
+    // Generate deploy configs (one per named block)
+    const deploys = {};
+    if (deployBlocks.length > 0) {
+      const Deploy = getDeployCodegen();
+      const deployGroups = this._groupByName(deployBlocks);
+      for (const [name, blocks] of deployGroups) {
+        const key = name || 'default';
+        deploys[key] = Deploy.mergeDeployBlocks(blocks);
+      }
+    }
+
     // Generate tests if test blocks exist
     let testCode = '';
     if (testBlocks.length > 0) {
@@ -267,6 +285,7 @@ export class CodeGenerator {
         browser: browserCode,
         client: browserCode,  // deprecated alias for backward compat
         edge: edges['default'] || '',
+        deploy: Object.keys(deploys).length > 0 ? deploys : undefined,
         sourceMappings,
         _sourceFile: this.filename,
       };
@@ -287,6 +306,7 @@ export class CodeGenerator {
       browsers,  // { "admin": code, "dashboard": code, ... }
       clients: browsers,   // deprecated alias for backward compat
       edges,     // { "api": code, "assets": code, ... }
+      deploy: Object.keys(deploys).length > 0 ? deploys : undefined,
       multiBlock: true,
       sourceMappings,
       _sourceFile: this.filename,

package/src/codegen/deploy-codegen.js

@@ -0,0 +1,49 @@
+// Deploy-specific codegen for the Tova language
+// Produces a configuration manifest (plain JS object) from deploy block AST nodes.
+
+const DEFAULTS = {
+  instances: 1,
+  memory: '512mb',
+  branch: 'main',
+  health: '/healthz',
+  health_interval: 30,
+  health_timeout: 5,
+  restart_on_failure: true,
+  keep_releases: 5,
+};
+
+export class DeployCodegen {
+  static mergeDeployBlocks(blocks) {
+    const config = { ...DEFAULTS, env: {}, databases: [] };
+    for (const block of blocks) {
+      config.name = block.name;
+      for (const stmt of block.body) {
+        switch (stmt.type) {
+          case 'DeployConfigField': {
+            // Extract literal value from AST expression
+            const val = stmt.value;
+            config[stmt.key] = val.value !== undefined ? val.value : val;
+            break;
+          }
+          case 'DeployEnvBlock': {
+            for (const entry of stmt.entries) {
+              config.env[entry.key] = entry.value.value !== undefined ? entry.value.value : entry.value;
+            }
+            break;
+          }
+          case 'DeployDbBlock': {
+            const dbConfig = {};
+            if (stmt.config && typeof stmt.config === 'object') {
+              for (const [k, v] of Object.entries(stmt.config)) {
+                dbConfig[k] = v.value !== undefined ? v.value : v;
+              }
+            }
+            config.databases.push({ engine: stmt.engine, config: dbConfig });
+            break;
+          }
+        }
+      }
+    }
+    return config;
+  }
+}

package/src/codegen/shared-codegen.js

@@ -10,6 +10,11 @@ export class SharedCodegen extends BaseCodegen {
   // Generate any needed helpers (called after all code is generated)
   generateHelpers() {
     const helpers = [];
+    // Runtime bridge for WASM-Tokio concurrent execution
+    if (this._needsRuntimeBridge) {
+      // Try multiple paths: relative to script, package require, absolute from process.cwd()
+      helpers.push(`let __tova_rt = null; try { const __p = require('path'); const __d = __p.dirname(typeof __filename !== 'undefined' ? __filename : process.argv[1] || ''); const __candidates = [__p.join(__d, '..', 'src', 'stdlib', 'runtime-bridge.js'), __p.join(process.cwd(), 'src', 'stdlib', 'runtime-bridge.js')]; for (const __c of __candidates) { try { __tova_rt = require(__c); break; } catch(_) {} } } catch(_) {}`);
+    }
     helpers.push(this.getStringProtoHelper());
     // Only include Result/Option if Ok/Err/Some/None are used
     if (this._needsResultOption) {

package/src/codegen/wasm-codegen.js

@@ -602,6 +602,12 @@ export function generateWasmGlue(funcNode, wasmBytes) {
   return `const ${name} = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([${bytesStr}]))).exports.${name};`;
 }
 
+// Generate a module-level constant holding the raw WASM bytes for runtime use
+export function generateWasmBytesExport(funcName, wasmBytes) {
+  const bytesStr = Array.from(wasmBytes).join(',');
+  return `const __wasm_bytes_${funcName} = new Uint8Array([${bytesStr}]);`;
+}
+
 // Generate JS glue code for a multi-function WASM module
 export function generateMultiWasmGlue(funcNodes, wasmBytes) {
   const bytesStr = Array.from(wasmBytes).join(',');

package/src/config/edit-toml.js

@@ -28,13 +28,15 @@ export function addToSection(filePath, section, key, value) {
   const endIdx = findSectionEnd(lines, sectionIdx);
 
   // Check if key already exists in this section — update it
+  const bareKey = key.replace(/^"|"$/g, '');
   for (let i = sectionIdx + 1; i < endIdx; i++) {
     const line = lines[i].trim();
     if (line === '' || line.startsWith('#')) continue;
     const eqIdx = line.indexOf('=');
     if (eqIdx !== -1) {
       const existingKey = line.slice(0, eqIdx).trim();
-      if (existingKey === key) {
+      const existingBare = existingKey.replace(/^"|"$/g, '');
+      if (existingKey === key || existingBare === bareKey) {
         lines[i] = entry;
         writeFileSync(filePath, lines.join('\n'));
         return;
@@ -57,6 +59,7 @@ export function addToSection(filePath, section, key, value) {
 export function removeFromSection(filePath, section, key) {
   const content = readFileSync(filePath, 'utf-8');
   const lines = content.split('\n');
+  const bareKey = key.replace(/^"|"$/g, '');
 
   const sectionIdx = findSectionIndex(lines, section);
   if (sectionIdx === -1) return false;
@@ -69,7 +72,8 @@ export function removeFromSection(filePath, section, key) {
     const eqIdx = line.indexOf('=');
     if (eqIdx !== -1) {
       const existingKey = line.slice(0, eqIdx).trim();
-      if (existingKey === key) {
+      const existingBare = existingKey.replace(/^"|"$/g, '');
+      if (existingKey === key || existingBare === bareKey) {
         lines.splice(i, 1);
         writeFileSync(filePath, lines.join('\n'));
         return true;

package/src/config/git-resolver.js

@@ -0,0 +1,128 @@
+// Git resolver for the Tova package manager.
+// Handles git operations: parsing tag lists, sorting by semver,
+// picking the latest tag, and fetching modules from remote repositories.
+
+import { spawn } from 'child_process';
+import { join } from 'path';
+import { mkdirSync, renameSync, rmSync, existsSync } from 'fs';
+import { parseSemver, compareSemver } from './semver.js';
+import { moduleToGitUrl, parseModulePath } from './module-path.js';
+import { getModuleCachePath, getCacheDir } from './module-cache.js';
+
+/**
+ * Parse `git ls-remote --tags` output into an array of { version, sha } objects.
+ * Filters out non-semver tags and prefers dereferenced (^{}) SHAs for annotated tags.
+ */
+export function parseTagList(output) {
+  if (!output.trim()) return [];
+  const lines = output.trim().split('\n');
+  const tagMap = new Map();
+  for (const line of lines) {
+    const [sha, ref] = line.split('\t');
+    if (!ref || !ref.startsWith('refs/tags/')) continue;
+    const tagName = ref.replace('refs/tags/', '');
+    const isDeref = tagName.endsWith('^{}');
+    const cleanName = isDeref ? tagName.slice(0, -3) : tagName;
+    const versionStr = cleanName.startsWith('v') ? cleanName.slice(1) : cleanName;
+    try { parseSemver(versionStr); } catch { continue; }
+    if (isDeref || !tagMap.has(versionStr)) {
+      tagMap.set(versionStr, sha);
+    }
+  }
+  return Array.from(tagMap.entries()).map(([version, sha]) => ({ version, sha }));
+}
+
+/**
+ * Sort an array of { version, sha } tags by semver in ascending order.
+ * Returns a new array (does not mutate the input).
+ */
+export function sortTags(tags) {
+  return [...tags].sort((a, b) => compareSemver(a.version, b.version));
+}
+
+/**
+ * Pick the tag with the highest semver version.
+ * Returns null if the tags array is empty.
+ */
+export function pickLatestTag(tags) {
+  if (tags.length === 0) return null;
+  const sorted = sortTags(tags);
+  return sorted[sorted.length - 1];
+}
+
+/**
+ * List all semver tags from a remote git repository.
+ * Returns a promise resolving to an array of { version, sha } objects.
+ */
+export function listRemoteTags(modulePath) {
+  const gitUrl = moduleToGitUrl(modulePath);
+  return new Promise((resolve, reject) => {
+    const proc = spawn('git', ['ls-remote', '--tags', gitUrl], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', d => stdout += d);
+    proc.stderr.on('data', d => stderr += d);
+    proc.on('close', code => {
+      if (code !== 0) {
+        reject(new Error(`Failed to list tags for ${modulePath}: ${stderr.trim()}`));
+        return;
+      }
+      resolve(parseTagList(stdout));
+    });
+  });
+}
+
+/**
+ * Clone a specific version of a module into the local cache.
+ * Performs a shallow clone, removes .git directory, and moves to the cache path.
+ * Returns the destination path on success.
+ */
+export function fetchModule(modulePath, version, cacheDir) {
+  const gitUrl = moduleToGitUrl(modulePath);
+  const destPath = getModuleCachePath(modulePath, version, cacheDir);
+  const dir = getCacheDir(cacheDir);
+  const tmpPath = join(dir, '.tmp-' + Date.now());
+  return new Promise((resolve, reject) => {
+    const proc = spawn('git', [
+      'clone', '--depth', '1', '--branch', `v${version}`, gitUrl, tmpPath,
+    ], { stdio: ['pipe', 'pipe', 'pipe'] });
+    let stderr = '';
+    proc.stderr.on('data', d => stderr += d);
+    proc.on('close', code => {
+      if (code !== 0) {
+        if (existsSync(tmpPath)) rmSync(tmpPath, { recursive: true, force: true });
+        reject(new Error(`Failed to fetch ${modulePath}@v${version}: ${stderr.trim()}`));
+        return;
+      }
+      const dotGit = join(tmpPath, '.git');
+      if (existsSync(dotGit)) rmSync(dotGit, { recursive: true, force: true });
+      mkdirSync(join(destPath, '..'), { recursive: true });
+      renameSync(tmpPath, destPath);
+      resolve(destPath);
+    });
+  });
+}
+
+/**
+ * Get the commit SHA for a specific version tag from a remote repository.
+ * Prefers the dereferenced SHA for annotated tags.
+ * Returns null if the version tag is not found.
+ */
+export function getCommitSha(modulePath, version, cacheDir) {
+  const gitUrl = moduleToGitUrl(modulePath);
+  return new Promise((resolve, reject) => {
+    const proc = spawn('git', ['ls-remote', gitUrl, `refs/tags/v${version}^{}`, `refs/tags/v${version}`], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    proc.stdout.on('data', d => stdout += d);
+    proc.on('close', code => {
+      if (code !== 0) { reject(new Error('Failed to get SHA')); return; }
+      const tags = parseTagList(stdout);
+      const tag = tags.find(t => t.version === version);
+      resolve(tag ? tag.sha : null);
+    });
+  });
+}

package/src/config/lock-file.js

@@ -0,0 +1,57 @@
+// src/config/lock-file.js
+import { join } from 'path';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { parseTOML } from './toml.js';
+
+export function writeLockFile(cwd, resolvedModules, npmDeps) {
+  const lines = [];
+  lines.push('[lock]');
+  lines.push(`generated = "${new Date().toISOString()}"`);
+  lines.push('');
+
+  for (const [mod, info] of Object.entries(resolvedModules)) {
+    lines.push(`["${mod}"]`);
+    lines.push(`version = "${info.version}"`);
+    lines.push(`sha = "${info.sha}"`);
+    lines.push(`source = "${info.source}"`);
+    lines.push('');
+  }
+
+  if (npmDeps && Object.keys(npmDeps).length > 0) {
+    lines.push('[npm]');
+    for (const [name, version] of Object.entries(npmDeps)) {
+      lines.push(`${name} = "${version}"`);
+    }
+    lines.push('');
+  }
+
+  writeFileSync(join(cwd, 'tova.lock'), lines.join('\n'));
+}
+
+export function readLockFile(cwd) {
+  const lockPath = join(cwd, 'tova.lock');
+  if (!existsSync(lockPath)) return null;
+  const content = readFileSync(lockPath, 'utf-8');
+  const parsed = parseTOML(content);
+
+  const modules = {};
+  const npm = {};
+
+  for (const [key, value] of Object.entries(parsed)) {
+    if (key === 'lock') continue;
+    if (key === 'npm') {
+      Object.assign(npm, value);
+      continue;
+    }
+    // Module entries are quoted keys like "github.com/alice/http"
+    if (typeof value === 'object' && value.version) {
+      modules[key] = {
+        version: value.version,
+        sha: value.sha,
+        source: value.source,
+      };
+    }
+  }
+
+  return { modules, npm, generated: parsed.lock?.generated };
+}

package/src/config/module-cache.js

@@ -0,0 +1,58 @@
+// Global cache manager for the Tova package manager.
+// Manages the ~/.tova/pkg/ directory where downloaded packages are stored.
+// Provides path resolution, version lookup, and cleanup utilities.
+
+import { join } from 'path';
+import { existsSync, readdirSync, rmSync } from 'fs';
+import { homedir } from 'os';
+import { compareSemver } from './semver.js';
+import { parseModulePath } from './module-path.js';
+
+const DEFAULT_CACHE = join(homedir(), '.tova', 'pkg');
+
+export function getCacheDir(override) {
+  return override || process.env.TOVA_CACHE_DIR || DEFAULT_CACHE;
+}
+
+export function getModuleCachePath(modulePath, version, cacheDir) {
+  const dir = getCacheDir(cacheDir);
+  const parsed = typeof modulePath === 'string' ? parseModulePath(modulePath) : modulePath;
+  return join(dir, parsed.host, parsed.owner, parsed.repo, `v${version}`);
+}
+
+export function isVersionCached(modulePath, version, cacheDir) {
+  const p = getModuleCachePath(modulePath, version, cacheDir);
+  return existsSync(p) && existsSync(join(p, 'tova.toml'));
+}
+
+export function listCachedVersions(modulePath, cacheDir) {
+  const dir = getCacheDir(cacheDir);
+  const parsed = typeof modulePath === 'string' ? parseModulePath(modulePath) : modulePath;
+  const moduleDir = join(dir, parsed.host, parsed.owner, parsed.repo);
+  if (!existsSync(moduleDir)) return [];
+  const entries = readdirSync(moduleDir).filter(e => e.startsWith('v'));
+  const versions = entries.map(e => e.slice(1));
+  return versions.sort((a, b) => compareSemver(a, b));
+}
+
+export function getCompileCachePath(modulePath, version, cacheDir) {
+  const dir = getCacheDir(cacheDir);
+  return join(dir, '.cache', modulePath, `v${version}`);
+}
+
+export function cleanUnusedVersions(modulePath, keepVersions, cacheDir) {
+  const dir = getCacheDir(cacheDir);
+  const parsed = typeof modulePath === 'string' ? parseModulePath(modulePath) : modulePath;
+  const moduleDir = join(dir, parsed.host, parsed.owner, parsed.repo);
+  if (!existsSync(moduleDir)) return [];
+  const entries = readdirSync(moduleDir).filter(e => e.startsWith('v'));
+  const keepSet = new Set(keepVersions.map(v => `v${v}`));
+  const removed = [];
+  for (const entry of entries) {
+    if (!keepSet.has(entry)) {
+      rmSync(join(moduleDir, entry), { recursive: true, force: true });
+      removed.push(entry.slice(1));
+    }
+  }
+  return removed.sort((a, b) => compareSemver(a, b));
+}

package/src/config/module-entry.js

@@ -0,0 +1,37 @@
+// src/config/module-entry.js
+import { join } from 'path';
+import { existsSync } from 'fs';
+
+const ENTRY_CANDIDATES = [
+  'src/lib.tova',
+  'lib.tova',
+  'index.tova',
+  'src/index.tova',
+  'src/main.tova',
+  'main.tova',
+];
+
+/**
+ * Finds the entry point .tova file for a module.
+ * Checks: explicit entry → src/lib.tova → lib.tova → index.tova
+ */
+export function findEntryPoint(moduleDir, explicitEntry, subpath) {
+  const base = subpath ? join(moduleDir, subpath) : moduleDir;
+
+  if (explicitEntry) {
+    const p = join(base, explicitEntry);
+    if (existsSync(p)) return p;
+    throw new Error(`Explicit entry point not found: ${explicitEntry} in ${base}`);
+  }
+
+  for (const candidate of ENTRY_CANDIDATES) {
+    const p = join(base, candidate);
+    if (existsSync(p)) return p;
+  }
+
+  throw new Error(
+    `No entry point found in ${base}\n` +
+    `  Looked for: ${ENTRY_CANDIDATES.join(', ')}\n` +
+    `  Tip: Add an \`entry\` field to the package's tova.toml.`
+  );
+}

package/src/config/module-path.js

@@ -0,0 +1,31 @@
+// Module path utilities for Tova package management.
+// Determines whether an import is a Tova module (vs npm/relative),
+// parses module paths into components, and converts them to git URLs.
+
+export function isTovModule(source) {
+  if (!source || source.startsWith('.') || source.startsWith('/') || source.startsWith('@') || source.includes(':')) {
+    return false;
+  }
+  const firstSegment = source.split('/')[0];
+  return firstSegment.includes('.');
+}
+
+export function parseModulePath(source) {
+  if (!isTovModule(source)) {
+    throw new Error(`Invalid Tova module path: "${source}"`);
+  }
+  const parts = source.split('/');
+  if (parts.length < 3) {
+    throw new Error(`Invalid Tova module path: "${source}" — expected at least host/owner/repo`);
+  }
+  const host = parts[0];
+  const owner = parts[1];
+  const repo = parts[2];
+  const subpath = parts.length > 3 ? parts.slice(3).join('/') : null;
+  return { host, owner, repo, subpath, full: `${host}/${owner}/${repo}` };
+}
+
+export function moduleToGitUrl(modulePath) {
+  const parsed = typeof modulePath === 'string' ? parseModulePath(modulePath) : modulePath;
+  return `https://${parsed.full}.git`;
+}

package/src/config/pkg-errors.js

@@ -0,0 +1,62 @@
+// src/config/pkg-errors.js
+
+export function formatVersionConflict(modulePath, sources) {
+  const lines = [`error: version conflict for ${modulePath}`, ''];
+  for (const s of sources) {
+    lines.push(`  ${s.source} requires ${s.constraint}`);
+  }
+  lines.push('');
+  lines.push('  These constraints cannot be satisfied simultaneously.');
+  lines.push('  Tip: Check if either dependency has a newer version that resolves this.');
+  return lines.join('\n');
+}
+
+export function formatFetchError(modulePath, detail, cachedVersions = []) {
+  const lines = [`error: failed to fetch ${modulePath}`, '', `  ${detail}`];
+  if (cachedVersions.length > 0) {
+    lines.push('');
+    lines.push(`  Cached versions available: ${cachedVersions.join(', ')}`);
+    lines.push('  Tip: Run with --offline to use cached versions only.');
+  }
+  return lines.join('\n');
+}
+
+export function formatMissingEntry(modulePath, version) {
+  return [
+    `error: no entry point found for ${modulePath}@v${version}`,
+    '',
+    '  Looked for: src/lib.tova, lib.tova, index.tova',
+    "  Tip: The package may need an `entry` field in its tova.toml.",
+  ].join('\n');
+}
+
+export function formatAuthError(modulePath) {
+  return [
+    `error: authentication failed for ${modulePath}`,
+    '',
+    '  git clone returned: Permission denied (publickey)',
+    '  Tip: Ensure your SSH key or git credentials have access to this repo.',
+  ].join('\n');
+}
+
+export function formatCircularDep(chain) {
+  return [
+    'error: circular dependency detected',
+    '',
+    `  ${chain.join(' \u2192 ')}`,
+    '',
+    '  Tova does not allow circular module dependencies.',
+  ].join('\n');
+}
+
+export function formatIntegrityError(modulePath, version, expectedSha, actualSha) {
+  return [
+    `error: integrity check failed for ${modulePath}@v${version}`,
+    '',
+    `  Expected SHA: ${expectedSha}`,
+    `  Got SHA:      ${actualSha}`,
+    '',
+    '  The git tag may have been force-pushed. This could indicate tampering.',
+    `  Run \`tova update ${modulePath}\` to re-resolve.`,
+  ].join('\n');
+}

package/src/config/resolve.js

@@ -73,6 +73,23 @@ function normalizeConfig(parsed, source) {
     }
   }
 
+  // [package] section: marks this as a publishable package
+  if (parsed.package) {
+    config.package = {
+      name: parsed.package.name || '',
+      version: parsed.package.version || '0.1.0',
+      description: parsed.package.description || '',
+      license: parsed.package.license || '',
+      keywords: parsed.package.keywords || [],
+      homepage: parsed.package.homepage || '',
+      exports: parsed.package.exports || null,
+      entry: parsed.package.entry || null,
+    };
+    config.isPackage = true;
+  } else {
+    config.isPackage = false;
+  }
+
   return config;
 }