voyageai-cli 1.30.0 → 1.30.2

package/src/lib/code-search.js

@@ -0,0 +1,315 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { loadProject } = require('./project');
+
+const DEFAULT_CODE_MODEL = 'voyage-code-3';
+const DEFAULT_DB = 'vai_code_search';
+
+const CODE_EXTENSIONS = [
+  '.js', '.ts', '.jsx', '.tsx', '.py', '.go', '.rs', '.java', '.c', '.cpp',
+  '.h', '.hpp', '.cs', '.rb', '.php', '.swift', '.kt', '.scala', '.ex',
+  '.exs', '.clj', '.hs', '.ml', '.fs', '.vue', '.svelte', '.sh', '.bash',
+];
+
+const DOC_EXTENSIONS = ['.md', '.rst', '.txt', '.adoc', '.rdoc'];
+
+const DEFAULT_IGNORE = [
+  'node_modules', '.git', '.svn', '.hg', 'dist', 'build', 'out', 'target',
+  '__pycache__', '.cache', '.next', '.nuxt', 'coverage', '.nyc_output',
+  'vendor', 'venv', '.venv', 'env', '.idea', '.vscode',
+  'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'Cargo.lock',
+  '*.min.js', '*.min.css', '*.map', '*.chunk.js',
+];
+
+/**
+ * Language-aware function/class boundary patterns.
+ */
+const BOUNDARY_PATTERNS = {
+  js: /^(?:(?:export\s+)?(?:async\s+)?function\s+\w+|(?:export\s+)?(?:const|let|var)\s+\w+\s*=\s*(?:async\s+)?(?:function|\()|(?:export\s+)?class\s+\w+|module\.exports)/m,
+  ts: /^(?:(?:export\s+)?(?:async\s+)?function\s+\w+|(?:export\s+)?(?:const|let)\s+\w+\s*[=:]|(?:export\s+)?(?:class|interface|type|enum)\s+\w+)/m,
+  py: /^(?:def\s+|async\s+def\s+|class\s+)/m,
+  go: /^(?:func\s+|type\s+\w+\s+(?:struct|interface))/m,
+  rs: /^(?:(?:pub\s+)?fn\s+|(?:pub\s+)?(?:struct|enum|trait|impl)\s+)/m,
+  java: /^(?:\s*(?:public|private|protected)\s+(?:static\s+)?(?:class|interface|void|\w+)\s+\w+)/m,
+  rb: /^(?:def\s+|class\s+|module\s+)/m,
+  php: /^(?:\s*(?:public|private|protected)?\s*(?:static\s+)?function\s+|class\s+)/m,
+};
+
+/**
+ * Get the boundary pattern for a file extension.
+ * @param {string} ext
+ * @returns {RegExp|null}
+ */
+function getBoundaryPattern(ext) {
+  const lang = ext.replace('.', '');
+  const map = {
+    js: 'js', jsx: 'js', mjs: 'js', cjs: 'js',
+    ts: 'ts', tsx: 'ts', mts: 'ts',
+    py: 'py',
+    go: 'go',
+    rs: 'rs',
+    java: 'java', kt: 'java', scala: 'java',
+    rb: 'rb',
+    php: 'php',
+  };
+  const key = map[lang];
+  return key ? BOUNDARY_PATTERNS[key] : null;
+}
+
+/**
+ * Smart chunk code: try splitting by function/class boundaries first,
+ * fall back to recursive character-based chunking.
+ * @param {string} content
+ * @param {string} filePath
+ * @param {object} opts
+ * @returns {Array<{text: string, startLine: number, endLine: number, type: string}>}
+ */
+function smartChunkCode(content, filePath, opts = {}) {
+  const { chunk } = require('./chunker');
+  const ext = path.extname(filePath).toLowerCase();
+  const pattern = getBoundaryPattern(ext);
+  const chunkSize = opts.chunkSize || 512;
+  const chunkOverlap = opts.chunkOverlap || 50;
+  const lines = content.split('\n');
+
+  // Try boundary-based splitting
+  if (pattern) {
+    const boundaries = [];
+    for (let i = 0; i < lines.length; i++) {
+      if (pattern.test(lines[i])) {
+        boundaries.push(i);
+      }
+    }
+
+    if (boundaries.length > 1) {
+      const chunks = [];
+      for (let i = 0; i < boundaries.length; i++) {
+        const start = boundaries[i];
+        const end = i + 1 < boundaries.length ? boundaries[i + 1] : lines.length;
+        const text = lines.slice(start, end).join('\n').trim();
+        if (text.length >= 20) {
+          if (text.length > chunkSize * 2) {
+            const subChunks = chunk(text, { strategy: 'recursive', size: chunkSize, overlap: chunkOverlap });
+            let lineOffset = start;
+            for (const sc of subChunks) {
+              const scLines = sc.split('\n').length;
+              chunks.push({ text: sc, startLine: lineOffset + 1, endLine: lineOffset + scLines, type: 'boundary' });
+              lineOffset += scLines;
+            }
+          } else {
+            chunks.push({ text, startLine: start + 1, endLine: end, type: 'boundary' });
+          }
+        }
+      }
+      if (boundaries[0] > 0) {
+        const preamble = lines.slice(0, boundaries[0]).join('\n').trim();
+        if (preamble.length >= 20) {
+          chunks.unshift({ text: preamble, startLine: 1, endLine: boundaries[0], type: 'preamble' });
+        }
+      }
+      if (chunks.length > 0) return chunks;
+    }
+  }
+
+  // Fallback: recursive chunking with line number tracking
+  const { chunk: chunkFn } = require('./chunker');
+  const textChunks = chunkFn(content, { strategy: 'recursive', size: chunkSize, overlap: chunkOverlap });
+  const result = [];
+  let searchFrom = 0;
+  for (const tc of textChunks) {
+    const firstLine = tc.split('\n')[0];
+    let startLine = searchFrom;
+    for (let i = searchFrom; i < lines.length; i++) {
+      if (lines[i].includes(firstLine.trim().slice(0, 40))) {
+        startLine = i;
+        break;
+      }
+    }
+    const chunkLines = tc.split('\n').length;
+    result.push({ text: tc, startLine: startLine + 1, endLine: startLine + chunkLines, type: 'character' });
+    searchFrom = startLine + 1;
+  }
+  return result;
+}
+
+/**
+ * Extract symbol names from code.
+ * @param {string} content
+ * @param {string} filePath
+ * @returns {string[]}
+ */
+function extractSymbols(content, filePath) {
+  const ext = path.extname(filePath).toLowerCase().slice(1);
+  const patterns = {
+    js: [/(?:function\s+|const\s+|let\s+|var\s+)(\w+)\s*(?:=\s*(?:async\s+)?(?:function|\(|=>)|\()/g, /class\s+(\w+)/g],
+    ts: [/(?:function\s+|const\s+|let\s+)(\w+)\s*(?:=\s*(?:async\s+)?(?:function|\(|=>)|[<(])/g, /(?:class|interface|type)\s+(\w+)/g],
+    py: [/(?:def|async def)\s+(\w+)\s*\(/g, /class\s+(\w+)/g],
+    go: [/func\s+(?:\([^)]+\)\s+)?(\w+)\s*\(/g, /type\s+(\w+)\s+struct/g],
+    rs: [/fn\s+(\w+)\s*[<(]/g, /(?:struct|enum|trait)\s+(\w+)/g],
+    java: [/(?:public|private|protected)?\s*(?:static)?\s*\w+\s+(\w+)\s*\(/g, /class\s+(\w+)/g],
+    rb: [/def\s+(\w+)/g, /class\s+(\w+)/g],
+    php: [/function\s+(\w+)/g, /class\s+(\w+)/g],
+  };
+  const langMap = { jsx: 'js', mjs: 'js', cjs: 'js', tsx: 'ts', mts: 'ts', kt: 'java', scala: 'java' };
+  const lang = langMap[ext] || ext;
+  const langPatterns = patterns[lang] || patterns.js;
+  const symbols = [];
+  for (const p of langPatterns) {
+    let m;
+    while ((m = p.exec(content)) !== null) {
+      if (m[1] && !symbols.includes(m[1])) symbols.push(m[1]);
+    }
+  }
+  return symbols.slice(0, 50);
+}
+
+/**
+ * Parse .gitignore patterns from a directory.
+ * @param {string} dirPath
+ * @returns {string[]}
+ */
+function loadGitignore(dirPath) {
+  const gitignorePath = path.join(dirPath, '.gitignore');
+  try {
+    const content = fs.readFileSync(gitignorePath, 'utf-8');
+    return content
+      .split('\n')
+      .map(l => l.trim())
+      .filter(l => l && !l.startsWith('#'));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Check if a path should be ignored.
+ * @param {string} filePath
+ * @param {string[]} patterns
+ * @returns {boolean}
+ */
+function shouldIgnore(filePath, patterns) {
+  const basename = path.basename(filePath);
+  for (const pattern of patterns) {
+    if (pattern.startsWith('*')) {
+      if (basename.endsWith(pattern.slice(1))) return true;
+    } else if (filePath.includes(pattern) || basename === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Recursively find code files respecting .gitignore.
+ * @param {string} dirPath
+ * @param {object} opts
+ * @returns {Promise<string[]>}
+ */
+async function findCodeFiles(dirPath, opts = {}) {
+  const maxFiles = opts.maxFiles || 5000;
+  const maxFileSize = opts.maxFileSize || 100000;
+  const gitignorePatterns = loadGitignore(dirPath);
+  const allPatterns = [...DEFAULT_IGNORE, ...gitignorePatterns];
+  const files = [];
+
+  async function walk(dir) {
+    if (files.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    } catch { return; }
+    for (const entry of entries) {
+      if (files.length >= maxFiles) break;
+      const fullPath = path.join(dir, entry.name);
+      if (shouldIgnore(fullPath, allPatterns)) continue;
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name).toLowerCase();
+        if (!CODE_EXTENSIONS.includes(ext)) continue;
+        try {
+          const stats = await fs.promises.stat(fullPath);
+          if (stats.size > maxFileSize || stats.size === 0) continue;
+        } catch { continue; }
+        files.push(fullPath);
+      }
+    }
+  }
+
+  await walk(dirPath);
+  return files;
+}
+
+/**
+ * Derive a collection name from a directory path.
+ * @param {string} dirPath
+ * @returns {string}
+ */
+function deriveCollectionName(dirPath) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(dirPath, 'package.json'), 'utf-8'));
+    if (pkg.name) return pkg.name.replace(/[^a-zA-Z0-9_-]/g, '_') + '_code';
+  } catch { /* ignore */ }
+  return path.basename(path.resolve(dirPath)).replace(/[^a-zA-Z0-9_-]/g, '_') + '_code';
+}
+
+/**
+ * Resolve db/collection from options, .vai.json codeSearch config, or defaults.
+ * @param {object} opts
+ * @param {string} [workspacePath]
+ * @returns {{db: string, collection: string, model: string, projectConfig: object}}
+ */
+function resolveConfig(opts, workspacePath) {
+  const { config: proj } = loadProject(workspacePath);
+  const cs = proj.codeSearch || {};
+  const db = opts.db || cs.db || proj.db || DEFAULT_DB;
+  const collection = opts.collection || cs.collection || deriveCollectionName(workspacePath || process.cwd());
+  const model = opts.model || cs.model || DEFAULT_CODE_MODEL;
+  return { db, collection, model, projectConfig: proj };
+}
+
+/**
+ * Auto-select the best embedding model based on file types.
+ * @param {string[]} files - Array of file paths
+ * @param {object} [projectConfig] - Project config from .vai.json
+ * @returns {string}
+ */
+function selectCodeModel(files, projectConfig) {
+  // User override always wins
+  if (projectConfig?.codeSearch?.model) {
+    return projectConfig.codeSearch.model;
+  }
+
+  const total = files.length;
+  if (total === 0) return DEFAULT_CODE_MODEL;
+
+  const codeFiles = files.filter(f => CODE_EXTENSIONS.includes(path.extname(f).toLowerCase()));
+  const docFiles = files.filter(f => DOC_EXTENSIONS.includes(path.extname(f).toLowerCase()));
+
+  const codeRatio = codeFiles.length / total;
+  const docRatio = docFiles.length / total;
+
+  if (codeRatio >= 0.7) return 'voyage-code-3';
+  if (docRatio >= 0.7) return 'voyage-4-large';
+  return 'voyage-code-3';
+}
+
+module.exports = {
+  DEFAULT_CODE_MODEL,
+  DEFAULT_DB,
+  CODE_EXTENSIONS,
+  DOC_EXTENSIONS,
+  DEFAULT_IGNORE,
+  BOUNDARY_PATTERNS,
+  getBoundaryPattern,
+  smartChunkCode,
+  extractSymbols,
+  loadGitignore,
+  shouldIgnore,
+  findCodeFiles,
+  deriveCollectionName,
+  resolveConfig,
+  selectCodeModel,
+};

package/src/lib/codegen.js

@@ -302,7 +302,7 @@ function renderTemplate(target, name, context) {
 function buildContext(project, options = {}) {
   const context = {
     // Core config
-    model: options.model || project.model || 'voyage-3-large',
+    model: options.model || project.model || 'voyage-4-large',
     db: options.db || project.db || 'myapp',
     collection: options.collection || project.collection || 'documents',
     field: options.field || project.field || 'embedding',

package/src/lib/explanations.js

@@ -549,7 +549,7 @@ const concepts = {
       ``,
       `${pc.bold('In practice:')} You don't need to do anything special to use MoE — the API`,
       `interface is identical. The architecture difference shows up in quality and cost:`,
-      `  ${pc.dim('•')} voyage-4-large: $0.12/1M tokens — better quality than voyage-3-large ($0.18/1M)`,
+      `  ${pc.dim('•')} voyage-4-large: $0.12/1M tokens, best quality via MoE architecture`,
       `  ${pc.dim('•')} 40% cheaper than comparable dense models at the same quality tier`,
     ].join('\n'),
     links: [
@@ -616,9 +616,9 @@ const concepts = {
       ``,
       `${pc.bold('Current standings (Jan 2026):')}`,
       `  ${pc.cyan('voyage-4-large')}       ${pc.bold('71.41')}  ${pc.dim('— SOTA, MoE architecture')}`,
-      `  ${pc.cyan('voyage-4')}             ${pc.bold('70.07')}  ${pc.dim('— near voyage-3-large quality')}`,
+      `  ${pc.cyan('voyage-4')}             ${pc.bold('70.07')}  ${pc.dim('— balanced quality/cost')}`,
       `  ${pc.cyan('Gemini Embedding 001')} ${pc.bold('68.66')}  ${pc.dim('— Google')}`,
-      `  ${pc.cyan('voyage-4-lite')}        ${pc.bold('68.10')}  ${pc.dim('— near voyage-3.5 quality')}`,
+      `  ${pc.cyan('voyage-4-lite')}        ${pc.bold('68.10')}  ${pc.dim('— best budget option')}`,
       `  ${pc.cyan('Cohere Embed v4')}      ${pc.bold('65.75')}  ${pc.dim('— Cohere')}`,
       `  ${pc.cyan('OpenAI v3 Large')}      ${pc.bold('62.57')}  ${pc.dim('— OpenAI')}`,
       ``,

package/src/lib/export/contexts/benchmark-export.js

@@ -0,0 +1,27 @@
+'use strict';
+
+/**
+ * Normalize benchmark data for export.
+ * @param {object} data - Raw benchmark data
+ * @param {object} options
+ * @returns {object} normalized
+ */
+function normalizeBenchmark(data, options = {}) {
+  const results = data.results || data.rows || [];
+  const rows = results.map((r) => {
+    const row = { ...r };
+    return row;
+  });
+
+  return {
+    _context: 'benchmark',
+    name: data.name || data.title || 'Benchmark',
+    date: data.date || new Date().toISOString(),
+    results: rows,
+    rows, // alias for CSV renderer
+  };
+}
+
+const BENCHMARK_FORMATS = ['json', 'csv', 'markdown', 'svg', 'png', 'clipboard'];
+
+module.exports = { normalizeBenchmark, BENCHMARK_FORMATS };

package/src/lib/export/contexts/chat-export.js

@@ -0,0 +1,41 @@
+'use strict';
+
+/**
+ * Normalize a chat session for export.
+ * @param {object} data - Raw chat session data
+ * @param {object} options
+ * @returns {object} normalized
+ */
+function normalizeChat(data, options = {}) {
+  const turns = (data.turns || data.messages || []).map((t) => {
+    const turn = {
+      role: t.role,
+      content: t.content,
+      timestamp: t.timestamp,
+    };
+    if (options.includeSources !== false && t.context) {
+      turn.context = t.context;
+    }
+    if (options.includeMetadata && t.metadata) {
+      turn.metadata = t.metadata;
+    }
+    if (options.includeContextChunks && t.contextChunks) {
+      turn.contextChunks = t.contextChunks;
+    }
+    return turn;
+  });
+
+  return {
+    _context: 'chat',
+    sessionId: data.sessionId || data.id,
+    startedAt: data.startedAt,
+    provider: data.provider,
+    model: data.model,
+    collection: data.collection,
+    turns,
+  };
+}
+
+const CHAT_FORMATS = ['json', 'markdown', 'pdf', 'clipboard'];
+
+module.exports = { normalizeChat, CHAT_FORMATS };

package/src/lib/export/contexts/explore-export.js

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * Normalize explore/visualization data for export.
+ * Phase 1 stub — only JSON supported.
+ * @param {object} data
+ * @param {object} options
+ * @returns {object} normalized
+ */
+function normalizeExplore(data, options = {}) {
+  return {
+    _context: 'explore',
+    points: data.points || [],
+    labels: data.labels || [],
+    dimensions: data.dimensions || 2,
+    method: data.method || 'pca',
+  };
+}
+
+const EXPLORE_FORMATS = ['json', 'svg', 'png'];
+
+module.exports = { normalizeExplore, EXPLORE_FORMATS };

package/src/lib/export/contexts/search-export.js

@@ -0,0 +1,54 @@
+'use strict';
+
+/**
+ * Normalize search results for export.
+ * @param {object} data - Raw search results data
+ * @param {object} options
+ * @returns {object} normalized
+ */
+function normalizeSearch(data, options = {}) {
+  const results = (data.results || []).map((r, i) => {
+    const item = {
+      rank: r.rank || i + 1,
+      score: r.score,
+      source: r.source || r.path || '',
+    };
+    if (r.rerankedScore !== undefined) item.rerankedScore = r.rerankedScore;
+    if (options.includeFullText) {
+      item.text = r.text || '';
+    } else {
+      item.text = (r.text || '').slice(0, 200);
+    }
+    if (options.includeMetadata !== false && r.metadata) {
+      item.metadata = r.metadata;
+    }
+    return item;
+  });
+
+  const normalized = {
+    _context: 'search',
+    results,
+  };
+
+  if (options.includeQuery !== false && data.query) {
+    normalized.query = data.query;
+    normalized._exportMeta = { query: data.query };
+  }
+  if (data.collection) normalized.collection = data.collection;
+  if (data.model) normalized.model = data.model;
+
+  // Flat rows for CSV
+  normalized.rows = results.map((r) => ({
+    rank: r.rank,
+    score: r.score,
+    reranked_score: r.rerankedScore ?? '',
+    source: r.source,
+    text_excerpt: (r.text || '').slice(0, 200),
+  }));
+
+  return normalized;
+}
+
+const SEARCH_FORMATS = ['json', 'jsonl', 'csv', 'markdown', 'clipboard'];
+
+module.exports = { normalizeSearch, SEARCH_FORMATS };

package/src/lib/export/contexts/workflow-export.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const { buildDependencyGraph } = require('../../workflow');
+
+/**
+ * Normalize a workflow definition for export.
+ * @param {object} workflow - Raw workflow JSON
+ * @param {object} options
+ * @param {boolean} [options.includeExecution=false]
+ * @param {boolean} [options.includeMetadata=false]
+ * @returns {object} normalized
+ */
+function normalizeWorkflow(workflow, options = {}) {
+  const normalized = {
+    _context: 'workflow',
+    name: workflow.name,
+    description: workflow.description,
+    version: workflow.version,
+    inputs: workflow.inputs || {},
+    defaults: workflow.defaults,
+    steps: workflow.steps || [],
+    output: workflow.output,
+  };
+
+  // Compute dependency map for markdown rendering (Map<string, Set> → plain obj)
+  const depGraphMap = buildDependencyGraph(workflow.steps || []);
+  const depGraph = {};
+  for (const [id, deps] of depGraphMap) {
+    depGraph[id] = [...deps];
+  }
+  normalized._dependencyMap = depGraph;
+
+  // Count execution layers
+  const layerCount = computeLayerCount(workflow.steps || [], depGraph);
+  normalized._executionLayers = layerCount;
+
+  if (options.includeExecution && workflow._execution) {
+    normalized._execution = workflow._execution;
+  }
+
+  if (options.includeMetadata) {
+    normalized._metadata = {
+      _exportedAt: new Date().toISOString(),
+      _source: workflow._source || 'local',
+    };
+  }
+
+  return normalized;
+}
+
+function computeLayerCount(steps, depGraph) {
+  if (steps.length === 0) return 0;
+  const inDegree = {};
+  const ids = steps.map((s) => s.id);
+  for (const id of ids) inDegree[id] = (depGraph[id] || []).length;
+  const remaining = new Set(ids);
+  let layers = 0;
+  while (remaining.size > 0) {
+    const layer = [];
+    for (const id of remaining) {
+      if ((inDegree[id] || 0) === 0) layer.push(id);
+    }
+    if (layer.length === 0) break;
+    layers++;
+    for (const id of layer) {
+      remaining.delete(id);
+      for (const [depId, deps] of Object.entries(depGraph)) {
+        if (remaining.has(depId) && deps.includes(id)) {
+          inDegree[depId]--;
+        }
+      }
+    }
+  }
+  return layers;
+}
+
+/** Supported export formats for workflows */
+const WORKFLOW_FORMATS = ['json', 'markdown', 'mermaid', 'svg', 'png', 'clipboard'];
+
+module.exports = { normalizeWorkflow, WORKFLOW_FORMATS };

package/src/lib/export/formats/clipboard-export.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const os = require('os');
+
+/**
+ * Copy text content to the system clipboard.
+ * @param {string} content - Text to copy
+ * @returns {boolean} success
+ */
+function copyToClipboard(content) {
+  const platform = os.platform();
+  try {
+    if (platform === 'darwin') {
+      execSync('pbcopy', { input: content, stdio: ['pipe', 'ignore', 'ignore'] });
+    } else if (platform === 'linux') {
+      execSync('xclip -selection clipboard', { input: content, stdio: ['pipe', 'ignore', 'ignore'] });
+    } else if (platform === 'win32') {
+      execSync('clip', { input: content, stdio: ['pipe', 'ignore', 'ignore'] });
+    } else {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { copyToClipboard };

package/src/lib/export/formats/csv-export.js

@@ -0,0 +1,45 @@
+'use strict';
+
+/**
+ * Escape a CSV field value.
+ * Wraps in quotes if the value contains commas, quotes, or newlines.
+ * @param {*} value
+ * @returns {string}
+ */
+function escapeField(value) {
+  if (value === null || value === undefined) return '';
+  const str = String(value);
+  if (str.includes('"') || str.includes(',') || str.includes('\n') || str.includes('\r')) {
+    return '"' + str.replace(/"/g, '""') + '"';
+  }
+  return str;
+}
+
+/**
+ * Render an array of objects as CSV.
+ * @param {object} normalized - Must have a `rows` or `results` array of flat objects
+ * @param {object} options
+ * @param {string[]} [options.columns] - Explicit column order; auto-detected if omitted
+ * @returns {{ content: string, mimeType: string }}
+ */
+function renderCsv(normalized, options = {}) {
+  const rows = normalized.rows || normalized.results || [];
+  if (!Array.isArray(rows) || rows.length === 0) {
+    return { content: '', mimeType: 'text/csv' };
+  }
+
+  // Determine columns
+  const columns = options.columns || Object.keys(rows[0]);
+
+  const header = columns.map(escapeField).join(',');
+  const body = rows.map((row) =>
+    columns.map((col) => escapeField(row[col])).join(',')
+  );
+
+  return {
+    content: [header, ...body].join('\n'),
+    mimeType: 'text/csv',
+  };
+}
+
+module.exports = { renderCsv, escapeField };