tova 0.1.1 → 0.2.2

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>') {
@@ -30,6 +31,7 @@ export class CodeGenerator {
     const topLevel = [];
 
     const testBlocks = [];
+    const dataBlocks = [];
 
     for (const node of this.ast.body) {
       switch (node.type) {
@@ -37,6 +39,7 @@ export class CodeGenerator {
         case 'ServerBlock': serverBlocks.push(node); break;
         case 'ClientBlock': clientBlocks.push(node); break;
         case 'TestBlock': testBlocks.push(node); break;
+        case 'DataBlock': dataBlocks.push(node); break;
         default: topLevel.push(node); break;
       }
     }
@@ -46,8 +49,16 @@ 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();
-    const combinedShared = [helpers, sharedCode, topLevelCode].filter(s => s.trim()).join('\n').trim();
+
+    // Generate data block code (sources, pipelines, validators, refresh)
+    const dataCode = dataBlocks.map(b => this._genDataBlock(b, sharedGen)).join('\n');
+
+    const combinedShared = [helpers, sharedCode, topLevelCode, dataCode].filter(s => s.trim()).join('\n').trim();
 
     // Group server and client blocks by name
     const serverGroups = this._groupByName(serverBlocks);
@@ -99,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
@@ -145,4 +156,102 @@ export class CodeGenerator {
     if (testCode) result.test = testCode;
     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 ──');
+
+    for (const stmt of node.body) {
+      switch (stmt.type) {
+        case 'SourceDeclaration': {
+          // Source: lazy cached getter
+          const expr = gen.genExpression(stmt.expression);
+          lines.push(`let __data_${stmt.name}_cache = null;`);
+          lines.push(`async function __data_${stmt.name}_load() {`);
+          lines.push(`  if (__data_${stmt.name}_cache === null) {`);
+          lines.push(`    __data_${stmt.name}_cache = await ${expr};`);
+          lines.push(`  }`);
+          lines.push(`  return __data_${stmt.name}_cache;`);
+          lines.push(`}`);
+          // Also expose as a simple getter variable via lazy init
+          lines.push(`let ${stmt.name} = null;`);
+          lines.push(`Object.defineProperty(globalThis, ${JSON.stringify(stmt.name)}, {`);
+          lines.push(`  get() { if (${stmt.name} === null) { ${stmt.name} = __data_${stmt.name}_load(); } return ${stmt.name}; },`);
+          lines.push(`  configurable: true,`);
+          lines.push(`});`);
+          break;
+        }
+        case 'PipelineDeclaration': {
+          // Pipeline: function that chains transforms
+          const expr = gen.genExpression(stmt.expression);
+          lines.push(`async function __pipeline_${stmt.name}() {`);
+          lines.push(`  return ${expr};`);
+          lines.push(`}`);
+          lines.push(`let ${stmt.name} = null;`);
+          lines.push(`Object.defineProperty(globalThis, ${JSON.stringify(stmt.name)}, {`);
+          lines.push(`  get() { if (${stmt.name} === null) { ${stmt.name} = __pipeline_${stmt.name}(); } return ${stmt.name}; },`);
+          lines.push(`  configurable: true,`);
+          lines.push(`});`);
+          break;
+        }
+        case 'ValidateBlock': {
+          // Validate: validator function
+          const rules = stmt.rules.map(r => gen.genExpression(r));
+          lines.push(`function __validate_${stmt.typeName}(it) {`);
+          lines.push(`  const errors = [];`);
+          for (let i = 0; i < rules.length; i++) {
+            lines.push(`  if (!(${rules[i]})) errors.push("Validation rule ${i + 1} failed for ${stmt.typeName}");`);
+          }
+          lines.push(`  return errors.length === 0 ? { valid: true, errors: [] } : { valid: false, errors };`);
+          lines.push(`}`);
+          break;
+        }
+        case 'RefreshPolicy': {
+          // Refresh: interval cache invalidation
+          if (stmt.interval === 'on_demand') {
+            lines.push(`function refresh_${stmt.sourceName}() { __data_${stmt.sourceName}_cache = null; ${stmt.sourceName} = null; }`);
+          } else {
+            const { value, unit } = stmt.interval;
+            let ms;
+            switch (unit) {
+              case 'seconds': case 'second': ms = value * 1000; break;
+              case 'minutes': case 'minute': ms = value * 60 * 1000; break;
+              case 'hours': case 'hour': ms = value * 60 * 60 * 1000; break;
+              case 'days': case 'day': ms = value * 24 * 60 * 60 * 1000; break;
+              default: ms = value * 60 * 1000; // default to minutes
+            }
+            lines.push(`setInterval(() => { __data_${stmt.sourceName}_cache = null; ${stmt.sourceName} = null; }, ${ms});`);
+          }
+          break;
+        }
+      }
+    }
+
+    return lines.join('\n');
+  }
 }

package/src/codegen/server-codegen.js

@@ -154,6 +154,7 @@ export class ServerCodegen extends BaseCodegen {
     let cacheConfig = null;
     const sseDecls = [];
     const modelDecls = [];
+    const aiConfigs = []; // { name: string|null, config: object }
 
     const collectFromBody = (stmts, groupPrefix = null, groupMiddlewares = []) => {
       for (const stmt of stmts) {
@@ -225,6 +226,8 @@ export class ServerCodegen extends BaseCodegen {
           sseDecls.push(stmt);
         } else if (stmt.type === 'ModelDeclaration') {
           modelDecls.push(stmt);
+        } else if (stmt.type === 'AiConfigDeclaration') {
+          aiConfigs.push(stmt);
         } else {
           otherStatements.push(stmt);
         }
@@ -463,6 +466,32 @@ export class ServerCodegen extends BaseCodegen {
       lines.push('');
     }
 
+    // ════════════════════════════════════════════════════════════
+    // 3b. AI Client Initialization
+    // ════════════════════════════════════════════════════════════
+    if (aiConfigs.length > 0) {
+      lines.push('// ── AI Clients ──');
+      lines.push(this._getAiRuntime());
+      lines.push('');
+
+      for (const aiConf of aiConfigs) {
+        const configParts = [];
+        for (const [key, valueNode] of Object.entries(aiConf.config)) {
+          configParts.push(`  ${key}: ${this.genExpression(valueNode)}`);
+        }
+        const configStr = `{\n${configParts.join(',\n')}\n}`;
+
+        if (aiConf.name) {
+          // Named provider: ai "claude" { ... } → const claude = __createAI({...})
+          lines.push(`const ${aiConf.name} = __createAI(${configStr});`);
+        } else {
+          // Default provider: ai { ... } → const ai = __createAI({...})
+          lines.push(`const ai = __createAI(${configStr});`);
+        }
+      }
+      lines.push('');
+    }
+
     // ════════════════════════════════════════════════════════════
     // 4. Peer Server RPC Proxies (with circuit breaker + retry)
     // ════════════════════════════════════════════════════════════
@@ -1179,7 +1208,17 @@ export class ServerCodegen extends BaseCodegen {
       const aw = isAsync ? 'await ' : '';
       for (const modelDecl of modelDecls) {
         const typeName = modelDecl.name;
-        const typeInfo = sharedTypes.get(typeName);
+        let typeInfo = sharedTypes.get(typeName);
+        // Fall back to model declaration fields if shared type not in this file (multi-file)
+        if (!typeInfo && modelDecl.config) {
+          const fields = [{ name: 'id', type: 'Int' }];
+          for (const [key, value] of Object.entries(modelDecl.config)) {
+            if (key === 'table' || key === 'timestamps' || key === 'belongs_to' || key === 'has_many') continue;
+            const fieldType = value.name || (value.type === 'ArrayTypeAnnotation' ? 'Array' : 'Any');
+            fields.push({ name: key, type: fieldType });
+          }
+          if (fields.length > 0) typeInfo = { fields };
+        }
         if (!typeInfo) continue;
         const tableName = modelDecl.config && modelDecl.config.table
           ? this.genExpression(modelDecl.config.table).replace(/"/g, '')
@@ -1378,6 +1417,10 @@ export class ServerCodegen extends BaseCodegen {
         }
 
         lines.push('};');
+        // Alias so server functions can reference the model by its original type name
+        // Use var so it works both when Task is already declared (single-file shared block)
+        // and when it isn't (multi-file: server in separate file from shared types)
+        lines.push(`var ${typeName} = ${typeName}Model;`);
         lines.push('');
       }
     }
@@ -1937,8 +1980,8 @@ export class ServerCodegen extends BaseCodegen {
       lines.push('  const html = `<!DOCTYPE html><html><head><title>API Docs</title>');
       lines.push('    <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css"></head>');
       lines.push('    <body><div id="swagger-ui"></div>');
-      lines.push('    <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>');
-      lines.push('    <script>SwaggerUIBundle({ url: "/openapi.json", dom_id: "#swagger-ui" });</script>');
+      lines.push('    <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"><\\/script>');
+      lines.push('    <script>SwaggerUIBundle({ url: "/openapi.json", dom_id: "#swagger-ui" });<\\/script>');
       lines.push('    </body></html>`;');
       lines.push('  return new Response(html, { headers: { "Content-Type": "text/html" } });');
       lines.push('});');
@@ -2503,4 +2546,133 @@ export class ServerCodegen extends BaseCodegen {
 
     return lines.join('\n');
   }
+
+  _getAiRuntime() {
+    return `// AI Client Runtime
+function __createAI(config) {
+  const providerName = config.provider || 'custom';
+  async function __aiRequest(method, args, callOpts = {}) {
+    const cfg = { ...config, ...callOpts };
+    const baseUrl = cfg.base_url || (providerName === 'anthropic' ? 'https://api.anthropic.com' : providerName === 'ollama' ? 'http://localhost:11434' : 'https://api.openai.com');
+    const headers = { 'Content-Type': 'application/json', ...(cfg.headers || {}) };
+    if (providerName === 'anthropic') {
+      headers['x-api-key'] = cfg.api_key;
+      headers['anthropic-version'] = '2023-06-01';
+    } else if (cfg.api_key) {
+      headers['Authorization'] = 'Bearer ' + cfg.api_key;
+    }
+    const timeout = cfg.timeout || 60000;
+
+    if (method === 'ask') {
+      const [prompt, opts] = args;
+      let body, url;
+      if (providerName === 'anthropic') {
+        body = { model: cfg.model, max_tokens: opts?.max_tokens || cfg.max_tokens || 4096, messages: [{ role: 'user', content: prompt }] };
+        if (opts?.temperature ?? cfg.temperature) body.temperature = opts?.temperature ?? cfg.temperature;
+        if (opts?.tools) body.tools = opts.tools.map(t => ({ name: t.name, description: t.description, input_schema: { type: 'object', properties: t.params ? Object.fromEntries(Object.entries(t.params).map(([k, v]) => [k, { type: typeof v === 'string' ? v.toLowerCase() : 'string' }])) : {} } }));
+        url = baseUrl + '/v1/messages';
+      } else if (providerName === 'ollama') {
+        body = { model: cfg.model, messages: [{ role: 'user', content: prompt }], stream: false };
+        url = baseUrl + '/api/chat';
+      } else {
+        body = { model: cfg.model, messages: [{ role: 'user', content: prompt }] };
+        if (opts?.max_tokens || cfg.max_tokens) body.max_tokens = opts?.max_tokens || cfg.max_tokens;
+        if (opts?.temperature ?? cfg.temperature) body.temperature = opts?.temperature ?? cfg.temperature;
+        if (opts?.tools) body.tools = opts.tools.map(t => ({ type: 'function', function: { name: t.name, description: t.description, parameters: { type: 'object', properties: t.params ? Object.fromEntries(Object.entries(t.params).map(([k, v]) => [k, { type: typeof v === 'string' ? v.toLowerCase() : 'string' }])) : {} } } }));
+        url = baseUrl + '/v1/chat/completions';
+      }
+      const res = await fetch(url, { method: 'POST', headers, body: JSON.stringify(body), signal: AbortSignal.timeout(timeout) });
+      if (!res.ok) throw new Error(providerName + ' API error ' + res.status + ': ' + (await res.text()));
+      const data = await res.json();
+      if (providerName === 'anthropic') {
+        if (opts?.tools && data.content?.some(c => c.type === 'tool_use')) return { text: data.content.filter(c => c.type === 'text').map(c => c.text).join(''), tool_calls: data.content.filter(c => c.type === 'tool_use') };
+        return data.content.map(c => c.text).join('');
+      }
+      if (providerName === 'ollama') return data.message.content;
+      const choice = data.choices[0];
+      if (opts?.tools && choice.message.tool_calls) return { text: choice.message.content || '', tool_calls: choice.message.tool_calls };
+      return choice.message.content;
+    }
+
+    if (method === 'chat') {
+      const [messages, opts] = args;
+      let body, url;
+      if (providerName === 'anthropic') {
+        const sys = messages.filter(m => m.role === 'system');
+        const msgs = messages.filter(m => m.role !== 'system');
+        body = { model: cfg.model, max_tokens: opts?.max_tokens || cfg.max_tokens || 4096, messages: msgs };
+        if (sys.length > 0) body.system = sys.map(m => m.content).join('\\n');
+        url = baseUrl + '/v1/messages';
+      } else if (providerName === 'ollama') {
+        body = { model: cfg.model, messages, stream: false };
+        url = baseUrl + '/api/chat';
+      } else {
+        body = { model: cfg.model, messages };
+        if (opts?.max_tokens || cfg.max_tokens) body.max_tokens = opts?.max_tokens || cfg.max_tokens;
+        url = baseUrl + '/v1/chat/completions';
+      }
+      if (opts?.temperature ?? cfg.temperature) body.temperature = opts?.temperature ?? cfg.temperature;
+      const res = await fetch(url, { method: 'POST', headers, body: JSON.stringify(body), signal: AbortSignal.timeout(timeout) });
+      if (!res.ok) throw new Error(providerName + ' API error ' + res.status + ': ' + (await res.text()));
+      const data = await res.json();
+      if (providerName === 'anthropic') return data.content.map(c => c.text).join('');
+      if (providerName === 'ollama') return data.message.content;
+      return data.choices[0].message.content;
+    }
+
+    if (method === 'embed') {
+      const [input, opts] = args;
+      let body, url;
+      if (providerName === 'ollama') {
+        url = baseUrl + '/api/embeddings';
+        if (Array.isArray(input)) {
+          const results = [];
+          for (const text of input) {
+            const r = await fetch(url, { method: 'POST', headers, body: JSON.stringify({ model: cfg.model, prompt: text }) });
+            results.push((await r.json()).embedding);
+          }
+          return results;
+        }
+        body = { model: cfg.model, prompt: input };
+      } else {
+        body = { model: cfg.model || 'text-embedding-3-small', input };
+        url = baseUrl + '/v1/embeddings';
+      }
+      const res = await fetch(url, { method: 'POST', headers, body: JSON.stringify(body), signal: AbortSignal.timeout(timeout) });
+      if (!res.ok) throw new Error(providerName + ' API error ' + res.status + ': ' + (await res.text()));
+      const data = await res.json();
+      if (providerName === 'ollama') return data.embedding;
+      if (Array.isArray(input)) return data.data.map(d => d.embedding);
+      return data.data[0].embedding;
+    }
+
+    if (method === 'extract') {
+      const [prompt, schema, opts] = args;
+      const extractPrompt = prompt + '\\n\\nRespond with a JSON object matching this schema: ' + JSON.stringify(schema);
+      const text = await __aiRequest('ask', [extractPrompt, opts]);
+      try { return JSON.parse(text); } catch { return JSON.parse(text.match(/\\{[\\s\\S]*\\}/)?.[0] || '{}'); }
+    }
+
+    if (method === 'classify') {
+      const [text, categories, opts] = args;
+      const catList = Array.isArray(categories) ? categories : Object.keys(categories);
+      const classifyPrompt = 'Classify into one of: ' + catList.join(', ') + '\\n\\nText: "' + text + '"\\n\\nRespond with only the category name.';
+      const result = (await __aiRequest('ask', [classifyPrompt, { ...opts, max_tokens: 100 }])).trim();
+      return catList.find(c => c.toLowerCase() === result.toLowerCase()) || result;
+    }
+
+    throw new Error('Unknown AI method: ' + method);
+  }
+
+  return {
+    ask(prompt, opts) { return __aiRequest('ask', [prompt, opts || {}], opts); },
+    chat(messages, opts) { return __aiRequest('chat', [messages, opts || {}], opts); },
+    embed(input, opts) { return __aiRequest('embed', [input, opts || {}], opts); },
+    extract(prompt, schema, opts) { return __aiRequest('extract', [prompt, schema, opts || {}], opts); },
+    classify(text, categories, opts) { return __aiRequest('classify', [text, categories, opts || {}], opts); },
+  };
+}
+// Default AI object for one-off calls (no config block required)
+const ai = typeof ai === 'undefined' ? __createAI({}) : ai;`;
+  }
 }

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',
+  };
+}