tova 0.7.0 → 0.8.2

package/src/config/resolver.js

@@ -0,0 +1,139 @@
+// src/config/resolver.js
+import { selectMinVersion, satisfies, parseSemver, compareSemver } from './semver.js';
+
+/**
+ * Merges dependency maps from multiple sources, collecting all constraints per module.
+ */
+export function mergeDependencies(...depMaps) {
+  const merged = {};
+  for (const deps of depMaps) {
+    for (const [mod, constraint] of Object.entries(deps)) {
+      if (!merged[mod]) merged[mod] = [];
+      if (Array.isArray(constraint)) {
+        merged[mod].push(...constraint);
+      } else {
+        merged[mod].push(constraint);
+      }
+    }
+  }
+  return merged;
+}
+
+/**
+ * Merges npm dependencies from multiple module configs.
+ * For conflicts, picks the highest constraint version.
+ */
+export function mergeNpmDeps(moduleConfigs) {
+  const merged = {};
+  for (const config of moduleConfigs) {
+    const prod = config.npm?.prod || {};
+    for (const [name, version] of Object.entries(prod)) {
+      if (!merged[name]) {
+        merged[name] = version;
+      } else {
+        // Keep whichever specifies a higher minimum
+        try {
+          const existing = parseSemver(merged[name].replace(/^[\^~>=<]*/, ''));
+          const incoming = parseSemver(version.replace(/^[\^~>=<]*/, ''));
+          if (compareSemver(incoming, existing) > 0) {
+            merged[name] = version;
+          }
+        } catch {
+          merged[name] = version;
+        }
+      }
+    }
+  }
+  return merged;
+}
+
+/**
+ * Detects version conflicts — modules where no single version satisfies all constraints.
+ */
+export function detectConflicts(constraintMap, availableVersions) {
+  const conflicts = [];
+  for (const [mod, constraints] of Object.entries(constraintMap)) {
+    const versions = availableVersions[mod] || [];
+    const resolved = selectMinVersion(versions, constraints);
+    if (resolved === null && constraints.length > 1) {
+      conflicts.push({
+        module: mod,
+        constraints,
+        available: versions,
+      });
+    }
+  }
+  return conflicts;
+}
+
+/**
+ * Resolves all dependencies to exact versions.
+ * Returns a map of modulePath -> { version, sha, source, npmDeps }.
+ *
+ * This is the high-level orchestrator called by `tova install`.
+ * It takes callbacks for I/O operations (fetching tags, reading configs)
+ * so the core logic is testable without network access.
+ */
+export async function resolveDependencies(rootDeps, options = {}) {
+  const {
+    getAvailableVersions, // async (modulePath) => ['1.0.0', '1.1.0', ...]
+    getModuleConfig,      // async (modulePath, version) => { dependencies, npm }
+    getVersionSha,        // async (modulePath, version) => 'sha...'
+  } = options;
+
+  const resolved = {};         // modulePath -> { version, sha }
+  const allConstraints = {};   // modulePath -> [constraints...]
+  const allNpmDeps = [];       // [{ npm: { prod: {...} } }, ...]
+  const queue = [rootDeps];    // queue of dependency maps to process
+
+  while (queue.length > 0) {
+    const deps = queue.shift();
+    for (const [mod, constraint] of Object.entries(deps)) {
+      if (!allConstraints[mod]) allConstraints[mod] = [];
+      allConstraints[mod].push(constraint);
+
+      // Get available versions
+      const versions = await getAvailableVersions(mod);
+      const version = selectMinVersion(versions, allConstraints[mod]);
+
+      if (version === null) {
+        const conflicts = detectConflicts(
+          { [mod]: allConstraints[mod] },
+          { [mod]: versions }
+        );
+        if (conflicts.length > 0) {
+          throw new Error(
+            `Version conflict for ${mod}:\n` +
+            conflicts[0].constraints.map(c => `  requires ${c}`).join('\n') +
+            `\n  Available: ${versions.join(', ')}`
+          );
+        }
+        throw new Error(
+          `No version of ${mod} satisfies constraint: ${allConstraints[mod].join(', ')}\n` +
+          `  Available: ${versions.join(', ') || 'none'}`
+        );
+      }
+
+      // Skip if we already resolved this module to the same or higher version
+      if (resolved[mod] && compareSemver(resolved[mod].version, version) >= 0) {
+        continue;
+      }
+
+      const sha = await getVersionSha(mod, version);
+      resolved[mod] = { version, sha, source: `https://${mod}.git` };
+
+      // Read this module's config for transitive deps
+      const config = await getModuleConfig(mod, version);
+      if (config) {
+        allNpmDeps.push(config);
+        if (config.dependencies && Object.keys(config.dependencies).length > 0) {
+          queue.push(config.dependencies);
+        }
+      }
+    }
+  }
+
+  const npmDeps = mergeNpmDeps(allNpmDeps);
+
+  return { resolved, npmDeps };
+}

package/src/config/search.js

@@ -0,0 +1,28 @@
+// src/config/search.js
+
+export function formatSearchResults(items) {
+  if (items.length === 0) return '  No packages found.\n';
+  const lines = [];
+  for (const item of items) {
+    const modulePath = `github.com/${item.full_name}`;
+    const stars = item.stargazers_count || 0;
+    const desc = item.description || '(no description)';
+    const updated = item.updated_at ? item.updated_at.slice(0, 10) : 'unknown';
+    lines.push(`  ${modulePath}`);
+    lines.push(`    ${desc}`);
+    lines.push(`    Stars: ${stars}  Updated: ${updated}`);
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+export async function searchPackages(query) {
+  const searchQuery = encodeURIComponent(`${query} topic:tova-package`);
+  const url = `https://api.github.com/search/repositories?q=${searchQuery}&sort=stars&per_page=20`;
+  const res = await fetch(url, {
+    headers: { 'Accept': 'application/vnd.github.v3+json' },
+  });
+  if (!res.ok) throw new Error(`GitHub search failed: ${res.statusText}`);
+  const data = await res.json();
+  return data.items || [];
+}

package/src/config/semver.js

@@ -0,0 +1,72 @@
+// src/config/semver.js
+// Semver utilities for the Tova package manager.
+// Provides parsing, comparison, constraint satisfaction, and minimum version selection.
+
+export function parseSemver(str) {
+  const s = str.startsWith('v') ? str.slice(1) : str;
+  const parts = s.split('.');
+  const major = parseInt(parts[0], 10);
+  const minor = parseInt(parts[1] || '0', 10);
+  const patch = parseInt(parts[2] || '0', 10);
+  if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
+    throw new Error(`Invalid semver: "${str}"`);
+  }
+  return { major, minor, patch };
+}
+
+export function compareSemver(a, b) {
+  const va = typeof a === 'string' ? parseSemver(a) : a;
+  const vb = typeof b === 'string' ? parseSemver(b) : b;
+  if (va.major !== vb.major) return va.major > vb.major ? 1 : -1;
+  if (va.minor !== vb.minor) return va.minor > vb.minor ? 1 : -1;
+  if (va.patch !== vb.patch) return va.patch > vb.patch ? 1 : -1;
+  return 0;
+}
+
+export function parseConstraint(constraint) {
+  if (constraint.startsWith('^')) {
+    return { type: 'caret', version: parseSemver(constraint.slice(1)) };
+  }
+  if (constraint.startsWith('~')) {
+    return { type: 'tilde', version: parseSemver(constraint.slice(1)) };
+  }
+  if (constraint.startsWith('>=')) {
+    return { type: 'gte', version: parseSemver(constraint.slice(2)) };
+  }
+  if (constraint.startsWith('>')) {
+    return { type: 'gt', version: parseSemver(constraint.slice(1)) };
+  }
+  return { type: 'exact', version: parseSemver(constraint) };
+}
+
+export function satisfies(version, constraint) {
+  const v = typeof version === 'string' ? parseSemver(version) : version;
+  const c = typeof constraint === 'string' ? parseConstraint(constraint) : constraint;
+  switch (c.type) {
+    case 'exact':
+      return compareSemver(v, c.version) === 0;
+    case 'caret':
+      if (compareSemver(v, c.version) < 0) return false;
+      return v.major === c.version.major;
+    case 'tilde':
+      if (compareSemver(v, c.version) < 0) return false;
+      return v.major === c.version.major && v.minor === c.version.minor;
+    case 'gte':
+      return compareSemver(v, c.version) >= 0;
+    case 'gt':
+      return compareSemver(v, c.version) > 0;
+    default:
+      return false;
+  }
+}
+
+export function selectMinVersion(versions, constraints) {
+  const constraintList = Array.isArray(constraints) ? constraints : [constraints];
+  const sorted = [...versions].sort((a, b) => compareSemver(a, b));
+  for (const ver of sorted) {
+    if (constraintList.every(c => satisfies(ver, c))) {
+      return ver;
+    }
+  }
+  return null;
+}

package/src/config/toml.js

@@ -13,10 +13,10 @@ export function parseTOML(input) {
     // Skip empty lines and comments
     if (line === '' || line.startsWith('#')) continue;
 
-    // Section header: [section] or [section.subsection]
+    // Section header: [section] or [section.subsection] or ["quoted.key"]
     if (line.startsWith('[') && !line.startsWith('[[')) {
-      const close = line.indexOf(']');
-      if (close === -1) {
+      const close = line.lastIndexOf(']');
+      if (close <= 0) {
         throw new Error(`TOML parse error on line ${i + 1}: unclosed section header`);
       }
       const sectionPath = line.slice(1, close).trim();
@@ -24,8 +24,8 @@ export function parseTOML(input) {
         throw new Error(`TOML parse error on line ${i + 1}: empty section name`);
       }
       current = result;
-      for (const part of sectionPath.split('.')) {
-        const key = part.trim();
+      const parts = parseSectionPath(sectionPath);
+      for (const key of parts) {
         if (!current[key]) current[key] = {};
         current = current[key];
       }
@@ -45,6 +45,49 @@ export function parseTOML(input) {
   return result;
 }
 
+function parseSectionPath(path) {
+  const parts = [];
+  let i = 0;
+  while (i < path.length) {
+    // Skip whitespace
+    while (i < path.length && path[i] === ' ') i++;
+    if (i >= path.length) break;
+
+    if (path[i] === '"') {
+      // Quoted key: read until closing quote
+      i++; // skip opening quote
+      let key = '';
+      while (i < path.length && path[i] !== '"') {
+        if (path[i] === '\\') {
+          i++;
+          key += path[i] || '';
+        } else {
+          key += path[i];
+        }
+        i++;
+      }
+      i++; // skip closing quote
+      parts.push(key);
+    } else {
+      // Bare key: read until dot or end
+      let key = '';
+      while (i < path.length && path[i] !== '.') {
+        key += path[i];
+        i++;
+      }
+      key = key.trim();
+      if (key) parts.push(key);
+    }
+
+    // Skip dot separator
+    while (i < path.length && (path[i] === ' ' || path[i] === '.')) {
+      if (path[i] === '.') { i++; break; }
+      i++;
+    }
+  }
+  return parts;
+}
+
 function parseValue(raw, lineNum) {
   if (raw === '') {
     throw new Error(`TOML parse error on line ${lineNum}: missing value`);

package/src/deploy/deploy.js

@@ -0,0 +1,217 @@
+// CLI deploy command entry point for the Tova language
+// Provides argument parsing and deploy orchestration.
+// SSH execution is stubbed for now — will be wired in integration.
+
+import { inferInfrastructure } from './infer.js';
+
+/**
+ * Parse CLI deploy arguments into a config object.
+ *
+ *   tova deploy prod --plan
+ *   tova deploy prod --rollback
+ *   tova deploy prod --logs --since "1 hour ago"
+ *   tova deploy prod --status
+ *   tova deploy prod --ssh
+ *   tova deploy prod --setup-git
+ *   tova deploy --list --server root@example.com
+ *   tova deploy prod --remove
+ *   tova deploy prod --logs --instance 1
+ */
+export function parseDeployArgs(args) {
+  const result = {
+    envName: null,
+    plan: false,
+    rollback: false,
+    logs: false,
+    status: false,
+    ssh: false,
+    setupGit: false,
+    remove: false,
+    list: false,
+    server: null,
+    since: null,
+    instance: null,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case '--plan': result.plan = true; break;
+      case '--rollback': result.rollback = true; break;
+      case '--logs': result.logs = true; break;
+      case '--status': result.status = true; break;
+      case '--ssh': result.ssh = true; break;
+      case '--setup-git': result.setupGit = true; break;
+      case '--remove': result.remove = true; break;
+      case '--list': result.list = true; break;
+      case '--server': result.server = args[++i]; break;
+      case '--since': result.since = args[++i]; break;
+      case '--instance': result.instance = parseInt(args[++i], 10); break;
+      default:
+        if (!arg.startsWith('--') && !result.envName) {
+          result.envName = arg;
+        }
+        break;
+    }
+  }
+  return result;
+}
+
+/**
+ * Print a deploy plan to the console.
+ * Shows the infrastructure that would be provisioned.
+ *
+ * @param {Object} infra - Infrastructure manifest from inferInfrastructure()
+ */
+export function printPlan(infra) {
+  const lines = [];
+  lines.push('');
+  lines.push('  Deploy Plan');
+  lines.push('  ──────────────────────────────────────');
+  lines.push('');
+
+  if (infra.name) lines.push(`  Environment:  ${infra.name}`);
+  if (infra.server) lines.push(`  Server:       ${infra.server}`);
+  if (infra.domain) lines.push(`  Domain:       ${infra.domain}`);
+  lines.push(`  Instances:    ${infra.instances}`);
+  lines.push(`  Memory:       ${infra.memory}`);
+  lines.push(`  Branch:       ${infra.branch}`);
+  lines.push(`  Health:       ${infra.health} (every ${infra.health_interval}s)`);
+  lines.push(`  Keep:         ${infra.keep_releases} releases`);
+  lines.push('');
+
+  // Required services
+  const services = [];
+  if (infra.requires.bun) services.push('Bun');
+  if (infra.requires.caddy) services.push('Caddy');
+  if (infra.requires.ufw) services.push('UFW');
+  if (services.length > 0) {
+    lines.push(`  Services:     ${services.join(', ')}`);
+  }
+
+  // Databases
+  if (infra.databases.length > 0) {
+    const dbNames = infra.databases.map(d => d.engine);
+    lines.push(`  Databases:    ${dbNames.join(', ')}`);
+  }
+
+  // Features
+  const features = [];
+  if (infra.hasWebSocket) features.push('WebSocket');
+  if (infra.hasSSE) features.push('SSE');
+  if (infra.hasBrowser) features.push('Static assets');
+  if (features.length > 0) {
+    lines.push(`  Features:     ${features.join(', ')}`);
+  }
+
+  // Required secrets
+  if (infra.requiredSecrets.length > 0) {
+    lines.push(`  Secrets:      ${infra.requiredSecrets.join(', ')}`);
+  }
+
+  // Env variables
+  const envKeys = Object.keys(infra.env || {});
+  if (envKeys.length > 0) {
+    lines.push(`  Env vars:     ${envKeys.join(', ')}`);
+  }
+
+  lines.push('');
+  lines.push('  ──────────────────────────────────────');
+  lines.push('');
+
+  console.log(lines.join('\n'));
+}
+
+/**
+ * Main deploy orchestrator.
+ *
+ * Compiles the project, infers infrastructure, and (eventually) executes
+ * SSH deployment. For now the SSH parts are stubbed.
+ *
+ * @param {Object} ast - Parsed program AST
+ * @param {Object} buildResult - Codegen output
+ * @param {Object} deployArgs - Parsed CLI args from parseDeployArgs()
+ * @param {string} projectDir - Absolute path to the project directory
+ * @returns {Object} result with plan, infra, and status
+ */
+export async function deploy(ast, buildResult, deployArgs, projectDir) {
+  // Infer full infrastructure manifest from AST
+  const infra = inferInfrastructure(ast);
+
+  // Override environment name from CLI args
+  if (deployArgs.envName) {
+    infra.name = deployArgs.envName;
+  }
+
+  // If deploy config exists in build result, merge it
+  if (buildResult.deploy && buildResult.deploy[deployArgs.envName]) {
+    const envConfig = buildResult.deploy[deployArgs.envName];
+    if (envConfig.server) infra.server = envConfig.server;
+    if (envConfig.domain) infra.domain = envConfig.domain;
+    if (envConfig.instances) infra.instances = envConfig.instances;
+    if (envConfig.memory) infra.memory = envConfig.memory;
+    if (envConfig.branch) infra.branch = envConfig.branch;
+  }
+
+  // Plan mode — just show what would be deployed
+  if (deployArgs.plan) {
+    printPlan(infra);
+    return { action: 'plan', infra };
+  }
+
+  // Rollback mode — stub
+  if (deployArgs.rollback) {
+    console.log(`  Rolling back ${deployArgs.envName}...`);
+    // TODO: SSH into server, symlink previous release
+    return { action: 'rollback', infra };
+  }
+
+  // Logs mode — stub
+  if (deployArgs.logs) {
+    const since = deployArgs.since || '1 hour ago';
+    const instance = deployArgs.instance !== null ? ` (instance ${deployArgs.instance})` : '';
+    console.log(`  Fetching logs for ${deployArgs.envName}${instance} since ${since}...`);
+    // TODO: SSH into server, journalctl/tail logs
+    return { action: 'logs', infra };
+  }
+
+  // Status mode — stub
+  if (deployArgs.status) {
+    console.log(`  Checking status of ${deployArgs.envName}...`);
+    // TODO: SSH into server, check systemd service status
+    return { action: 'status', infra };
+  }
+
+  // SSH mode — stub
+  if (deployArgs.ssh) {
+    console.log(`  Opening SSH session to ${deployArgs.envName}...`);
+    // TODO: spawn interactive SSH session
+    return { action: 'ssh', infra };
+  }
+
+  // Setup git push-to-deploy — stub
+  if (deployArgs.setupGit) {
+    console.log(`  Setting up git push-to-deploy for ${deployArgs.envName}...`);
+    // TODO: SSH into server, configure bare repo + post-receive hook
+    return { action: 'setup-git', infra };
+  }
+
+  // Remove deployment — stub
+  if (deployArgs.remove) {
+    console.log(`  Removing deployment ${deployArgs.envName}...`);
+    // TODO: SSH into server, stop services, remove files
+    return { action: 'remove', infra };
+  }
+
+  // List deployments — stub
+  if (deployArgs.list) {
+    console.log('  Listing deployments...');
+    // TODO: SSH into server, list ~/apps/
+    return { action: 'list', infra };
+  }
+
+  // Default: full deploy — stub
+  console.log(`  Deploying to ${deployArgs.envName}...`);
+  // TODO: rsync build, run provision script, restart services
+  return { action: 'deploy', infra };
+}