tova 0.1.5 → 0.2.2

package/bin/tova.js

@@ -15,6 +15,10 @@ import { getFullStdlib, buildSelectiveStdlib, BUILTIN_NAMES, PROPAGATE } from '.
 import { Formatter } from '../src/formatter/formatter.js';
 import { REACTIVITY_SOURCE, RPC_SOURCE, ROUTER_SOURCE } from '../src/runtime/embedded.js';
 import '../src/runtime/string-proto.js';
+import { resolveConfig } from '../src/config/resolve.js';
+import { writePackageJson } from '../src/config/package-json.js';
+import { addToSection, removeFromSection } from '../src/config/edit-toml.js';
+import { stringifyTOML } from '../src/config/toml.js';
 
 const require = createRequire(import.meta.url);
 const { version: VERSION } = require('../package.json');
@@ -33,10 +37,13 @@ Usage:
 Commands:
   run <file>       Compile and execute a .tova file
   build [dir]      Compile .tova files to JavaScript (default: current dir)
-  dev              Start development server with file watching
+  dev              Start development server with live reload
+  new <name>       Create a new Tova project
+  install          Install npm dependencies from tova.toml
+  add <pkg>        Add an npm dependency (--dev for dev dependency)
+  remove <pkg>     Remove an npm dependency
   repl             Start interactive Tova REPL
   lsp              Start Language Server Protocol server
-  new <name>       Create a new Tova project
   fmt <file>      Format a .tova file (--check to verify only)
   test [dir]      Run test blocks in .tova files (--filter, --watch)
   migrate:create <name>   Create a new migration file
@@ -88,6 +95,15 @@ async function main() {
     case 'new':
       newProject(args[1]);
       break;
+    case 'install':
+      await installDeps();
+      break;
+    case 'add':
+      await addDep(args.slice(1));
+      break;
+    case 'remove':
+      await removeDep(args[1]);
+      break;
     case 'fmt':
       formatFile(args.slice(1));
       break;
@@ -305,9 +321,23 @@ function findTovaFiles(dir) {
 
 async function runFile(filePath, options = {}) {
   if (!filePath) {
-    console.error('Error: No file specified');
-    console.error('Usage: tova run <file.tova>');
-    process.exit(1);
+    // If tova.toml exists, try to find a main file in the entry directory
+    const config = resolveConfig(process.cwd());
+    if (config._source === 'tova.toml') {
+      const entryDir = resolve(config.project.entry || '.');
+      for (const name of ['main.tova', 'app.tova']) {
+        const candidate = join(entryDir, name);
+        if (existsSync(candidate)) {
+          filePath = candidate;
+          break;
+        }
+      }
+    }
+    if (!filePath) {
+      console.error('Error: No file specified');
+      console.error('Usage: tova run <file.tova>');
+      process.exit(1);
+    }
   }
 
   const resolved = resolve(filePath);
@@ -339,11 +369,13 @@ async function runFile(filePath, options = {}) {
 // ─── Build ──────────────────────────────────────────────────
 
 async function buildProject(args) {
+  const config = resolveConfig(process.cwd());
   const isProduction = args.includes('--production');
   const buildStrict = args.includes('--strict');
-  const srcDir = resolve(args.filter(a => !a.startsWith('--'))[0] || '.');
+  const explicitSrc = args.filter(a => !a.startsWith('--'))[0];
+  const srcDir = resolve(explicitSrc || config.project.entry || '.');
   const outIdx = args.indexOf('--output');
-  const outDir = resolve(outIdx >= 0 ? args[outIdx + 1] : '.tova-out');
+  const outDir = resolve(outIdx >= 0 ? args[outIdx + 1] : (config.build.output || '.tova-out'));
 
   // Production build uses a separate optimized pipeline
   if (isProduction) {
@@ -455,8 +487,11 @@ async function buildProject(args) {
 // ─── Dev Server ─────────────────────────────────────────────
 
 async function devServer(args) {
-  const srcDir = resolve(args[0] || '.');
-  const basePort = parseInt(args.find((_, i, a) => a[i - 1] === '--port') || '3000');
+  const config = resolveConfig(process.cwd());
+  const explicitSrc = args.filter(a => !a.startsWith('--'))[0];
+  const srcDir = resolve(explicitSrc || config.project.entry || '.');
+  const explicitPort = args.find((_, i, a) => a[i - 1] === '--port');
+  const basePort = parseInt(explicitPort || config.dev.port || '3000');
   const buildStrict = args.includes('--strict');
 
   const tovaFiles = findFiles(srcDir, '.tova');
@@ -465,6 +500,8 @@ async function devServer(args) {
     process.exit(1);
   }
 
+  const reloadPort = basePort + 100;
+
   console.log(`\n  Tova dev server starting...\n`);
 
   // Compile all files
@@ -509,7 +546,7 @@ async function devServer(args) {
       if (output.client) {
         const p = join(outDir, `${outBaseName}.client.js`);
         writeFileSync(p, output.client);
-        clientHTML = await generateDevHTML(output.client, srcDir);
+        clientHTML = await generateDevHTML(output.client, srcDir, reloadPort);
         writeFileSync(join(outDir, 'index.html'), clientHTML);
         hasClient = true;
       }
@@ -589,6 +626,49 @@ async function devServer(args) {
     console.log(`  ✓ Client: ${relative('.', outDir)}/index.html`);
   }
 
+  // Start live-reload SSE server
+  const reloadClients = new Set();
+  const reloadServer = Bun.serve({
+    port: reloadPort,
+    fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === '/__tova_reload') {
+        const stream = new ReadableStream({
+          start(controller) {
+            const client = { controller };
+            reloadClients.add(client);
+            // Send heartbeat to keep connection alive
+            const heartbeat = setInterval(() => {
+              try { controller.enqueue(new TextEncoder().encode(': heartbeat\n\n')); } catch { clearInterval(heartbeat); }
+            }, 15000);
+            req.signal.addEventListener('abort', () => {
+              clearInterval(heartbeat);
+              reloadClients.delete(client);
+            });
+          },
+        });
+        return new Response(stream, {
+          headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+          },
+        });
+      }
+      return new Response('Not Found', { status: 404 });
+    },
+  });
+
+  function notifyReload() {
+    const msg = new TextEncoder().encode('data: reload\n\n');
+    for (const client of reloadClients) {
+      try { client.controller.enqueue(msg); } catch { reloadClients.delete(client); }
+    }
+  }
+
+  console.log(`  ✓ Live reload on port ${reloadPort}`);
+
   // Start file watcher for auto-rebuild
   const watcher = startWatcher(srcDir, async () => {
     console.log('  Rebuilding...');
@@ -620,7 +700,7 @@ async function devServer(args) {
         }
         if (output.client) {
           writeFileSync(join(outDir, `${outBaseName}.client.js`), output.client);
-          rebuildClientHTML = await generateDevHTML(output.client, srcDir);
+          rebuildClientHTML = await generateDevHTML(output.client, srcDir, reloadPort);
           writeFileSync(join(outDir, 'index.html'), rebuildClientHTML);
         }
         if (output.server) {
@@ -670,6 +750,7 @@ async function devServer(args) {
       rebuildPortOffset++;
     }
     console.log('  ✓ Rebuild complete');
+    notifyReload();
   });
 
   console.log(`\n  Watching for changes. Press Ctrl+C to stop\n`);
@@ -678,6 +759,7 @@ async function devServer(args) {
   process.on('SIGINT', () => {
     console.log('\n  Shutting down...');
     watcher.close();
+    reloadServer.stop();
     for (const p of processes) {
       p.child.kill('SIGTERM');
     }
@@ -688,7 +770,16 @@ async function devServer(args) {
   await new Promise(() => {});
 }
 
-async function generateDevHTML(clientCode, srcDir) {
+async function generateDevHTML(clientCode, srcDir, reloadPort = 0) {
+  const liveReloadScript = reloadPort ? `
+  <script>
+    (function() {
+      var es = new EventSource("http://localhost:${reloadPort}/__tova_reload");
+      es.onmessage = function(e) { if (e.data === "reload") window.location.reload(); };
+      es.onerror = function() { setTimeout(function() { window.location.reload(); }, 1000); };
+    })();
+  </script>` : '';
+
   // Check if client code uses npm packages — if so, bundle with Bun.build
   if (srcDir && hasNpmImports(clientCode)) {
     const bundled = await bundleClientCode(clientCode, srcDir);
@@ -710,7 +801,7 @@ async function generateDevHTML(clientCode, srcDir) {
   <div id="app"></div>
   <script type="module">
 ${bundled}
-  </script>
+  </script>${liveReloadScript}
 </body>
 </html>`;
   }
@@ -772,7 +863,7 @@ ${inlineRpc}
 
 // ── App ──
 ${inlineClient}
-  </script>
+  </script>${liveReloadScript}
 </body>
 </html>`;
 }
@@ -797,19 +888,34 @@ function newProject(name) {
   mkdirSync(projectDir, { recursive: true });
   mkdirSync(join(projectDir, 'src'));
 
-  // package.json
-  writeFileSync(join(projectDir, 'package.json'), JSON.stringify({
-    name,
-    version: '0.1.0',
-    type: 'module',
-    scripts: {
-      dev: 'tova dev src',
-      build: 'tova build src',
+  // tova.toml
+  const tomlContent = stringifyTOML({
+    project: {
+      name,
+      version: '0.1.0',
+      description: 'A full-stack Tova application',
+      entry: 'src',
     },
-    dependencies: {
-      'tova': '^0.1.0',
+    build: {
+      output: '.tova-out',
     },
-  }, null, 2) + '\n');
+    dev: {
+      port: 3000,
+    },
+    dependencies: {},
+    npm: {},
+  });
+  writeFileSync(join(projectDir, 'tova.toml'), tomlContent);
+
+  // .gitignore
+  writeFileSync(join(projectDir, '.gitignore'), `node_modules/
+.tova-out/
+package.json
+bun.lock
+*.db
+*.db-shm
+*.db-wal
+`);
 
   // Main app file
   writeFileSync(join(projectDir, 'src', 'app.tova'), `// ${name} — Built with Tova
@@ -853,24 +959,146 @@ Built with [Tova](https://github.com/tova-lang/tova-lang) — a modern full-stac
 ## Development
 
 \`\`\`bash
-bun install
-bun run dev
+tova install
+tova dev
 \`\`\`
 
 ## Build
 
 \`\`\`bash
-bun run build
+tova build
+\`\`\`
+
+## Add npm packages
+
+\`\`\`bash
+tova add htmx
+tova add prettier --dev
 \`\`\`
 `);
 
-  console.log(`  ✓ Created ${name}/package.json`);
+  console.log(`  ✓ Created ${name}/tova.toml`);
+  console.log(`  ✓ Created ${name}/.gitignore`);
   console.log(`  ✓ Created ${name}/src/app.tova`);
   console.log(`  ✓ Created ${name}/README.md`);
   console.log(`\n  Get started:\n`);
   console.log(`    cd ${name}`);
-  console.log(`    bun install`);
-  console.log(`    bun run dev\n`);
+  console.log(`    tova install`);
+  console.log(`    tova dev\n`);
+}
+
+// ─── Package Management ─────────────────────────────────────
+
+async function installDeps() {
+  const cwd = process.cwd();
+  const config = resolveConfig(cwd);
+
+  if (config._source !== 'tova.toml') {
+    // No tova.toml — just run bun install as normal
+    console.log('  No tova.toml found, running bun install...\n');
+    const proc = spawn('bun', ['install'], { stdio: 'inherit', cwd });
+    const code = await new Promise(res => proc.on('close', res));
+    process.exit(code);
+    return;
+  }
+
+  // Generate shadow package.json from tova.toml
+  const wrote = writePackageJson(config, cwd);
+  if (wrote) {
+    console.log('  Generated package.json from tova.toml');
+    const proc = spawn('bun', ['install'], { stdio: 'inherit', cwd });
+    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');
+  }
+}
+
+async function addDep(args) {
+  const isDev = args.includes('--dev');
+  const pkg = args.find(a => !a.startsWith('--'));
+
+  if (!pkg) {
+    console.error('Error: No package specified');
+    console.error('Usage: tova add <package> [--dev]');
+    process.exit(1);
+  }
+
+  const cwd = process.cwd();
+  const tomlPath = join(cwd, 'tova.toml');
+
+  if (!existsSync(tomlPath)) {
+    console.error('Error: No tova.toml found in current directory');
+    console.error('Run `tova new <name>` to create a new project, or create tova.toml manually.');
+    process.exit(1);
+  }
+
+  // Parse package name and version
+  let name = pkg;
+  let version = 'latest';
+  if (pkg.includes('@') && !pkg.startsWith('@')) {
+    const atIdx = pkg.lastIndexOf('@');
+    name = pkg.slice(0, atIdx);
+    version = pkg.slice(atIdx + 1);
+  } else if (pkg.startsWith('@') && pkg.includes('@', 1)) {
+    // Scoped package with version: @scope/name@version
+    const atIdx = pkg.lastIndexOf('@');
+    name = pkg.slice(0, atIdx);
+    version = pkg.slice(atIdx + 1);
+  }
+
+  // If version is 'latest', resolve it via npm registry
+  if (version === 'latest') {
+    try {
+      const proc = spawn('npm', ['view', name, 'version'], { stdio: ['pipe', 'pipe', 'pipe'] });
+      let out = '';
+      proc.stdout.on('data', d => out += d);
+      const code = await new Promise(res => proc.on('close', res));
+      if (code === 0 && out.trim()) {
+        version = `^${out.trim()}`;
+      } else {
+        version = '*';
+      }
+    } catch {
+      version = '*';
+    }
+  }
+
+  const section = isDev ? 'npm.dev' : 'npm';
+  addToSection(tomlPath, section, name, version);
+
+  console.log(`  Added ${name}@${version} to [${section}] in tova.toml`);
+
+  // Run install
+  await installDeps();
+}
+
+async function removeDep(pkg) {
+  if (!pkg) {
+    console.error('Error: No package specified');
+    console.error('Usage: tova remove <package>');
+    process.exit(1);
+  }
+
+  const cwd = process.cwd();
+  const tomlPath = join(cwd, 'tova.toml');
+
+  if (!existsSync(tomlPath)) {
+    console.error('Error: No tova.toml found in current directory');
+    process.exit(1);
+  }
+
+  // Try removing from [npm] first, then [npm.dev]
+  const removed = removeFromSection(tomlPath, 'npm', pkg) ||
+                  removeFromSection(tomlPath, 'npm.dev', pkg);
+
+  if (removed) {
+    console.log(`  Removed ${pkg} from tova.toml`);
+    await installDeps();
+  } else {
+    console.error(`  Package '${pkg}' not found in tova.toml`);
+    process.exit(1);
+  }
 }
 
 // ─── Migrations ─────────────────────────────────────────────

package/package.json

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

package/src/codegen/client-codegen.js

@@ -172,7 +172,8 @@ export class ClientCodegen extends BaseCodegen {
     return `${asyncPrefix}(${params}) => ${this.genExpression(node.body)}`;
   }
 
-  generate(clientBlocks, sharedCode) {
+  generate(clientBlocks, sharedCode, sharedBuiltins = null) {
+    this._sharedBuiltins = sharedBuiltins || new Set();
     const lines = [];
 
     // Runtime imports
@@ -209,9 +210,10 @@ export class ClientCodegen extends BaseCodegen {
       lines.push('');
     }
 
-    // Stdlib core functions (available in all Tova code)
+    // Stdlib placeholder — filled after all client code is generated so tree-shaking sees all usages
+    const stdlibPlaceholderIdx = lines.length;
     lines.push('// ── Stdlib ──');
-    lines.push(this.getStdlibCore());
+    lines.push('__STDLIB_PLACEHOLDER__');
     lines.push('');
 
     // Server RPC proxy
@@ -350,6 +352,9 @@ export class ClientCodegen extends BaseCodegen {
       lines.push('});');
     }
 
+    // Replace stdlib placeholder now that all client code has been generated
+    lines[stdlibPlaceholderIdx + 1] = this.getStdlibCore();
+
     return lines.join('\n');
   }
 
@@ -901,8 +906,14 @@ export class ClientCodegen extends BaseCodegen {
 
   getStdlibCore() {
     const parts = [];
-    // Only include used builtin functions (tree-shaking)
-    const selectiveStdlib = buildSelectiveStdlib(this._usedBuiltins);
+    // Only include builtins used in client blocks that aren't already in shared code
+    const clientOnly = new Set();
+    for (const name of this._usedBuiltins) {
+      if (!this._sharedBuiltins || !this._sharedBuiltins.has(name)) {
+        clientOnly.add(name);
+      }
+    }
+    const selectiveStdlib = buildSelectiveStdlib(clientOnly);
     if (selectiveStdlib) parts.push(selectiveStdlib);
     // Include Result/Option if Ok/Err/Some/None are used
     if (this._needsResultOption) parts.push(RESULT_OPTION);

package/src/codegen/codegen.js

@@ -5,6 +5,7 @@
 import { SharedCodegen } from './shared-codegen.js';
 import { ServerCodegen } from './server-codegen.js';
 import { ClientCodegen } from './client-codegen.js';
+import { BUILTIN_NAMES } from '../stdlib/inline.js';
 
 export class CodeGenerator {
   constructor(ast, filename = '<stdin>') {
@@ -48,6 +49,10 @@ export class CodeGenerator {
     // All shared blocks (regardless of name) are merged into one shared output
     const sharedCode = sharedBlocks.map(b => sharedGen.generate(b)).join('\n');
     const topLevelCode = topLevel.map(s => sharedGen.generateStatement(s)).join('\n');
+
+    // Pre-scan server/client blocks for builtin usage so shared stdlib includes them
+    this._scanBlocksForBuiltins([...serverBlocks, ...clientBlocks], sharedGen._usedBuiltins);
+
     const helpers = sharedGen.generateHelpers();
 
     // Generate data block code (sources, pipelines, validators, refresh)
@@ -105,7 +110,7 @@ export class CodeGenerator {
     for (const [name, blocks] of clientGroups) {
       const gen = new ClientCodegen();
       const key = name || 'default';
-      clients[key] = gen.generate(blocks, combinedShared);
+      clients[key] = gen.generate(blocks, combinedShared, sharedGen._usedBuiltins);
     }
 
     // Generate tests if test blocks exist
@@ -152,6 +157,31 @@ export class CodeGenerator {
     return result;
   }
 
+  // Walk AST nodes to find builtin function calls/identifiers
+  _scanBlocksForBuiltins(blocks, targetSet) {
+    const walk = (node) => {
+      if (!node || typeof node !== 'object') return;
+      if (node.type === 'Identifier' && BUILTIN_NAMES.has(node.name)) {
+        targetSet.add(node.name);
+      }
+      if (node.type === 'CallExpression' && node.callee && node.callee.type === 'Identifier' && BUILTIN_NAMES.has(node.callee.name)) {
+        targetSet.add(node.callee.name);
+      }
+      for (const key of Object.keys(node)) {
+        if (key === 'loc' || key === 'type') continue;
+        const val = node[key];
+        if (Array.isArray(val)) {
+          for (const item of val) {
+            if (item && typeof item === 'object') walk(item);
+          }
+        } else if (val && typeof val === 'object' && val.type) {
+          walk(val);
+        }
+      }
+    };
+    for (const block of blocks) walk(block);
+  }
+
   _genDataBlock(node, gen) {
     const lines = [];
     lines.push('// ── Data Block ──');

package/src/config/edit-toml.js

@@ -0,0 +1,100 @@
+// Line-level TOML editing for tova add / tova remove.
+// Operates on raw text to preserve formatting, comments, and whitespace.
+
+import { readFileSync, writeFileSync } from 'fs';
+
+export function addToSection(filePath, section, key, value) {
+  const content = readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n');
+  const entry = `${key} = "${value}"`;
+
+  // Find the section header
+  const sectionIdx = findSectionIndex(lines, section);
+
+  if (sectionIdx === -1) {
+    // Section doesn't exist — append it at end of file
+    const newLines = [...lines];
+    // Ensure blank line before new section
+    if (newLines.length > 0 && newLines[newLines.length - 1].trim() !== '') {
+      newLines.push('');
+    }
+    newLines.push(`[${section}]`);
+    newLines.push(entry);
+    writeFileSync(filePath, newLines.join('\n'));
+    return;
+  }
+
+  // Find the end of this section (next section header or EOF)
+  const endIdx = findSectionEnd(lines, sectionIdx);
+
+  // Check if key already exists in this section — update it
+  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) {
+        lines[i] = entry;
+        writeFileSync(filePath, lines.join('\n'));
+        return;
+      }
+    }
+  }
+
+  // Key doesn't exist — insert after last non-blank line in section
+  let insertIdx = sectionIdx + 1;
+  for (let i = endIdx - 1; i > sectionIdx; i--) {
+    if (lines[i].trim() !== '') {
+      insertIdx = i + 1;
+      break;
+    }
+  }
+  lines.splice(insertIdx, 0, entry);
+  writeFileSync(filePath, lines.join('\n'));
+}
+
+export function removeFromSection(filePath, section, key) {
+  const content = readFileSync(filePath, 'utf-8');
+  const lines = content.split('\n');
+
+  const sectionIdx = findSectionIndex(lines, section);
+  if (sectionIdx === -1) return false;
+
+  const endIdx = findSectionEnd(lines, sectionIdx);
+
+  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) {
+        lines.splice(i, 1);
+        writeFileSync(filePath, lines.join('\n'));
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+function findSectionIndex(lines, section) {
+  const pattern = `[${section}]`;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line === pattern) return i;
+  }
+  return -1;
+}
+
+function findSectionEnd(lines, sectionIdx) {
+  for (let i = sectionIdx + 1; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.startsWith('[') && !line.startsWith('[[')) {
+      return i;
+    }
+  }
+  return lines.length;
+}

package/src/config/package-json.js

@@ -0,0 +1,52 @@
+// Generate a shadow package.json from tova.toml config.
+
+import { writeFileSync, existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+const MARKER = '// Auto-generated from tova.toml. Do not edit.';
+
+export function generatePackageJson(config, cwd) {
+  const npmProd = config.npm?.prod || {};
+  const npmDev = config.npm?.dev || {};
+
+  const hasNpmDeps = Object.keys(npmProd).length > 0 || Object.keys(npmDev).length > 0;
+  if (!hasNpmDeps) return null;
+
+  const pkg = {
+    '//': MARKER,
+    name: config.project.name,
+    version: config.project.version,
+    private: true,
+    type: 'module',
+  };
+
+  if (Object.keys(npmProd).length > 0) {
+    pkg.dependencies = npmProd;
+  }
+
+  if (Object.keys(npmDev).length > 0) {
+    pkg.devDependencies = npmDev;
+  }
+
+  return pkg;
+}
+
+export function writePackageJson(config, cwd) {
+  const pkg = generatePackageJson(config, cwd);
+  if (!pkg) return false;
+
+  const pkgPath = join(cwd, 'package.json');
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+  return true;
+}
+
+export function isGeneratedPackageJson(cwd) {
+  const pkgPath = join(cwd, 'package.json');
+  if (!existsSync(pkgPath)) return false;
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    return pkg['//'] === MARKER;
+  } catch {
+    return false;
+  }
+}

package/src/config/resolve.js

@@ -0,0 +1,100 @@
+// Config resolution: reads tova.toml → falls back to package.json → defaults.
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { parseTOML } from './toml.js';
+
+const DEFAULTS = {
+  project: {
+    name: 'tova-app',
+    version: '0.1.0',
+    description: '',
+    entry: 'src',
+  },
+  build: {
+    output: '.tova-out',
+  },
+  dev: {
+    port: 3000,
+  },
+  dependencies: {},
+  npm: {},
+};
+
+export function resolveConfig(cwd) {
+  const tomlPath = join(cwd, 'tova.toml');
+  const pkgPath = join(cwd, 'package.json');
+
+  // Try tova.toml first
+  if (existsSync(tomlPath)) {
+    const raw = readFileSync(tomlPath, 'utf-8');
+    const parsed = parseTOML(raw);
+    return normalizeConfig(parsed, 'tova.toml');
+  }
+
+  // Fall back to package.json
+  if (existsSync(pkgPath)) {
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    return configFromPackageJson(pkg);
+  }
+
+  // Return defaults
+  return { ...DEFAULTS, _source: 'defaults' };
+}
+
+function normalizeConfig(parsed, source) {
+  const config = {
+    project: {
+      name: parsed.project?.name || DEFAULTS.project.name,
+      version: parsed.project?.version || DEFAULTS.project.version,
+      description: parsed.project?.description || DEFAULTS.project.description,
+      entry: parsed.project?.entry || DEFAULTS.project.entry,
+    },
+    build: {
+      output: parsed.build?.output || DEFAULTS.build.output,
+    },
+    dev: {
+      port: parsed.dev?.port ?? DEFAULTS.dev.port,
+    },
+    dependencies: parsed.dependencies || {},
+    npm: {},
+    _source: source,
+  };
+
+  // Collect npm deps: top-level from [npm], dev deps from [npm.dev]
+  if (parsed.npm) {
+    for (const [key, value] of Object.entries(parsed.npm)) {
+      if (key === 'dev' && typeof value === 'object' && !Array.isArray(value)) {
+        config.npm.dev = value;
+      } else if (typeof value === 'string') {
+        if (!config.npm.prod) config.npm.prod = {};
+        config.npm.prod[key] = value;
+      }
+    }
+  }
+
+  return config;
+}
+
+function configFromPackageJson(pkg) {
+  return {
+    project: {
+      name: pkg.name || DEFAULTS.project.name,
+      version: pkg.version || DEFAULTS.project.version,
+      description: pkg.description || DEFAULTS.project.description,
+      entry: DEFAULTS.project.entry,
+    },
+    build: {
+      output: DEFAULTS.build.output,
+    },
+    dev: {
+      port: DEFAULTS.dev.port,
+    },
+    dependencies: {},
+    npm: {
+      prod: pkg.dependencies || {},
+      dev: pkg.devDependencies || {},
+    },
+    _source: 'package.json',
+  };
+}

package/src/config/toml.js

@@ -0,0 +1,209 @@
+// Minimal TOML parser for tova.toml project manifests.
+// Handles: sections ([name], [a.b]), strings, numbers, booleans, simple arrays.
+
+export function parseTOML(input) {
+  const result = {};
+  let current = result;
+  const lines = input.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const line = raw.trim();
+
+    // Skip empty lines and comments
+    if (line === '' || line.startsWith('#')) continue;
+
+    // Section header: [section] or [section.subsection]
+    if (line.startsWith('[') && !line.startsWith('[[')) {
+      const close = line.indexOf(']');
+      if (close === -1) {
+        throw new Error(`TOML parse error on line ${i + 1}: unclosed section header`);
+      }
+      const sectionPath = line.slice(1, close).trim();
+      if (!sectionPath) {
+        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();
+        if (!current[key]) current[key] = {};
+        current = current[key];
+      }
+      continue;
+    }
+
+    // Key = value
+    const eqIdx = line.indexOf('=');
+    if (eqIdx === -1) continue; // skip lines without =
+
+    const key = line.slice(0, eqIdx).trim();
+    const rawValue = line.slice(eqIdx + 1).trim();
+
+    current[key] = parseValue(rawValue, i + 1);
+  }
+
+  return result;
+}
+
+function parseValue(raw, lineNum) {
+  if (raw === '') {
+    throw new Error(`TOML parse error on line ${lineNum}: missing value`);
+  }
+
+  // Strip inline comment (not inside quotes)
+  const stripped = stripInlineComment(raw);
+
+  // Boolean
+  if (stripped === 'true') return true;
+  if (stripped === 'false') return false;
+
+  // Quoted string (double or single)
+  if ((stripped.startsWith('"') && stripped.endsWith('"')) ||
+      (stripped.startsWith("'") && stripped.endsWith("'"))) {
+    return parseString(stripped);
+  }
+
+  // Array
+  if (stripped.startsWith('[')) {
+    return parseArray(stripped, lineNum);
+  }
+
+  // Number (integer or float)
+  if (/^-?\d+(\.\d+)?$/.test(stripped)) {
+    return stripped.includes('.') ? parseFloat(stripped) : parseInt(stripped, 10);
+  }
+
+  // Bare value (treat as string for compat with version ranges like ^2.0.0)
+  return stripped;
+}
+
+function stripInlineComment(raw) {
+  // Find # that's not inside a quoted string
+  let inStr = null;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (inStr) {
+      if (ch === '\\') { i++; continue; }
+      if (ch === inStr) inStr = null;
+    } else {
+      if (ch === '"' || ch === "'") { inStr = ch; continue; }
+      if (ch === '#') return raw.slice(0, i).trim();
+    }
+  }
+  return raw;
+}
+
+function parseString(raw) {
+  const quote = raw[0];
+  const inner = raw.slice(1, -1);
+  if (quote === '"') {
+    // Handle escape sequences
+    return inner
+      .replace(/\\n/g, '\n')
+      .replace(/\\t/g, '\t')
+      .replace(/\\r/g, '\r')
+      .replace(/\\\\/g, '\\')
+      .replace(/\\"/g, '"');
+  }
+  // Single-quoted: literal string, no escapes
+  return inner;
+}
+
+function parseArray(raw, lineNum) {
+  // Simple single-line array: [val1, val2, ...]
+  if (!raw.endsWith(']')) {
+    throw new Error(`TOML parse error on line ${lineNum}: unclosed array`);
+  }
+  const inner = raw.slice(1, -1).trim();
+  if (inner === '') return [];
+
+  const items = [];
+  let current = '';
+  let depth = 0;
+  let inStr = null;
+
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (inStr) {
+      current += ch;
+      if (ch === '\\') { current += inner[++i] || ''; continue; }
+      if (ch === inStr) inStr = null;
+    } else {
+      if (ch === '"' || ch === "'") { inStr = ch; current += ch; continue; }
+      if (ch === '[') { depth++; current += ch; continue; }
+      if (ch === ']') { depth--; current += ch; continue; }
+      if (ch === ',' && depth === 0) {
+        const val = current.trim();
+        if (val !== '') items.push(parseValue(val, lineNum));
+        current = '';
+        continue;
+      }
+      current += ch;
+    }
+  }
+  const last = current.trim();
+  if (last !== '') items.push(parseValue(last, lineNum));
+
+  return items;
+}
+
+export function stringifyTOML(obj, _prefix = '') {
+  const lines = [];
+  const sections = [];
+
+  // Write top-level key-value pairs first
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+      sections.push([key, value]);
+    } else {
+      lines.push(`${key} = ${formatValue(value)}`);
+    }
+  }
+
+  // Write sections
+  for (const [key, value] of sections) {
+    const sectionKey = _prefix ? `${_prefix}.${key}` : key;
+    const { topLevel, nested } = splitObject(value);
+
+    if (lines.length > 0 || sections.indexOf([key, value]) > 0) {
+      lines.push('');
+    }
+    lines.push(`[${sectionKey}]`);
+
+    for (const [k, v] of Object.entries(topLevel)) {
+      lines.push(`${k} = ${formatValue(v)}`);
+    }
+
+    for (const [k, v] of Object.entries(nested)) {
+      const nestedKey = `${sectionKey}.${k}`;
+      lines.push('');
+      lines.push(`[${nestedKey}]`);
+      for (const [nk, nv] of Object.entries(v)) {
+        lines.push(`${nk} = ${formatValue(nv)}`);
+      }
+    }
+  }
+
+  return lines.join('\n') + '\n';
+}
+
+function splitObject(obj) {
+  const topLevel = {};
+  const nested = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+      nested[key] = value;
+    } else {
+      topLevel[key] = value;
+    }
+  }
+  return { topLevel, nested };
+}
+
+function formatValue(value) {
+  if (typeof value === 'string') return `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'number') return String(value);
+  if (Array.isArray(value)) return `[${value.map(formatValue).join(', ')}]`;
+  return String(value);
+}